librats 1.0.2 → 2.2.0

package/native-src/src/{storage.cpp → librats/storage/storage.cpp}

@@ -1,14 +1,12 @@
-#include "storage.h"
-#include "crc32.h"
-#include "librats.h"
-#include "fs.h"
-#include "logger.h"
+#include "librats/storage/storage.h"
+#include "librats/node/node_context.h"
+#include "librats/crypto/crc32.h"
+#include "librats/util/fs.h"
+#include "librats/util/logger.h"
 #include <algorithm>
 #include <cstring>
 #include <cstdlib>
-#include <fstream>
-#include <sstream>
-#include <iomanip>
+#include <cstdio>
 
 // Define logging module for this file
 #define LOG_STORAGE_INFO(message) LOG_INFO("storage", message)
@@ -18,6 +16,14 @@
 
 namespace librats {
 
+namespace {
+
+void put_u32(std::vector<uint8_t>& b, uint32_t v) {
+    for (int i = 3; i >= 0; --i) b.push_back(static_cast<uint8_t>((v >> (i * 8)) & 0xFF));
+}
+
+} // namespace
+
 //=============================================================================
 // StorageEntry Implementation
 //=============================================================================
@@ -25,27 +31,27 @@ namespace librats {
 void StorageEntry::calculate_checksum() {
     // Calculate CRC32 over key + type + data + timestamp + peer_id
     std::vector<uint8_t> buffer;
-    
+
     // Add key
     buffer.insert(buffer.end(), key.begin(), key.end());
-    
+
     // Add type
     buffer.push_back(static_cast<uint8_t>(type));
-    
+
     // Add data
     buffer.insert(buffer.end(), data.begin(), data.end());
-    
+
     // Add timestamp (8 bytes, big endian)
     for (int i = 7; i >= 0; i--) {
         buffer.push_back(static_cast<uint8_t>((timestamp_ms >> (i * 8)) & 0xFF));
     }
-    
+
     // Add peer_id
     buffer.insert(buffer.end(), origin_peer_id.begin(), origin_peer_id.end());
-    
+
     // Add deleted flag
     buffer.push_back(deleted ? 1 : 0);
-    
+
     checksum = storage_calculate_crc32(buffer.data(), buffer.size());
 }
 
@@ -57,7 +63,7 @@ bool StorageEntry::verify_checksum() const {
 
 std::vector<uint8_t> StorageEntry::serialize() const {
     std::vector<uint8_t> buffer;
-    
+
     // Format:
     // [4 bytes] total_length (excluding this field)
     // [4 bytes] key_length
@@ -70,90 +76,90 @@ std::vector<uint8_t> StorageEntry::serialize() const {
     // [4 bytes] data_length
     // [data_length bytes] data
     // [4 bytes] checksum
-    
+
     // Calculate total size first
     uint32_t key_len = static_cast<uint32_t>(key.size());
     uint32_t peer_id_len = static_cast<uint32_t>(origin_peer_id.size());
     uint32_t data_len = static_cast<uint32_t>(data.size());
     uint32_t total_len = 4 + key_len + 1 + 1 + 8 + 4 + peer_id_len + 4 + data_len + 4;
-    
+
     buffer.reserve(4 + total_len);
-    
+
     // Total length (big endian)
     buffer.push_back((total_len >> 24) & 0xFF);
     buffer.push_back((total_len >> 16) & 0xFF);
     buffer.push_back((total_len >> 8) & 0xFF);
     buffer.push_back(total_len & 0xFF);
-    
+
     // Key length (big endian)
     buffer.push_back((key_len >> 24) & 0xFF);
     buffer.push_back((key_len >> 16) & 0xFF);
     buffer.push_back((key_len >> 8) & 0xFF);
     buffer.push_back(key_len & 0xFF);
-    
+
     // Key
     buffer.insert(buffer.end(), key.begin(), key.end());
-    
+
     // Type
     buffer.push_back(static_cast<uint8_t>(type));
-    
+
     // Deleted flag
     buffer.push_back(deleted ? 1 : 0);
-    
+
     // Timestamp (big endian)
     for (int i = 7; i >= 0; i--) {
         buffer.push_back(static_cast<uint8_t>((timestamp_ms >> (i * 8)) & 0xFF));
     }
-    
+
     // Peer ID length (big endian)
     buffer.push_back((peer_id_len >> 24) & 0xFF);
     buffer.push_back((peer_id_len >> 16) & 0xFF);
     buffer.push_back((peer_id_len >> 8) & 0xFF);
     buffer.push_back(peer_id_len & 0xFF);
-    
+
     // Peer ID
     buffer.insert(buffer.end(), origin_peer_id.begin(), origin_peer_id.end());
-    
+
     // Data length (big endian)
     buffer.push_back((data_len >> 24) & 0xFF);
     buffer.push_back((data_len >> 16) & 0xFF);
     buffer.push_back((data_len >> 8) & 0xFF);
     buffer.push_back(data_len & 0xFF);
-    
+
     // Data
     buffer.insert(buffer.end(), data.begin(), data.end());
-    
+
     // Checksum (big endian)
     buffer.push_back((checksum >> 24) & 0xFF);
     buffer.push_back((checksum >> 16) & 0xFF);
     buffer.push_back((checksum >> 8) & 0xFF);
     buffer.push_back(checksum & 0xFF);
-    
+
     return buffer;
 }
 
-bool StorageEntry::deserialize(const std::vector<uint8_t>& buffer, size_t offset, 
+bool StorageEntry::deserialize(const std::vector<uint8_t>& buffer, size_t offset,
                                StorageEntry& entry, size_t& bytes_read) {
     bytes_read = 0;
-    
+
     // Minimum size check (4 bytes for total_length)
     if (offset + 4 > buffer.size()) {
         return false;
     }
-    
+
     // Read total length
     uint32_t total_len = (static_cast<uint32_t>(buffer[offset]) << 24) |
                          (static_cast<uint32_t>(buffer[offset + 1]) << 16) |
                          (static_cast<uint32_t>(buffer[offset + 2]) << 8) |
                          static_cast<uint32_t>(buffer[offset + 3]);
-    
+
     // Check if we have enough data
     if (offset + 4 + total_len > buffer.size()) {
         return false;
     }
-    
+
     size_t pos = offset + 4;
-    
+
     // Read key length
     if (pos + 4 > buffer.size()) return false;
     uint32_t key_len = (static_cast<uint32_t>(buffer[pos]) << 24) |
@@ -161,22 +167,22 @@ bool StorageEntry::deserialize(const std::vector<uint8_t>& buffer, size_t offset
                        (static_cast<uint32_t>(buffer[pos + 2]) << 8) |
                        static_cast<uint32_t>(buffer[pos + 3]);
     pos += 4;
-    
+
     // Read key
     if (pos + key_len > buffer.size()) return false;
     entry.key = std::string(buffer.begin() + pos, buffer.begin() + pos + key_len);
     pos += key_len;
-    
+
     // Read type
     if (pos + 1 > buffer.size()) return false;
     entry.type = static_cast<StorageValueType>(buffer[pos]);
     pos += 1;
-    
+
     // Read deleted flag
     if (pos + 1 > buffer.size()) return false;
     entry.deleted = buffer[pos] != 0;
     pos += 1;
-    
+
     // Read timestamp
     if (pos + 8 > buffer.size()) return false;
     entry.timestamp_ms = 0;
@@ -184,7 +190,7 @@ bool StorageEntry::deserialize(const std::vector<uint8_t>& buffer, size_t offset
         entry.timestamp_ms = (entry.timestamp_ms << 8) | buffer[pos + i];
     }
     pos += 8;
-    
+
     // Read peer ID length
     if (pos + 4 > buffer.size()) return false;
     uint32_t peer_id_len = (static_cast<uint32_t>(buffer[pos]) << 24) |
@@ -192,12 +198,12 @@ bool StorageEntry::deserialize(const std::vector<uint8_t>& buffer, size_t offset
                            (static_cast<uint32_t>(buffer[pos + 2]) << 8) |
                            static_cast<uint32_t>(buffer[pos + 3]);
     pos += 4;
-    
+
     // Read peer ID
     if (pos + peer_id_len > buffer.size()) return false;
     entry.origin_peer_id = std::string(buffer.begin() + pos, buffer.begin() + pos + peer_id_len);
     pos += peer_id_len;
-    
+
     // Read data length
     if (pos + 4 > buffer.size()) return false;
     uint32_t data_len = (static_cast<uint32_t>(buffer[pos]) << 24) |
@@ -205,12 +211,12 @@ bool StorageEntry::deserialize(const std::vector<uint8_t>& buffer, size_t offset
                         (static_cast<uint32_t>(buffer[pos + 2]) << 8) |
                         static_cast<uint32_t>(buffer[pos + 3]);
     pos += 4;
-    
+
     // Read data
     if (pos + data_len > buffer.size()) return false;
     entry.data = std::vector<uint8_t>(buffer.begin() + pos, buffer.begin() + pos + data_len);
     pos += data_len;
-    
+
     // Read checksum
     if (pos + 4 > buffer.size()) return false;
     entry.checksum = (static_cast<uint32_t>(buffer[pos]) << 24) |
@@ -218,7 +224,7 @@ bool StorageEntry::deserialize(const std::vector<uint8_t>& buffer, size_t offset
                      (static_cast<uint32_t>(buffer[pos + 2]) << 8) |
                      static_cast<uint32_t>(buffer[pos + 3]);
     pos += 4;
-    
+
     bytes_read = pos - offset;
     return true;
 }
@@ -228,7 +234,7 @@ bool StorageEntry::wins_over(const StorageEntry& other) const {
     if (timestamp_ms != other.timestamp_ms) {
         return timestamp_ms > other.timestamp_ms;
     }
-    
+
     // Tie-breaker: lexicographic comparison of peer IDs
     return origin_peer_id > other.origin_peer_id;
 }
@@ -261,18 +267,17 @@ StorageValueType string_to_storage_value_type(const std::string& str) {
 // StorageManager Implementation
 //=============================================================================
 
-StorageManager::StorageManager(RatsClient& client, const StorageConfig& config)
-    : client_(client), 
-      config_(config),
+StorageManager::StorageManager(const StorageConfig& config)
+    : config_(config),
       sync_status_(StorageSyncStatus::NOT_STARTED),
       initial_sync_complete_(false),
       running_(true),
       dirty_(false) {
-    
+
     // Initialize statistics
     stats_ = StorageStatistics();
     stats_.sync_status = StorageSyncStatus::NOT_STARTED;
-    
+
     initialize();
 }
 
@@ -281,81 +286,57 @@ StorageManager::~StorageManager() {
 }
 
 void StorageManager::initialize() {
-    // Ensure data directory exists
+    // Ensure data directory exists and load any existing data from disk.
     if (config_.persist_to_disk) {
         create_directories(config_.data_directory.c_str());
-    }
-    
-    // Load existing data from disk
-    if (config_.persist_to_disk) {
         load();
-    }
-    
-    // Subscribe to GossipSub topic for real-time updates
-    if (config_.enable_sync && client_.is_gossipsub_available()) {
-        client_.subscribe_to_topic(STORAGE_GOSSIP_TOPIC);
-        
-        // Set up message handler for storage updates
-        client_.on_topic_message(STORAGE_GOSSIP_TOPIC, 
-            [this](const std::string& peer_id, const std::string& topic, const std::string& message) {
-                handle_gossip_message(peer_id, topic, message);
-            });
-    }
-    
-    // Register message handlers for sync protocol
-    if (config_.enable_sync) {
-        client_.on(MSG_TYPE_SYNC_REQUEST, [this](const std::string& peer_id, const nlohmann::json& data) {
-            handle_sync_request(peer_id, data);
-        });
-        
-        client_.on(MSG_TYPE_SYNC_RESPONSE, [this](const std::string& peer_id, const nlohmann::json& data) {
-            handle_sync_response(peer_id, data);
-        });
-    }
-    
-    // Start persistence thread
-    if (config_.persist_to_disk) {
         persistence_thread_ = std::thread(&StorageManager::persistence_thread_loop, this);
     }
-    
+
     LOG_STORAGE_INFO("StorageManager initialized with data directory: " << config_.data_directory);
 }
 
 void StorageManager::shutdown() {
+    // Idempotent: safe to call from both stop() and the destructor.
+    if (!running_.exchange(false)) return;
+
     LOG_STORAGE_INFO("StorageManager shutting down...");
-    
-    running_.store(false);
-    
+
     // Wake up persistence thread
     {
         std::lock_guard<std::mutex> lock(persistence_mutex_);
         persistence_cv_.notify_all();
     }
-    
+
     // Join persistence thread
     if (persistence_thread_.joinable()) {
         persistence_thread_.join();
     }
-    
+
     // Final save
-    if (config_.persist_to_disk && dirty_) {
+    bool needs_save;
+    {
+        std::lock_guard<std::mutex> lock(persistence_mutex_);
+        needs_save = dirty_;
+    }
+    if (config_.persist_to_disk && needs_save) {
         save();
     }
-    
+
     LOG_STORAGE_INFO("StorageManager shut down");
 }
 
 void StorageManager::persistence_thread_loop() {
     const auto save_interval = std::chrono::seconds(5);
-    
+
     while (running_.load()) {
         std::unique_lock<std::mutex> lock(persistence_mutex_);
-        persistence_cv_.wait_for(lock, save_interval, [this] { 
-            return !running_.load() || dirty_; 
+        persistence_cv_.wait_for(lock, save_interval, [this] {
+            return !running_.load() || dirty_;
         });
-        
+
         if (!running_.load()) break;
-        
+
         if (dirty_) {
             lock.unlock();
             save();
@@ -363,10 +344,34 @@ void StorageManager::persistence_thread_loop() {
     }
 }
 
+//=============================================================================
+// Subsystem
+//=============================================================================
+
+void StorageManager::attach(NodeContext& ctx) {
+    network_ = &ctx.network;
+
+    if (!config_.enable_sync) return;
+
+    network_->on(MessageType::Storage,
+        [this](const Peer& peer, ByteView payload) { on_storage_message(peer.id(), payload); });
+    network_->on_peer_connected(
+        [this](const Peer& peer) { on_peer_connected(peer.id()); });
+}
+
+void StorageManager::start() {
+    // The persistence thread is already running (started in the constructor) and
+    // sync is driven by peer events registered in attach(); nothing to spin up here.
+}
+
+void StorageManager::stop() {
+    shutdown();
+}
+
 void StorageManager::set_config(const StorageConfig& config) {
     std::lock_guard<std::mutex> lock(storage_mutex_);
     config_ = config;
-    
+
     if (config_.persist_to_disk) {
         create_directories(config_.data_directory.c_str());
     }
@@ -396,12 +401,12 @@ bool StorageManager::put(const std::string& key, const std::vector<uint8_t>& val
     return put_internal(key, StorageValueType::BINARY, value);
 }
 
-bool StorageManager::put_json(const std::string& key, const nlohmann::json& value) {
+bool StorageManager::put_json(const std::string& key, const librats::Json& value) {
     std::string json_str = value.dump();
     return put_internal(key, StorageValueType::JSON, serialize_value(json_str));
 }
 
-bool StorageManager::put_internal(const std::string& key, StorageValueType type, 
+bool StorageManager::put_internal(const std::string& key, StorageValueType type,
                                   const std::vector<uint8_t>& data,
                                   uint64_t timestamp_ms,
                                   const std::string& origin_peer_id,
@@ -410,22 +415,22 @@ bool StorageManager::put_internal(const std::string& key, StorageValueType type,
         LOG_STORAGE_ERROR("Cannot put with empty key");
         return false;
     }
-    
+
     if (data.size() > config_.max_value_size) {
         LOG_STORAGE_ERROR("Value size " << data.size() << " exceeds maximum " << config_.max_value_size);
         return false;
     }
-    
+
     // Use current time if not provided
     if (timestamp_ms == 0) {
         timestamp_ms = get_current_timestamp_ms();
     }
-    
+
     // Use our peer ID if not provided
     std::string peer_id = origin_peer_id.empty() ? get_our_peer_id() : origin_peer_id;
-    
+
     StorageEntry new_entry(key, type, data, timestamp_ms, peer_id);
-    
+
     StorageChangeEvent event;
     event.operation = StorageOperation::OP_PUT;
     event.key = key;
@@ -434,10 +439,10 @@ bool StorageManager::put_internal(const std::string& key, StorageValueType type,
     event.timestamp_ms = timestamp_ms;
     event.origin_peer_id = peer_id;
     event.is_remote = !origin_peer_id.empty() && origin_peer_id != get_our_peer_id();
-    
+
     {
         std::lock_guard<std::mutex> lock(storage_mutex_);
-        
+
         auto it = entries_.find(key);
         if (it != entries_.end()) {
             // Check LWW - only update if new entry wins
@@ -445,24 +450,24 @@ bool StorageManager::put_internal(const std::string& key, StorageValueType type,
                 LOG_STORAGE_DEBUG("Rejected put for key '" << key << "' - existing entry is newer");
                 return false;
             }
-            
+
             event.old_data = it->second.data;
             it->second = new_entry;
         } else {
             entries_[key] = new_entry;
         }
     }
-    
+
     mark_dirty();
-    
+
     // Broadcast to peers if this is a local change
     if (broadcast && config_.enable_sync) {
-        broadcast_put(new_entry);
+        broadcast_entry(new_entry);
     }
-    
+
     // Notify change callback
     notify_change(event);
-    
+
     LOG_STORAGE_DEBUG("Put key '" << key << "' with type " << storage_value_type_to_string(type));
     return true;
 }
@@ -473,104 +478,93 @@ bool StorageManager::put_internal(const std::string& key, StorageValueType type,
 
 std::optional<std::string> StorageManager::get_string(const std::string& key) const {
     std::lock_guard<std::mutex> lock(storage_mutex_);
-    
+
     auto it = entries_.find(key);
     if (it == entries_.end() || it->second.deleted) {
         return std::nullopt;
     }
-    
+
     if (it->second.type != StorageValueType::STRING) {
         return std::nullopt;
     }
-    
+
     return deserialize_string(it->second.data);
 }
 
 std::optional<int64_t> StorageManager::get_int(const std::string& key) const {
     std::lock_guard<std::mutex> lock(storage_mutex_);
-    
+
     auto it = entries_.find(key);
     if (it == entries_.end() || it->second.deleted) {
         return std::nullopt;
     }
-    
+
     if (it->second.type != StorageValueType::INT64) {
         return std::nullopt;
     }
-    
+
     return deserialize_int64(it->second.data);
 }
 
 std::optional<double> StorageManager::get_double(const std::string& key) const {
     std::lock_guard<std::mutex> lock(storage_mutex_);
-    
+
     auto it = entries_.find(key);
     if (it == entries_.end() || it->second.deleted) {
         return std::nullopt;
     }
-    
+
     if (it->second.type != StorageValueType::DOUBLE) {
         return std::nullopt;
     }
-    
+
     return deserialize_double(it->second.data);
 }
 
 std::optional<std::vector<uint8_t>> StorageManager::get_binary(const std::string& key) const {
     std::lock_guard<std::mutex> lock(storage_mutex_);
-    
+
     auto it = entries_.find(key);
     if (it == entries_.end() || it->second.deleted) {
         return std::nullopt;
     }
-    
+
     if (it->second.type != StorageValueType::BINARY) {
         return std::nullopt;
     }
-    
+
     return it->second.data;
 }
 
-std::optional<nlohmann::json> StorageManager::get_json(const std::string& key) const {
+std::optional<librats::Json> StorageManager::get_json(const std::string& key) const {
     std::lock_guard<std::mutex> lock(storage_mutex_);
-    
+
     auto it = entries_.find(key);
     if (it == entries_.end() || it->second.deleted) {
         return std::nullopt;
     }
-    
+
     if (it->second.type != StorageValueType::JSON) {
         return std::nullopt;
     }
-    
+
     try {
         std::string json_str = deserialize_string(it->second.data);
-        return nlohmann::json::parse(json_str);
+        return librats::Json::parse(json_str);
     } catch (const std::exception& e) {
         LOG_STORAGE_ERROR("Failed to parse JSON for key '" << key << "': " << e.what());
         return std::nullopt;
     }
 }
 
-const StorageEntry* StorageManager::get_entry(const std::string& key) const {
-    std::lock_guard<std::mutex> lock(storage_mutex_);
-    
-    auto it = entries_.find(key);
-    if (it == entries_.end() || it->second.deleted) {
-        return nullptr;
-    }
-    
-    return &it->second;
-}
-
 std::optional<StorageValueType> StorageManager::get_type(const std::string& key) const {
     std::lock_guard<std::mutex> lock(storage_mutex_);
-    
+
     auto it = entries_.find(key);
     if (it == entries_.end() || it->second.deleted) {
         return std::nullopt;
     }
-    
+
     return it->second.type;
 }
 
@@ -581,98 +575,100 @@ std::optional<StorageValueType> StorageManager::get_type(const std::string& key)
 bool StorageManager::remove(const std::string& key) {
     uint64_t timestamp_ms = get_current_timestamp_ms();
     std::string our_peer_id = get_our_peer_id();
-    
+
     StorageChangeEvent event;
     event.operation = StorageOperation::OP_DELETE;
     event.key = key;
     event.timestamp_ms = timestamp_ms;
     event.origin_peer_id = our_peer_id;
     event.is_remote = false;
-    
+
+    StorageEntry tombstone;
     {
         std::lock_guard<std::mutex> lock(storage_mutex_);
-        
+
         auto it = entries_.find(key);
         if (it == entries_.end()) {
             return false;
         }
-        
+
         if (it->second.deleted) {
             return false;  // Already deleted
         }
-        
+
         event.old_data = it->second.data;
-        
+
         // Mark as deleted (tombstone)
         it->second.deleted = true;
         it->second.timestamp_ms = timestamp_ms;
         it->second.origin_peer_id = our_peer_id;
         it->second.data.clear();
         it->second.calculate_checksum();
+        tombstone = it->second;
     }
-    
+
     mark_dirty();
-    
-    // Broadcast delete to peers
+
+    // Broadcast the tombstone to peers
     if (config_.enable_sync) {
-        broadcast_delete(key, timestamp_ms);
+        broadcast_entry(tombstone);
     }
-    
+
     // Notify change callback
     notify_change(event);
-    
+
     LOG_STORAGE_DEBUG("Deleted key '" << key << "'");
     return true;
 }
 
 bool StorageManager::has(const std::string& key) const {
     std::lock_guard<std::mutex> lock(storage_mutex_);
-    
+
     auto it = entries_.find(key);
     return it != entries_.end() && !it->second.deleted;
 }
 
 std::vector<std::string> StorageManager::keys() const {
     std::lock_guard<std::mutex> lock(storage_mutex_);
-    
+
     std::vector<std::string> result;
     result.reserve(entries_.size());
-    
+
     for (const auto& pair : entries_) {
         if (!pair.second.deleted) {
             result.push_back(pair.first);
         }
     }
-    
+
     return result;
 }
 
 std::vector<std::string> StorageManager::keys_with_prefix(const std::string& prefix) const {
     std::lock_guard<std::mutex> lock(storage_mutex_);
-    
+
     std::vector<std::string> result;
-    
+
     for (const auto& pair : entries_) {
-        if (!pair.second.deleted && 
+        if (!pair.second.deleted &&
             pair.first.size() >= prefix.size() &&
             pair.first.compare(0, prefix.size(), prefix) == 0) {
             result.push_back(pair.first);
         }
     }
-    
+
     return result;
 }
 
 size_t StorageManager::size() const {
     std::lock_guard<std::mutex> lock(storage_mutex_);
-    
+
     size_t count = 0;
     for (const auto& pair : entries_) {
         if (!pair.second.deleted) {
             count++;
         }
     }
-    
+
     return count;
 }
 
@@ -681,24 +677,22 @@ bool StorageManager::empty() const {
 }
 
 void StorageManager::clear() {
-    uint64_t timestamp_ms = get_current_timestamp_ms();
-    
     std::vector<std::string> keys_to_delete;
-    
+
     {
         std::lock_guard<std::mutex> lock(storage_mutex_);
-        
+
         for (auto& pair : entries_) {
             if (!pair.second.deleted) {
                 keys_to_delete.push_back(pair.first);
             }
         }
     }
-    
+
     for (const auto& key : keys_to_delete) {
         remove(key);
     }
-    
+
     LOG_STORAGE_INFO("Cleared all entries");
 }
 
@@ -710,16 +704,21 @@ bool StorageManager::save() {
     if (!config_.persist_to_disk) {
         return true;
     }
-    
+
     std::lock_guard<std::mutex> lock(storage_mutex_);
-    
+
     bool result = write_data_file();
-    
+
     if (result) {
-        dirty_ = false;
+        // dirty_ belongs to persistence_mutex_, not storage_mutex_ — the persistence
+        // thread reads it under that lock. Same order as load() (storage → persistence).
+        {
+            std::lock_guard<std::mutex> dirty_lock(persistence_mutex_);
+            dirty_ = false;
+        }
         LOG_STORAGE_DEBUG("Saved " << entries_.size() << " entries to disk");
     }
-    
+
     return result;
 }
 
@@ -727,29 +726,29 @@ bool StorageManager::load() {
     if (!config_.persist_to_disk) {
         return true;
     }
-    
+
     std::lock_guard<std::mutex> lock(storage_mutex_);
-    
+
     std::string data_path = get_data_file_path();
     if (!file_exists(data_path.c_str())) {
         LOG_STORAGE_DEBUG("No existing data file found at " << data_path);
         return true;  // Not an error, just no data yet
     }
-    
+
     bool result = read_data_file();
-    
+
     if (result) {
         LOG_STORAGE_INFO("Loaded " << entries_.size() << " entries from disk");
     }
-    
+
     return result;
 }
 
 size_t StorageManager::compact() {
     std::lock_guard<std::mutex> lock(storage_mutex_);
-    
+
     size_t removed = 0;
-    
+
     for (auto it = entries_.begin(); it != entries_.end();) {
         if (it->second.deleted) {
             it = entries_.erase(it);
@@ -758,12 +757,12 @@ size_t StorageManager::compact() {
             ++it;
         }
     }
-    
+
     if (removed > 0) {
         mark_dirty();
         LOG_STORAGE_INFO("Compacted storage, removed " << removed << " tombstones");
     }
-    
+
     return removed;
 }
 
@@ -772,29 +771,27 @@ size_t StorageManager::compact() {
 //=============================================================================
 
 bool StorageManager::request_sync() {
-    if (!config_.enable_sync) {
+    if (!config_.enable_sync || !network_) {
         return false;
     }
-    
+
     // Get a connected peer to sync from
-    auto peers = client_.get_validated_peers();
+    auto peers = network_->connected_peers();
     if (peers.empty()) {
         LOG_STORAGE_WARN("No peers available for sync");
         return false;
     }
-    
-    // Pick first available peer
-    std::string peer_id = peers[0].peer_id;
-    
+
+    const PeerId& peer_id = peers[0];
+
     {
         std::lock_guard<std::mutex> lock(sync_mutex_);
         sync_status_ = StorageSyncStatus::IN_PROGRESS;
-        sync_peer_id_ = peer_id;
     }
-    
+
     send_sync_request(peer_id);
-    
-    LOG_STORAGE_INFO("Requested sync from peer " << peer_id);
+
+    LOG_STORAGE_INFO("Requested sync from peer " << peer_id.short_hex());
     return true;
 }
 
@@ -826,17 +823,17 @@ void StorageManager::set_sync_complete_callback(StorageSyncCompleteCallback call
 
 StorageStatistics StorageManager::get_statistics() const {
     std::lock_guard<std::mutex> lock(stats_mutex_);
-    
+
     StorageStatistics result = stats_;
-    
+
     // Calculate current counts
     {
         std::lock_guard<std::mutex> storage_lock(storage_mutex_);
-        
+
         result.total_entries = 0;
         result.deleted_entries = 0;
         result.total_data_bytes = 0;
-        
+
         for (const auto& pair : entries_) {
             if (pair.second.deleted) {
                 result.deleted_entries++;
@@ -846,20 +843,20 @@ StorageStatistics StorageManager::get_statistics() const {
             }
         }
     }
-    
+
     {
         std::lock_guard<std::mutex> sync_lock(sync_mutex_);
         result.sync_status = sync_status_;
         result.last_sync_time = last_sync_time_;
     }
-    
+
     return result;
 }
 
-nlohmann::json StorageManager::get_statistics_json() const {
+librats::Json StorageManager::get_statistics_json() const {
     StorageStatistics stats = get_statistics();
-    
-    nlohmann::json result;
+
+    librats::Json result;
     result["total_entries"] = stats.total_entries;
     result["deleted_entries"] = stats.deleted_entries;
     result["total_data_bytes"] = stats.total_data_bytes;
@@ -868,231 +865,110 @@ nlohmann::json StorageManager::get_statistics_json() const {
     result["entries_sent"] = stats.entries_sent;
     result["sync_requests_received"] = stats.sync_requests_received;
     result["sync_requests_sent"] = stats.sync_requests_sent;
-    
+
     switch (stats.sync_status) {
         case StorageSyncStatus::NOT_STARTED: result["sync_status"] = "not_started"; break;
         case StorageSyncStatus::IN_PROGRESS: result["sync_status"] = "in_progress"; break;
         case StorageSyncStatus::COMPLETED: result["sync_status"] = "completed"; break;
         case StorageSyncStatus::FAILED: result["sync_status"] = "failed"; break;
     }
-    
+
     return result;
 }
 
 //=============================================================================
-// Network Message Handlers
+// Network Message Handlers (run on a reactor thread)
 //=============================================================================
 
-void StorageManager::handle_gossip_message(const std::string& peer_id, const std::string& topic, 
-                                           const std::string& message) {
-    if (topic != STORAGE_GOSSIP_TOPIC) {
-        return;
-    }
-    
-    try {
-        nlohmann::json msg = nlohmann::json::parse(message);
-        
-        std::string msg_type = msg.value("type", "");
-        
-        if (msg_type == "put") {
-            // Decode entry from message
-            std::string key = msg["key"];
-            std::string type_str = msg["value_type"];
-            std::string data_base64 = msg["data"];
-            uint64_t timestamp_ms = msg["timestamp"];
-            std::string origin_peer = msg["origin_peer"];
-            
-            // Decode base64 data
-            std::vector<uint8_t> data;
-            // Simple base64 decode (we'll implement inline)
-            static const std::string base64_chars = 
-                "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-            
-            std::vector<int> T(256, -1);
-            for (int i = 0; i < 64; i++) T[static_cast<unsigned char>(base64_chars[i])] = i;
-            
-            int val = 0, valb = -8;
-            for (unsigned char c : data_base64) {
-                if (T[c] == -1) break;
-                val = (val << 6) + T[c];
-                valb += 6;
-                if (valb >= 0) {
-                    data.push_back((val >> valb) & 0xFF);
-                    valb -= 8;
-                }
-            }
-            
-            StorageValueType value_type = string_to_storage_value_type(type_str);
-            
-            // Apply with LWW resolution
-            put_internal(key, value_type, data, timestamp_ms, origin_peer, false);
-            
-            {
-                std::lock_guard<std::mutex> lock(stats_mutex_);
-                stats_.entries_synced++;
-            }
-            
-        } else if (msg_type == "delete") {
-            std::string key = msg["key"];
-            uint64_t timestamp_ms = msg["timestamp"];
-            std::string origin_peer = msg["origin_peer"];
-            
-            // Apply delete with LWW
-            {
-                std::lock_guard<std::mutex> lock(storage_mutex_);
-                
-                auto it = entries_.find(key);
-                if (it != entries_.end()) {
-                    // Check if this delete is newer
-                    if (timestamp_ms > it->second.timestamp_ms ||
-                        (timestamp_ms == it->second.timestamp_ms && origin_peer > it->second.origin_peer_id)) {
-                        it->second.deleted = true;
-                        it->second.timestamp_ms = timestamp_ms;
-                        it->second.origin_peer_id = origin_peer;
-                        it->second.data.clear();
-                        it->second.calculate_checksum();
-                        mark_dirty();
-                    }
-                }
-            }
-            
+void StorageManager::on_storage_message(const PeerId& from, ByteView payload) {
+    if (payload.empty()) return;
+
+    const uint8_t* p = payload.data();
+    const size_t n = payload.size();
+    const uint8_t op = p[0];
+
+    if (op == OP_ENTRY) {
+        // Deserialize a single entry from the payload (after the opcode byte).
+        std::vector<uint8_t> buf(p + 1, p + n);
+        StorageEntry entry;
+        size_t bytes_read = 0;
+        if (!StorageEntry::deserialize(buf, 0, entry, bytes_read)) {
+            LOG_STORAGE_WARN("Malformed storage entry from " << from.short_hex());
+            return;
+        }
+        if (!entry.verify_checksum()) {
+            LOG_STORAGE_WARN("Checksum mismatch on entry '" << entry.key << "' from " << from.short_hex());
+            return;
+        }
+
+        StorageChangeEvent event;
+        if (apply_remote_entry(entry, &event)) {
             {
                 std::lock_guard<std::mutex> lock(stats_mutex_);
                 stats_.entries_synced++;
             }
+            mark_dirty();
+            notify_change(event);
+            // Re-flood to other peers; LWW makes a duplicate lose, so this stops.
+            forward_entry(entry, from);
         }
-        
-    } catch (const std::exception& e) {
-        LOG_STORAGE_ERROR("Failed to handle gossip message: " << e.what());
-    }
-}
-
-void StorageManager::handle_sync_request(const std::string& peer_id, const nlohmann::json& data) {
-    LOG_STORAGE_INFO("Received sync request from peer " << peer_id);
-    
-    {
-        std::lock_guard<std::mutex> lock(stats_mutex_);
-        stats_.sync_requests_received++;
-    }
-    
-    // Send full database snapshot
-    send_sync_response(peer_id);
-}
-
-void StorageManager::handle_sync_response(const std::string& peer_id, const nlohmann::json& data) {
-    LOG_STORAGE_INFO("Received sync response from peer " << peer_id);
-    
-    try {
-        if (!data.contains("entries") || !data["entries"].is_array()) {
-            LOG_STORAGE_ERROR("Invalid sync response format");
-            
-            {
-                std::lock_guard<std::mutex> lock(sync_mutex_);
-                sync_status_ = StorageSyncStatus::FAILED;
-            }
-            
-            if (sync_complete_callback_) {
-                sync_complete_callback_(false, "Invalid sync response format");
-            }
-            return;
+    } else if (op == OP_SYNC_REQUEST) {
+        {
+            std::lock_guard<std::mutex> lock(stats_mutex_);
+            stats_.sync_requests_received++;
         }
-        
+        send_sync_response(from);
+    } else if (op == OP_SYNC_RESPONSE) {
+        // [3][count:u32][entry]*
+        if (n < 5) return;
+        uint32_t count = (static_cast<uint32_t>(p[1]) << 24) |
+                         (static_cast<uint32_t>(p[2]) << 16) |
+                         (static_cast<uint32_t>(p[3]) << 8) |
+                         static_cast<uint32_t>(p[4]);
+        std::vector<uint8_t> buf(p + 5, p + n);
+        size_t offset = 0;
         int applied = 0;
-        
-        for (const auto& entry_json : data["entries"]) {
-            std::string key = entry_json["key"];
-            std::string type_str = entry_json["value_type"];
-            std::string data_base64 = entry_json["data"];
-            uint64_t timestamp_ms = entry_json["timestamp"];
-            std::string origin_peer = entry_json["origin_peer"];
-            bool deleted = entry_json.value("deleted", false);
-            
-            // Decode base64 data
-            std::vector<uint8_t> decoded_data;
-            static const std::string base64_chars = 
-                "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-            
-            std::vector<int> T(256, -1);
-            for (int i = 0; i < 64; i++) T[static_cast<unsigned char>(base64_chars[i])] = i;
-            
-            int val = 0, valb = -8;
-            for (unsigned char c : data_base64) {
-                if (T[c] == -1) break;
-                val = (val << 6) + T[c];
-                valb += 6;
-                if (valb >= 0) {
-                    decoded_data.push_back((val >> valb) & 0xFF);
-                    valb -= 8;
-                }
-            }
-            
-            StorageValueType value_type = string_to_storage_value_type(type_str);
-            
-            // Create entry
+        for (uint32_t i = 0; i < count && offset < buf.size(); i++) {
             StorageEntry entry;
-            entry.key = key;
-            entry.type = value_type;
-            entry.data = decoded_data;
-            entry.timestamp_ms = timestamp_ms;
-            entry.origin_peer_id = origin_peer;
-            entry.deleted = deleted;
-            entry.calculate_checksum();
-            
-            if (apply_remote_entry(entry)) {
+            size_t bytes_read = 0;
+            if (!StorageEntry::deserialize(buf, offset, entry, bytes_read)) break;
+            offset += bytes_read;
+            if (!entry.verify_checksum()) continue;
+
+            StorageChangeEvent event;
+            if (apply_remote_entry(entry, &event)) {
                 applied++;
+                notify_change(event);
             }
         }
-        
+
         {
             std::lock_guard<std::mutex> lock(sync_mutex_);
             sync_status_ = StorageSyncStatus::COMPLETED;
             initial_sync_complete_ = true;
             last_sync_time_ = std::chrono::steady_clock::now();
         }
-        
         {
             std::lock_guard<std::mutex> lock(stats_mutex_);
             stats_.entries_synced += applied;
         }
-        
-        mark_dirty();
-        
-        LOG_STORAGE_INFO("Sync completed, applied " << applied << " entries from peer " << peer_id);
-        
-        if (sync_complete_callback_) {
-            sync_complete_callback_(true, "");
-        }
-        
-    } catch (const std::exception& e) {
-        LOG_STORAGE_ERROR("Failed to handle sync response: " << e.what());
-        
-        {
-            std::lock_guard<std::mutex> lock(sync_mutex_);
-            sync_status_ = StorageSyncStatus::FAILED;
-        }
-        
-        if (sync_complete_callback_) {
-            sync_complete_callback_(false, e.what());
-        }
+        if (applied > 0) mark_dirty();
+
+        LOG_STORAGE_INFO("Sync from " << from.short_hex() << " applied " << applied << " entries");
+        if (sync_complete_callback_) sync_complete_callback_(true, "");
     }
 }
 
-void StorageManager::on_peer_connected(const std::string& peer_id) {
-    if (!config_.enable_sync) {
-        return;
-    }
-    
-    // If we haven't synced yet, request sync from this peer
+void StorageManager::on_peer_connected(const PeerId& peer_id) {
+    if (!config_.enable_sync) return;
+
+    // Anti-entropy: ask the new peer for a full snapshot. Both ends do this on
+    // connect, so the two databases converge via LWW.
     {
         std::lock_guard<std::mutex> lock(sync_mutex_);
-        if (!initial_sync_complete_ && sync_status_ != StorageSyncStatus::IN_PROGRESS) {
+        if (sync_status_ == StorageSyncStatus::NOT_STARTED)
             sync_status_ = StorageSyncStatus::IN_PROGRESS;
-            sync_peer_id_ = peer_id;
-        } else {
-            return;  // Already synced or in progress
-        }
     }
-    
     send_sync_request(peer_id);
 }
 
@@ -1124,7 +1000,7 @@ std::vector<uint8_t> StorageManager::serialize_value(const std::string& value) c
 
 int64_t StorageManager::deserialize_int64(const std::vector<uint8_t>& data) const {
     if (data.size() < 8) return 0;
-    
+
     int64_t value = 0;
     for (int i = 0; i < 8; i++) {
         value = (value << 8) | data[i];
@@ -1134,12 +1010,12 @@ int64_t StorageManager::deserialize_int64(const std::vector<uint8_t>& data) cons
 
 double StorageManager::deserialize_double(const std::vector<uint8_t>& data) const {
     if (data.size() < 8) return 0.0;
-    
+
     uint64_t bits = 0;
     for (int i = 0; i < 8; i++) {
         bits = (bits << 8) | data[i];
     }
-    
+
     double value;
     std::memcpy(&value, &bits, sizeof(double));
     return value;
@@ -1153,133 +1029,103 @@ std::string StorageManager::deserialize_string(const std::vector<uint8_t>& data)
 // Private Methods - Network Operations
 //=============================================================================
 
-void StorageManager::broadcast_put(const StorageEntry& entry) {
-    if (!client_.is_gossipsub_available()) {
-        return;
-    }
-    
-    // Base64 encode data
-    static const char* base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-    std::string data_base64;
-    
-    int val = 0, valb = -6;
-    for (uint8_t c : entry.data) {
-        val = (val << 8) + c;
-        valb += 8;
-        while (valb >= 0) {
-            data_base64.push_back(base64_chars[(val >> valb) & 0x3F]);
-            valb -= 6;
-        }
-    }
-    if (valb > -6) data_base64.push_back(base64_chars[((val << 8) >> (valb + 8)) & 0x3F]);
-    while (data_base64.size() % 4) data_base64.push_back('=');
-    
-    nlohmann::json msg;
-    msg["type"] = "put";
-    msg["key"] = entry.key;
-    msg["value_type"] = storage_value_type_to_string(entry.type);
-    msg["data"] = data_base64;
-    msg["timestamp"] = entry.timestamp_ms;
-    msg["origin_peer"] = entry.origin_peer_id;
-    
-    client_.publish_to_topic(STORAGE_GOSSIP_TOPIC, msg.dump());
-    
+void StorageManager::broadcast_entry(const StorageEntry& entry) {
+    if (!network_) return;
+
+    std::vector<uint8_t> msg;
+    msg.push_back(OP_ENTRY);
+    std::vector<uint8_t> serialized = entry.serialize();
+    msg.insert(msg.end(), serialized.begin(), serialized.end());
+
+    network_->broadcast(MessageType::Storage, ByteView(msg));
+
     {
         std::lock_guard<std::mutex> lock(stats_mutex_);
         stats_.entries_sent++;
     }
 }
 
-void StorageManager::broadcast_delete(const std::string& key, uint64_t timestamp_ms) {
-    if (!client_.is_gossipsub_available()) {
-        return;
-    }
-    
-    nlohmann::json msg;
-    msg["type"] = "delete";
-    msg["key"] = key;
-    msg["timestamp"] = timestamp_ms;
-    msg["origin_peer"] = get_our_peer_id();
-    
-    client_.publish_to_topic(STORAGE_GOSSIP_TOPIC, msg.dump());
-    
-    {
-        std::lock_guard<std::mutex> lock(stats_mutex_);
-        stats_.entries_sent++;
+void StorageManager::forward_entry(const StorageEntry& entry, const PeerId& except) {
+    if (!network_) return;
+
+    std::vector<uint8_t> msg;
+    msg.push_back(OP_ENTRY);
+    std::vector<uint8_t> serialized = entry.serialize();
+    msg.insert(msg.end(), serialized.begin(), serialized.end());
+    ByteView view(msg);
+
+    for (const PeerId& peer : network_->connected_peers()) {
+        if (peer == except) continue;
+        network_->send(peer, MessageType::Storage, view);
     }
 }
 
-void StorageManager::send_sync_request(const std::string& peer_id) {
-    nlohmann::json request;
-    request["request_id"] = get_current_timestamp_ms();
-    
-    client_.send(peer_id, MSG_TYPE_SYNC_REQUEST, request);
-    
+void StorageManager::send_sync_request(const PeerId& peer_id) {
+    if (!network_) return;
+
+    std::vector<uint8_t> msg{OP_SYNC_REQUEST};
+    network_->send(peer_id, MessageType::Storage, ByteView(msg));
+
     {
         std::lock_guard<std::mutex> lock(stats_mutex_);
         stats_.sync_requests_sent++;
     }
-    
-    LOG_STORAGE_DEBUG("Sent sync request to peer " << peer_id);
+
+    LOG_STORAGE_DEBUG("Sent sync request to peer " << peer_id.short_hex());
 }
 
-void StorageManager::send_sync_response(const std::string& peer_id) {
-    nlohmann::json response;
-    nlohmann::json entries_json = nlohmann::json::array();
-    
+void StorageManager::send_sync_response(const PeerId& peer_id) {
+    if (!network_) return;
+
+    std::vector<uint8_t> msg;
+    msg.push_back(OP_SYNC_RESPONSE);
+
+    uint32_t count = 0;
+    std::vector<uint8_t> entries_blob;
     {
         std::lock_guard<std::mutex> lock(storage_mutex_);
-        
         for (const auto& pair : entries_) {
-            const StorageEntry& entry = pair.second;
-            
-            // Base64 encode data
-            static const char* base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-            std::string data_base64;
-            
-            int val = 0, valb = -6;
-            for (uint8_t c : entry.data) {
-                val = (val << 8) + c;
-                valb += 8;
-                while (valb >= 0) {
-                    data_base64.push_back(base64_chars[(val >> valb) & 0x3F]);
-                    valb -= 6;
-                }
-            }
-            if (valb > -6) data_base64.push_back(base64_chars[((val << 8) >> (valb + 8)) & 0x3F]);
-            while (data_base64.size() % 4) data_base64.push_back('=');
-            
-            nlohmann::json entry_json;
-            entry_json["key"] = entry.key;
-            entry_json["value_type"] = storage_value_type_to_string(entry.type);
-            entry_json["data"] = data_base64;
-            entry_json["timestamp"] = entry.timestamp_ms;
-            entry_json["origin_peer"] = entry.origin_peer_id;
-            entry_json["deleted"] = entry.deleted;
-            
-            entries_json.push_back(entry_json);
+            std::vector<uint8_t> serialized = pair.second.serialize();
+            entries_blob.insert(entries_blob.end(), serialized.begin(), serialized.end());
+            count++;
         }
     }
-    
-    response["entries"] = entries_json;
-    
-    client_.send(peer_id, MSG_TYPE_SYNC_RESPONSE, response);
-    
-    LOG_STORAGE_DEBUG("Sent sync response to peer " << peer_id << " with " << entries_json.size() << " entries");
+
+    put_u32(msg, count);
+    msg.insert(msg.end(), entries_blob.begin(), entries_blob.end());
+
+    network_->send(peer_id, MessageType::Storage, ByteView(msg));
+
+    LOG_STORAGE_DEBUG("Sent sync response to peer " << peer_id.short_hex() << " with " << count << " entries");
 }
 
-bool StorageManager::apply_remote_entry(const StorageEntry& entry) {
-    std::lock_guard<std::mutex> lock(storage_mutex_);
-    
-    auto it = entries_.find(entry.key);
-    if (it != entries_.end()) {
-        // Check LWW
-        if (!entry.wins_over(it->second)) {
-            return false;  // Our entry is newer, don't apply
+bool StorageManager::apply_remote_entry(const StorageEntry& entry, StorageChangeEvent* out_event) {
+    StorageChangeEvent event;
+    event.operation = entry.deleted ? StorageOperation::OP_DELETE : StorageOperation::OP_PUT;
+    event.key = entry.key;
+    event.type = entry.type;
+    event.new_data = entry.data;
+    event.timestamp_ms = entry.timestamp_ms;
+    event.origin_peer_id = entry.origin_peer_id;
+    event.is_remote = true;
+
+    {
+        std::lock_guard<std::mutex> lock(storage_mutex_);
+
+        auto it = entries_.find(entry.key);
+        if (it != entries_.end()) {
+            // Check LWW
+            if (!entry.wins_over(it->second)) {
+                return false;  // Our entry is newer or identical, don't apply
+            }
+            event.old_data = it->second.data;
+            it->second = entry;
+        } else {
+            entries_[entry.key] = entry;
         }
     }
-    
-    entries_[entry.key] = entry;
+
+    if (out_event) *out_event = event;
     return true;
 }
 
@@ -1298,14 +1144,14 @@ std::string StorageManager::get_index_file_path() const {
 bool StorageManager::write_data_file() {
     std::string data_path = get_data_file_path();
     std::string temp_path = data_path + ".tmp";
-    
+
     try {
         FILE* file = fopen(temp_path.c_str(), "wb");
         if (!file) {
             LOG_STORAGE_ERROR("Failed to open temp file for writing: " << temp_path);
             return false;
         }
-        
+
         // Write file header
         // Magic: "RATS" (4 bytes)
         // Version: 1 (4 bytes)
@@ -1313,9 +1159,9 @@ bool StorageManager::write_data_file() {
         const char* magic = "RATS";
         uint32_t version = 1;
         uint32_t entry_count = static_cast<uint32_t>(entries_.size());
-        
+
         fwrite(magic, 1, 4, file);
-        
+
         uint8_t version_bytes[4] = {
             static_cast<uint8_t>((version >> 24) & 0xFF),
             static_cast<uint8_t>((version >> 16) & 0xFF),
@@ -1323,7 +1169,7 @@ bool StorageManager::write_data_file() {
             static_cast<uint8_t>(version & 0xFF)
         };
         fwrite(version_bytes, 1, 4, file);
-        
+
         uint8_t count_bytes[4] = {
             static_cast<uint8_t>((entry_count >> 24) & 0xFF),
             static_cast<uint8_t>((entry_count >> 16) & 0xFF),
@@ -1331,29 +1177,29 @@ bool StorageManager::write_data_file() {
             static_cast<uint8_t>(entry_count & 0xFF)
         };
         fwrite(count_bytes, 1, 4, file);
-        
+
         // Write each entry
         for (const auto& pair : entries_) {
             std::vector<uint8_t> serialized = pair.second.serialize();
             fwrite(serialized.data(), 1, serialized.size(), file);
         }
-        
+
         fclose(file);
-        
+
         // On Windows, rename fails if destination exists, so delete it first
         if (file_exists(data_path.c_str())) {
             delete_file(data_path.c_str());
         }
-        
+
         // Atomically rename temp file to final
         if (!rename_file(temp_path.c_str(), data_path.c_str())) {
             LOG_STORAGE_ERROR("Failed to rename temp file to final: " << temp_path << " -> " << data_path);
             delete_file(temp_path.c_str());
             return false;
         }
-        
+
         return true;
-        
+
     } catch (const std::exception& e) {
         LOG_STORAGE_ERROR("Exception while writing data file: " << e.what());
         delete_file(temp_path.c_str());
@@ -1363,7 +1209,7 @@ bool StorageManager::write_data_file() {
 
 bool StorageManager::read_data_file() {
     std::string data_path = get_data_file_path();
-    
+
     try {
         size_t file_size;
         void* file_data = read_file_binary(data_path.c_str(), &file_size);
@@ -1371,66 +1217,66 @@ bool StorageManager::read_data_file() {
             LOG_STORAGE_ERROR("Failed to read data file: " << data_path);
             return false;
         }
-        
-        std::vector<uint8_t> buffer(static_cast<uint8_t*>(file_data), 
+
+        std::vector<uint8_t> buffer(static_cast<uint8_t*>(file_data),
                                     static_cast<uint8_t*>(file_data) + file_size);
         free_file_buffer(file_data);
-        
+
         // Read header
         if (buffer.size() < 12) {
             LOG_STORAGE_ERROR("Data file too small: " << buffer.size());
             return false;
         }
-        
+
         // Check magic
         if (buffer[0] != 'R' || buffer[1] != 'A' || buffer[2] != 'T' || buffer[3] != 'S') {
             LOG_STORAGE_ERROR("Invalid magic in data file");
             return false;
         }
-        
+
         // Read version
         uint32_t version = (static_cast<uint32_t>(buffer[4]) << 24) |
                           (static_cast<uint32_t>(buffer[5]) << 16) |
                           (static_cast<uint32_t>(buffer[6]) << 8) |
                           static_cast<uint32_t>(buffer[7]);
-        
+
         if (version != 1) {
             LOG_STORAGE_ERROR("Unsupported data file version: " << version);
             return false;
         }
-        
+
         // Read entry count
         uint32_t entry_count = (static_cast<uint32_t>(buffer[8]) << 24) |
                               (static_cast<uint32_t>(buffer[9]) << 16) |
                               (static_cast<uint32_t>(buffer[10]) << 8) |
                               static_cast<uint32_t>(buffer[11]);
-        
+
         // Read entries
         entries_.clear();
         size_t offset = 12;
-        
+
         for (uint32_t i = 0; i < entry_count && offset < buffer.size(); i++) {
             StorageEntry entry;
             size_t bytes_read = 0;
-            
+
             if (!StorageEntry::deserialize(buffer, offset, entry, bytes_read)) {
                 LOG_STORAGE_ERROR("Failed to deserialize entry " << i << " at offset " << offset);
                 return false;
             }
-            
+
             // Verify checksum
             if (!entry.verify_checksum()) {
                 LOG_STORAGE_WARN("Checksum mismatch for entry '" << entry.key << "', skipping");
                 offset += bytes_read;
                 continue;
             }
-            
+
             entries_[entry.key] = entry;
             offset += bytes_read;
         }
-        
+
         return true;
-        
+
     } catch (const std::exception& e) {
         LOG_STORAGE_ERROR("Exception while reading data file: " << e.what());
         return false;
@@ -1448,7 +1294,8 @@ uint64_t StorageManager::get_current_timestamp_ms() const {
 }
 
 std::string StorageManager::get_our_peer_id() const {
-    return client_.get_our_peer_id();
+    if (!network_) return "";
+    return network_->local_id().to_hex();
 }
 
 void StorageManager::notify_change(const StorageChangeEvent& event) {