librats 1.0.2 → 2.2.0

package/native-src/src/librats_c.cpp

@@ -1,1557 +0,0 @@
-#include "librats_c.h"
-#include "librats.h"
-#include "logger.h"
-#include "ice.h"
-#include <stdlib.h>
-#include <string.h>
-#include <algorithm>
-#include <cctype>
-#include <unordered_map>
-#include <cstdio>
-
-using namespace librats;
-
-struct rats_client_wrapper {
-    std::unique_ptr<RatsClient> client;
-
-    // Stored C callbacks and user data
-    rats_connection_cb connection_cb = nullptr;
-    void* connection_ud = nullptr;
-
-    rats_string_cb string_cb = nullptr;
-    void* string_ud = nullptr;
-
-    rats_binary_cb binary_cb = nullptr;
-    void* binary_ud = nullptr;
-
-    rats_json_cb json_cb = nullptr;
-    void* json_ud = nullptr;
-
-    rats_disconnect_cb disconnect_cb = nullptr;
-    void* disconnect_ud = nullptr;
-
-    rats_peer_discovered_cb peer_discovered_cb = nullptr;
-    void* peer_discovered_ud = nullptr;
-
-    rats_file_progress_cb file_progress_cb = nullptr;
-    void* file_progress_ud = nullptr;
-
-    // File transfer callbacks
-    rats_file_request_cb file_request_cb = nullptr;
-    void* file_request_ud = nullptr;
-    
-    rats_directory_request_cb directory_request_cb = nullptr;
-    void* directory_request_ud = nullptr;
-    
-    rats_directory_progress_cb directory_progress_cb = nullptr;
-    void* directory_progress_ud = nullptr;
-
-    // Message handlers - using a simple map for demonstration
-    std::unordered_map<std::string, std::pair<rats_message_cb, void*>> message_handlers;
-    
-    // GossipSub topic callbacks
-    std::unordered_map<std::string, std::pair<rats_topic_message_cb, void*>> topic_message_handlers;
-    std::unordered_map<std::string, std::pair<rats_topic_json_message_cb, void*>> topic_json_message_handlers;
-    std::unordered_map<std::string, std::pair<rats_topic_peer_joined_cb, void*>> topic_peer_joined_handlers;
-    std::unordered_map<std::string, std::pair<rats_topic_peer_left_cb, void*>> topic_peer_left_handlers;
-};
-
-static char* rats_strdup_owned(const std::string& s) {
-    size_t n = s.size();
-    char* out = static_cast<char*>(malloc(n + 1));
-    if (!out) return nullptr;
-    memcpy(out, s.c_str(), n);
-    out[n] = '\0';
-    return out;
-}
-
-extern "C" {
-
-void rats_string_free(const char* str) {
-    if (str) free((void*)str);
-}
-
-const char* rats_get_version_string(void) {
-    return rats_get_library_version_string();
-}
-
-void rats_get_version(int* major, int* minor, int* patch, int* build) {
-    rats_get_library_version(major, minor, patch, build);
-}
-
-const char* rats_get_git_describe(void) {
-    return rats_get_library_git_describe();
-}
-
-uint32_t rats_get_abi(void) {
-    return rats_get_library_abi();
-}
-
-rats_client_t rats_create(int listen_port) {
-    try {
-        rats_client_wrapper* wrap = new rats_client_wrapper();
-        wrap->client = std::make_unique<RatsClient>(listen_port);
-        return static_cast<rats_client_t>(wrap);
-    } catch (...) {
-        return nullptr;
-    }
-}
-
-void rats_destroy(rats_client_t handle) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    // Ensure stopped
-    wrap->client->stop();
-    delete wrap;
-}
-
-int rats_start(rats_client_t handle) {
-    if (!handle) return RATS_ERROR_INVALID_HANDLE;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->start() ? RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-}
-
-void rats_stop(rats_client_t handle) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->stop();
-}
-
-int rats_connect(rats_client_t handle, const char* host, int port) {
-    if (!handle || !host) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->connect_to_peer(std::string(host), port) ? 1 : 0;
-}
-
-int rats_get_listen_port(rats_client_t handle) {
-    if (!handle) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->get_listen_port();
-}
-
-int rats_broadcast_string(rats_client_t handle, const char* message) {
-    if (!handle || !message) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->broadcast_string_to_peers(std::string(message));
-}
-
-int rats_send_string(rats_client_t handle, const char* peer_id, const char* message) {
-    if (!handle) return RATS_ERROR_INVALID_HANDLE;
-    if (!peer_id || !message) return RATS_ERROR_INVALID_PARAMETER;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->send_string_to_peer_id(std::string(peer_id), std::string(message)) ? RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-}
-
-int rats_get_peer_count(rats_client_t handle) {
-    if (!handle) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->get_peer_count();
-}
-
-char* rats_get_our_peer_id(rats_client_t handle) {
-    if (!handle) return nullptr;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return rats_strdup_owned(wrap->client->get_our_peer_id());
-}
-
-char* rats_get_connection_statistics_json(rats_client_t handle) {
-    if (!handle) return nullptr;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    auto json = wrap->client->get_connection_statistics();
-    return rats_strdup_owned(json.dump());
-}
-
-void rats_set_console_logging_enabled(int enabled) {
-    Logger::getInstance().set_console_logging_enabled(enabled != 0);
-}
-
-int rats_is_console_logging_enabled(void) {
-    return Logger::getInstance().is_console_logging_enabled() ? 1 : 0;
-}
-
-void rats_set_logging_enabled(int enabled) {
-    // Global logger control through any client instance is awkward; use singleton
-    Logger::getInstance().set_file_logging_enabled(enabled != 0);
-}
-
-void rats_set_log_level(const char* level_str) {
-    if (!level_str) return;
-    std::string lvl(level_str);
-    // Map string to LogLevel
-    std::string upper = lvl;
-    std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
-    LogLevel level = LogLevel::INFO;
-    if (upper == "DEBUG") level = LogLevel::DEBUG;
-    else if (upper == "INFO") level = LogLevel::INFO;
-    else if (upper == "WARN" || upper == "WARNING") level = LogLevel::WARN;
-    else if (upper == "ERROR") level = LogLevel::ERROR;
-    Logger::getInstance().set_log_level(level);
-}
-
-
-void rats_set_log_file_path(rats_client_t handle, const char* file_path) {
-    if (!handle || !file_path) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->set_log_file_path(std::string(file_path));
-}
-
-char* rats_get_log_file_path(rats_client_t handle) {
-    if (!handle) return nullptr;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return rats_strdup_owned(wrap->client->get_log_file_path());
-}
-
-void rats_set_log_colors_enabled(rats_client_t handle, int enabled) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->set_log_colors_enabled(enabled != 0);
-}
-
-int rats_is_log_colors_enabled(rats_client_t handle) {
-    if (!handle) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->is_log_colors_enabled() ? 1 : 0;
-}
-
-void rats_set_log_timestamps_enabled(rats_client_t handle, int enabled) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->set_log_timestamps_enabled(enabled != 0);
-}
-
-int rats_is_log_timestamps_enabled(rats_client_t handle) {
-    if (!handle) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->is_log_timestamps_enabled() ? 1 : 0;
-}
-
-void rats_set_log_rotation_size(rats_client_t handle, size_t max_size_bytes) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->set_log_rotation_size(max_size_bytes);
-}
-
-void rats_set_log_retention_count(rats_client_t handle, int count) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->set_log_retention_count(count);
-}
-
-void rats_set_log_rotate_on_startup(rats_client_t handle, int enabled) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->set_log_rotate_on_startup(enabled != 0);
-}
-
-int rats_is_log_rotate_on_startup_enabled(rats_client_t handle) {
-    if (!handle) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->is_log_rotate_on_startup_enabled() ? 1 : 0;
-}
-
-void rats_clear_log_file(rats_client_t handle) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->clear_log_file();
-}
-
-void rats_set_connection_callback(rats_client_t handle, rats_connection_cb cb, void* user_data) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->connection_cb = cb;
-    wrap->connection_ud = user_data;
-    wrap->client->set_connection_callback([wrap](socket_t, const std::string& peer_id) {
-        if (wrap->connection_cb) {
-            wrap->connection_cb(wrap->connection_ud, peer_id.c_str());
-        }
-    });
-}
-
-void rats_set_string_callback(rats_client_t handle, rats_string_cb cb, void* user_data) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->string_cb = cb;
-    wrap->string_ud = user_data;
-    wrap->client->set_string_data_callback([wrap](socket_t, const std::string& peer_id, const std::string& data) {
-        if (wrap->string_cb) {
-            wrap->string_cb(wrap->string_ud, peer_id.c_str(), data.c_str());
-        }
-    });
-}
-
-void rats_set_disconnect_callback(rats_client_t handle, rats_disconnect_cb cb, void* user_data) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->disconnect_cb = cb;
-    wrap->disconnect_ud = user_data;
-    wrap->client->set_disconnect_callback([wrap](socket_t, const std::string& peer_id) {
-        if (wrap->disconnect_cb) {
-            wrap->disconnect_cb(wrap->disconnect_ud, peer_id.c_str());
-        }
-    });
-}
-
-// ===================== NEW C API IMPLEMENTATIONS =====================
-
-// Peer configuration
-rats_error_t rats_set_max_peers(rats_client_t handle, int max_peers) {
-    if (!handle) return RATS_ERROR_INVALID_HANDLE;
-    if (max_peers <= 0) return RATS_ERROR_INVALID_PARAMETER;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->set_max_peers(max_peers);
-    return RATS_SUCCESS;
-}
-
-int rats_get_max_peers(rats_client_t handle) {
-    if (!handle) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->get_max_peers();
-}
-
-int rats_is_peer_limit_reached(rats_client_t handle) {
-    if (!handle) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->is_peer_limit_reached() ? 1 : 0;
-}
-
-rats_error_t rats_disconnect_peer_by_id(rats_client_t handle, const char* peer_id) {
-    if (!handle || !peer_id) return RATS_ERROR_INVALID_PARAMETER;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->disconnect_peer_by_id(std::string(peer_id));
-    return RATS_SUCCESS;
-}
-
-// Binary data operations  
-rats_error_t rats_send_binary(rats_client_t handle, const char* peer_id, const void* data, size_t size) {
-    if (!handle || !peer_id || !data || size == 0) return RATS_ERROR_INVALID_PARAMETER;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    std::vector<uint8_t> binary_data(static_cast<const uint8_t*>(data), 
-                                     static_cast<const uint8_t*>(data) + size);
-    
-    return wrap->client->send_binary_to_peer_id(std::string(peer_id), binary_data) ? 
-           RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-}
-
-int rats_broadcast_binary(rats_client_t handle, const void* data, size_t size) {
-    if (!handle || !data || size == 0) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    std::vector<uint8_t> binary_data(static_cast<const uint8_t*>(data), 
-                                     static_cast<const uint8_t*>(data) + size);
-    
-    return wrap->client->broadcast_binary_to_peers(binary_data);
-}
-
-// JSON operations
-rats_error_t rats_send_json(rats_client_t handle, const char* peer_id, const char* json_str) {
-    if (!handle || !peer_id || !json_str) return RATS_ERROR_INVALID_PARAMETER;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    try {
-        nlohmann::json json_data = nlohmann::json::parse(json_str);
-        return wrap->client->send_json_to_peer_id(std::string(peer_id), json_data) ? 
-               RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-    } catch (const nlohmann::json::exception&) {
-        return RATS_ERROR_JSON_PARSE;
-    }
-}
-
-int rats_broadcast_json(rats_client_t handle, const char* json_str) {
-    if (!handle || !json_str) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    try {
-        nlohmann::json json_data = nlohmann::json::parse(json_str);
-        return wrap->client->broadcast_json_to_peers(json_data);
-    } catch (const nlohmann::json::exception&) {
-        return 0;
-    }
-}
-
-// DHT Discovery
-rats_error_t rats_start_dht_discovery(rats_client_t handle, int dht_port) {
-    if (!handle) return RATS_ERROR_INVALID_HANDLE;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->start_dht_discovery(dht_port) ? RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-}
-
-void rats_stop_dht_discovery(rats_client_t handle) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->stop_dht_discovery();
-}
-
-int rats_is_dht_running(rats_client_t handle) {
-    if (!handle) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->is_dht_running() ? 1 : 0;
-}
-
-rats_error_t rats_announce_for_hash(rats_client_t handle, const char* content_hash, int port,
-                                    rats_peers_found_cb callback, void* user_data) {
-    if (!handle || !content_hash) return RATS_ERROR_INVALID_PARAMETER;
-    if (strlen(content_hash) != 40) return RATS_ERROR_INVALID_PARAMETER; // SHA1 hash must be 40 chars
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    uint16_t announce_port = (port <= 0) ? 0 : static_cast<uint16_t>(port);
-    
-    // Create C++ callback wrapper if C callback is provided
-    std::function<void(const std::vector<std::string>&)> cpp_callback = nullptr;
-    if (callback) {
-        cpp_callback = [callback, user_data](const std::vector<std::string>& peers) {
-            // Convert vector to C-style array
-            std::vector<const char*> c_peers;
-            c_peers.reserve(peers.size());
-            for (const auto& peer : peers) {
-                c_peers.push_back(peer.c_str());
-            }
-            callback(user_data, c_peers.data(), static_cast<int>(c_peers.size()));
-        };
-    }
-    
-    return wrap->client->announce_for_hash(std::string(content_hash), announce_port, cpp_callback) ? 
-           RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-}
-
-size_t rats_get_dht_routing_table_size(rats_client_t handle) {
-    if (!handle) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->get_dht_routing_table_size();
-}
-
-// Automatic discovery
-
-void rats_start_automatic_peer_discovery(rats_client_t handle) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->start_automatic_peer_discovery();
-}
-
-void rats_stop_automatic_peer_discovery(rats_client_t handle) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->stop_automatic_peer_discovery();
-}
-
-int rats_is_automatic_discovery_running(rats_client_t handle) {
-    if (!handle) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->is_automatic_discovery_running() ? 1 : 0;
-}
-
-char* rats_get_discovery_hash(rats_client_t handle) {
-    if (!handle) return nullptr;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return rats_strdup_owned(wrap->client->get_discovery_hash());
-}
-
-char* rats_get_rats_peer_discovery_hash(void) {
-    return rats_strdup_owned(RatsClient::get_rats_peer_discovery_hash());
-}
-
-// mDNS Discovery
-rats_error_t rats_start_mdns_discovery(rats_client_t handle, const char* service_name) {
-    if (!handle) return RATS_ERROR_INVALID_HANDLE;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    std::string service = service_name ? std::string(service_name) : std::string("");
-    return wrap->client->start_mdns_discovery(service) ? RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-}
-
-void rats_stop_mdns_discovery(rats_client_t handle) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->stop_mdns_discovery();
-}
-
-int rats_is_mdns_running(rats_client_t handle) {
-    if (!handle) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->is_mdns_running() ? 1 : 0;
-}
-
-rats_error_t rats_query_mdns_services(rats_client_t handle) {
-    if (!handle) return RATS_ERROR_INVALID_HANDLE;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->query_mdns_services() ? RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-}
-
-// Encryption
-rats_error_t rats_set_encryption_enabled(rats_client_t handle, int enabled) {
-    if (!handle) return RATS_ERROR_INVALID_HANDLE;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->set_encryption_enabled(enabled != 0);
-    return RATS_SUCCESS;
-}
-
-int rats_is_encryption_enabled(rats_client_t handle) {
-    if (!handle) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->is_encryption_enabled() ? 1 : 0;
-}
-
-// Protocol configuration
-rats_error_t rats_set_protocol_name(rats_client_t handle, const char* protocol_name) {
-    if (!handle || !protocol_name) return RATS_ERROR_INVALID_PARAMETER;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->set_protocol_name(std::string(protocol_name));
-    return RATS_SUCCESS;
-}
-
-rats_error_t rats_set_protocol_version(rats_client_t handle, const char* protocol_version) {
-    if (!handle || !protocol_version) return RATS_ERROR_INVALID_PARAMETER;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->set_protocol_version(std::string(protocol_version));
-    return RATS_SUCCESS;
-}
-
-char* rats_get_protocol_name(rats_client_t handle) {
-    if (!handle) return nullptr;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return rats_strdup_owned(wrap->client->get_protocol_name());
-}
-
-char* rats_get_protocol_version(rats_client_t handle) {
-    if (!handle) return nullptr;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return rats_strdup_owned(wrap->client->get_protocol_version());
-}
-
-// Message Exchange API
-rats_error_t rats_on_message(rats_client_t handle, const char* message_type, 
-                             rats_message_cb callback, void* user_data) {
-    if (!handle || !message_type || !callback) return RATS_ERROR_INVALID_PARAMETER;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    // Store the C callback
-    wrap->message_handlers[std::string(message_type)] = std::make_pair(callback, user_data);
-    
-    // Set up C++ callback that calls the C callback
-    wrap->client->on(std::string(message_type), [wrap, callback, user_data](const std::string& peer_id, const nlohmann::json& data) {
-        if (callback) {
-            std::string json_str = data.dump();
-            callback(user_data, peer_id.c_str(), json_str.c_str());
-        }
-    });
-    
-    return RATS_SUCCESS;
-}
-
-rats_error_t rats_send_message(rats_client_t handle, const char* peer_id, 
-                               const char* message_type, const char* data) {
-    if (!handle || !peer_id || !message_type || !data) return RATS_ERROR_INVALID_PARAMETER;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    try {
-        nlohmann::json json_data = nlohmann::json::parse(data);
-        wrap->client->send(std::string(peer_id), std::string(message_type), json_data);
-        return RATS_SUCCESS;
-    } catch (const nlohmann::json::exception&) {
-        // If not valid JSON, send as string value
-        nlohmann::json string_data = std::string(data);
-        wrap->client->send(std::string(peer_id), std::string(message_type), string_data);
-        return RATS_SUCCESS;
-    }
-}
-
-rats_error_t rats_broadcast_message(rats_client_t handle, const char* message_type, const char* data) {
-    if (!handle || !message_type || !data) return RATS_ERROR_INVALID_PARAMETER;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    try {
-        nlohmann::json json_data = nlohmann::json::parse(data);
-        wrap->client->send(std::string(message_type), json_data);
-        return RATS_SUCCESS;
-    } catch (const nlohmann::json::exception&) {
-        // If not valid JSON, send as string value
-        nlohmann::json string_data = std::string(data);
-        wrap->client->send(std::string(message_type), string_data);
-        return RATS_SUCCESS;
-    }
-}
-
-// File Transfer
-char* rats_send_file(rats_client_t handle, const char* peer_id, 
-                     const char* file_path, const char* remote_filename) {
-    if (!handle || !peer_id || !file_path) return nullptr;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    std::string remote_name = remote_filename ? std::string(remote_filename) : std::string("");
-    std::string transfer_id = wrap->client->send_file(std::string(peer_id), 
-                                                      std::string(file_path), remote_name);
-    
-    return transfer_id.empty() ? nullptr : rats_strdup_owned(transfer_id);
-}
-
-rats_error_t rats_accept_file_transfer(rats_client_t handle, const char* transfer_id, 
-                                       const char* local_path) {
-    if (!handle || !transfer_id || !local_path) return RATS_ERROR_INVALID_PARAMETER;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    return wrap->client->accept_file_transfer(std::string(transfer_id), std::string(local_path)) ? 
-           RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-}
-
-rats_error_t rats_reject_file_transfer(rats_client_t handle, const char* transfer_id, 
-                                       const char* reason) {
-    if (!handle || !transfer_id) return RATS_ERROR_INVALID_PARAMETER;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    std::string reject_reason = reason ? std::string(reason) : std::string("");
-    return wrap->client->reject_file_transfer(std::string(transfer_id), reject_reason) ? 
-           RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-}
-
-rats_error_t rats_cancel_file_transfer(rats_client_t handle, const char* transfer_id) {
-    if (!handle || !transfer_id) return RATS_ERROR_INVALID_PARAMETER;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    return wrap->client->cancel_file_transfer(std::string(transfer_id)) ? 
-           RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-}
-
-// Enhanced callbacks
-void rats_set_binary_callback(rats_client_t handle, rats_binary_cb cb, void* user_data) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->binary_cb = cb;
-    wrap->binary_ud = user_data;
-    wrap->client->set_binary_data_callback([wrap](socket_t, const std::string& peer_id, const std::vector<uint8_t>& data) {
-        if (wrap->binary_cb) {
-            wrap->binary_cb(wrap->binary_ud, peer_id.c_str(), data.data(), data.size());
-        }
-    });
-}
-
-void rats_set_json_callback(rats_client_t handle, rats_json_cb cb, void* user_data) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->json_cb = cb;
-    wrap->json_ud = user_data;
-    wrap->client->set_json_data_callback([wrap](socket_t, const std::string& peer_id, const nlohmann::json& data) {
-        if (wrap->json_cb) {
-            std::string json_str = data.dump();
-            wrap->json_cb(wrap->json_ud, peer_id.c_str(), json_str.c_str());
-        }
-    });
-}
-
-void rats_set_peer_discovered_callback(rats_client_t handle, rats_peer_discovered_cb cb, void* user_data) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->peer_discovered_cb = cb;
-    wrap->peer_discovered_ud = user_data;
-    wrap->client->set_mdns_callback([wrap](const std::string& host, int port, const std::string& service_name) {
-        if (wrap->peer_discovered_cb) {
-            wrap->peer_discovered_cb(wrap->peer_discovered_ud, host.c_str(), port, service_name.c_str());
-        }
-    });
-}
-
-void rats_set_file_progress_callback(rats_client_t handle, rats_file_progress_cb cb, void* user_data) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->file_progress_cb = cb;
-    wrap->file_progress_ud = user_data;
-    
-    wrap->client->on_file_transfer_progress([wrap](const FileTransferProgress& progress) {
-        if (wrap->file_progress_cb) {
-            int progress_percent = progress.get_completion_percentage();
-            std::string status_str = "IN_PROGRESS"; // Default status
-            switch (progress.status) {
-                case FileTransferStatus::PENDING: status_str = "PENDING"; break;
-                case FileTransferStatus::STARTING: status_str = "STARTING"; break;
-                case FileTransferStatus::IN_PROGRESS: status_str = "IN_PROGRESS"; break;
-                case FileTransferStatus::PAUSED: status_str = "PAUSED"; break;
-                case FileTransferStatus::COMPLETED: status_str = "COMPLETED"; break;
-                case FileTransferStatus::FAILED: status_str = "FAILED"; break;
-                case FileTransferStatus::CANCELLED: status_str = "CANCELLED"; break;
-                case FileTransferStatus::RESUMING: status_str = "RESUMING"; break;
-            }
-            wrap->file_progress_cb(wrap->file_progress_ud, progress.transfer_id.c_str(), progress_percent, status_str.c_str());
-        }
-    });
-}
-
-char* rats_send_directory(rats_client_t handle, const char* peer_id, const char* directory_path, const char* remote_directory_name, int recursive) {
-    if (!handle || !peer_id || !directory_path) return nullptr;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    std::string remote_name = remote_directory_name ? std::string(remote_directory_name) : std::string("");
-    (void)recursive; // directory transfers are always recursive
-    std::string transfer_id = wrap->client->send_directory(std::string(peer_id), std::string(directory_path), remote_name);
-
-    return transfer_id.empty() ? nullptr : rats_strdup_owned(transfer_id);
-}
-
-// Pull-style requests are not supported in this version; transfers are push-only.
-char* rats_request_file(rats_client_t handle, const char* peer_id, const char* remote_file_path, const char* local_path) {
-    (void)handle; (void)peer_id; (void)remote_file_path; (void)local_path;
-    return nullptr;
-}
-
-char* rats_request_directory(rats_client_t handle, const char* peer_id, const char* remote_directory_path, const char* local_directory_path, int recursive) {
-    (void)handle; (void)peer_id; (void)remote_directory_path; (void)local_directory_path; (void)recursive;
-    return nullptr;
-}
-
-rats_error_t rats_accept_directory_transfer(rats_client_t handle, const char* transfer_id, const char* local_path) {
-    if (!handle || !transfer_id || !local_path) return RATS_ERROR_INVALID_PARAMETER;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-
-    return wrap->client->accept_file_transfer(std::string(transfer_id), std::string(local_path)) ? RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-}
-
-rats_error_t rats_reject_directory_transfer(rats_client_t handle, const char* transfer_id, const char* reason) {
-    if (!handle || !transfer_id) return RATS_ERROR_INVALID_PARAMETER;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-
-    std::string reject_reason = reason ? std::string(reason) : std::string("");
-    return wrap->client->reject_file_transfer(std::string(transfer_id), reject_reason) ? RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-}
-
-rats_error_t rats_pause_file_transfer(rats_client_t handle, const char* transfer_id) {
-    if (!handle || !transfer_id) return RATS_ERROR_INVALID_PARAMETER;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    return wrap->client->pause_file_transfer(std::string(transfer_id)) ? RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-}
-
-rats_error_t rats_resume_file_transfer(rats_client_t handle, const char* transfer_id) {
-    if (!handle || !transfer_id) return RATS_ERROR_INVALID_PARAMETER;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    return wrap->client->resume_file_transfer(std::string(transfer_id)) ? RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-}
-
-char* rats_get_file_transfer_progress_json(rats_client_t handle, const char* transfer_id) {
-    if (!handle || !transfer_id) return nullptr;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    auto progress = wrap->client->get_file_transfer_progress(std::string(transfer_id));
-    if (!progress) return nullptr;
-    
-    // Convert progress to JSON
-    nlohmann::json progress_json;
-    progress_json["transfer_id"] = progress->transfer_id;
-    progress_json["filename"] = progress->filename;
-    progress_json["local_path"] = progress->local_path;
-    progress_json["peer_id"] = progress->peer_id;
-    progress_json["bytes_transferred"] = progress->bytes_transferred;
-    progress_json["total_bytes"] = progress->total_bytes;
-    progress_json["completion_percentage"] = progress->get_completion_percentage();
-    progress_json["status"] = static_cast<int>(progress->status);
-    progress_json["direction"] = static_cast<int>(progress->direction);
-    
-    return rats_strdup_owned(progress_json.dump());
-}
-
-char* rats_get_file_transfer_statistics_json(rats_client_t handle) {
-    if (!handle) return nullptr;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    auto stats = wrap->client->get_file_transfer_statistics();
-    return rats_strdup_owned(stats.dump());
-}
-
-// File transfer callback setters
-void rats_set_file_request_callback(rats_client_t handle, rats_file_request_cb cb, void* user_data) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->file_request_cb = cb;
-    wrap->file_request_ud = user_data;
-    
-    if (cb) {
-        // Fires for every incoming offer (file or directory). The C app should
-        // then call rats_accept_file_transfer()/rats_reject_file_transfer().
-        wrap->client->on_file_transfer_request([wrap](const IncomingTransferOffer& offer) {
-            if (wrap->file_request_cb) {
-                wrap->file_request_cb(wrap->file_request_ud, offer.peer_id.c_str(),
-                                      offer.transfer_id.c_str(), "", offer.name.c_str());
-            }
-        });
-    }
-}
-
-// Directory offers arrive through the unified file-request callback above;
-// this setter is kept for ABI compatibility and simply records the callback.
-void rats_set_directory_request_callback(rats_client_t handle, rats_directory_request_cb cb, void* user_data) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->directory_request_cb = cb;
-    wrap->directory_request_ud = user_data;
-}
-
-// Directory progress arrives through the unified file-progress callback above;
-// this setter is kept for ABI compatibility and simply records the callback.
-void rats_set_directory_progress_callback(rats_client_t handle, rats_directory_progress_cb cb, void* user_data) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->directory_progress_cb = cb;
-    wrap->directory_progress_ud = user_data;
-}
-
-// Peer information
-char** rats_get_peer_ids(rats_client_t handle, int* count) {
-    if (!handle || !count) {
-        if (count) *count = 0;
-        return nullptr;
-    }
-    
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    auto peers = wrap->client->get_validated_peers();
-    
-    *count = static_cast<int>(peers.size());
-    if (*count == 0) return nullptr;
-    
-    char** peer_ids = static_cast<char**>(malloc(*count * sizeof(char*)));
-    if (!peer_ids) {
-        *count = 0;
-        return nullptr;
-    }
-    
-    for (int i = 0; i < *count; ++i) {
-        peer_ids[i] = rats_strdup_owned(peers[i].peer_id);
-        if (!peer_ids[i]) {
-            // Clean up on allocation failure
-            for (int j = 0; j < i; ++j) {
-                free(peer_ids[j]);
-            }
-            free(peer_ids);
-            *count = 0;
-            return nullptr;
-        }
-    }
-    
-    return peer_ids;
-}
-
-char* rats_get_peer_info_json(rats_client_t handle, const char* peer_id) {
-    if (!handle || !peer_id) return nullptr;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    auto peer = wrap->client->get_peer_by_id(std::string(peer_id));
-    if (!peer) return nullptr;
-    
-    // Create JSON representation of peer info
-    nlohmann::json peer_info;
-    peer_info["peer_id"] = peer->peer_id;
-    peer_info["ip"] = peer->ip;
-    peer_info["port"] = peer->port;
-    peer_info["is_outgoing"] = peer->is_outgoing;
-    peer_info["handshake_completed"] = peer->is_handshake_completed();
-    peer_info["version"] = peer->version;
-    peer_info["encryption_enabled"] = peer->encryption_enabled;
-    
-    return rats_strdup_owned(peer_info.dump());
-}
-
-char** rats_get_validated_peer_ids(rats_client_t handle, int* count) {
-    if (!handle || !count) {
-        if (count) *count = 0;
-        return nullptr;
-    }
-    
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    auto peers = wrap->client->get_validated_peers();
-    
-    *count = static_cast<int>(peers.size());
-    if (*count == 0) return nullptr;
-    
-    char** peer_ids = static_cast<char**>(malloc(*count * sizeof(char*)));
-    if (!peer_ids) {
-        *count = 0;
-        return nullptr;
-    }
-    
-    for (int i = 0; i < *count; ++i) {
-        peer_ids[i] = rats_strdup_owned(peers[i].peer_id);
-        if (!peer_ids[i]) {
-            // Clean up on allocation failure
-            for (int j = 0; j < i; ++j) {
-                free(peer_ids[j]);
-            }
-            free(peer_ids);
-            *count = 0;
-            return nullptr;
-        }
-    }
-    
-    return peer_ids;
-}
-
-// ===================== GOSSIPSUB FUNCTIONALITY =====================
-
-int rats_is_gossipsub_available(rats_client_t handle) {
-    if (!handle) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->is_gossipsub_available() ? 1 : 0;
-}
-
-int rats_is_gossipsub_running(rats_client_t handle) {
-    if (!handle) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->is_gossipsub_running() ? 1 : 0;
-}
-
-rats_error_t rats_subscribe_to_topic(rats_client_t handle, const char* topic) {
-    if (!handle || !topic) return RATS_ERROR_INVALID_PARAMETER;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->subscribe_to_topic(std::string(topic)) ? RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-}
-
-rats_error_t rats_unsubscribe_from_topic(rats_client_t handle, const char* topic) {
-    if (!handle || !topic) return RATS_ERROR_INVALID_PARAMETER;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->unsubscribe_from_topic(std::string(topic)) ? RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-}
-
-int rats_is_subscribed_to_topic(rats_client_t handle, const char* topic) {
-    if (!handle || !topic) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->is_subscribed_to_topic(std::string(topic)) ? 1 : 0;
-}
-
-char** rats_get_subscribed_topics(rats_client_t handle, int* count) {
-    if (!handle || !count) {
-        if (count) *count = 0;
-        return nullptr;
-    }
-    
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    auto topics = wrap->client->get_subscribed_topics();
-    
-    *count = static_cast<int>(topics.size());
-    if (*count == 0) return nullptr;
-    
-    char** topic_array = static_cast<char**>(malloc(*count * sizeof(char*)));
-    if (!topic_array) {
-        *count = 0;
-        return nullptr;
-    }
-    
-    for (int i = 0; i < *count; ++i) {
-        topic_array[i] = rats_strdup_owned(topics[i]);
-        if (!topic_array[i]) {
-            // Clean up on allocation failure
-            for (int j = 0; j < i; ++j) {
-                free(topic_array[j]);
-            }
-            free(topic_array);
-            *count = 0;
-            return nullptr;
-        }
-    }
-    
-    return topic_array;
-}
-
-rats_error_t rats_publish_to_topic(rats_client_t handle, const char* topic, const char* message) {
-    if (!handle || !topic || !message) return RATS_ERROR_INVALID_PARAMETER;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->publish_to_topic(std::string(topic), std::string(message)) ? RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-}
-
-rats_error_t rats_publish_json_to_topic(rats_client_t handle, const char* topic, const char* json_str) {
-    if (!handle || !topic || !json_str) return RATS_ERROR_INVALID_PARAMETER;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    try {
-        nlohmann::json json_data = nlohmann::json::parse(json_str);
-        return wrap->client->publish_json_to_topic(std::string(topic), json_data) ? RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-    } catch (const nlohmann::json::exception&) {
-        return RATS_ERROR_JSON_PARSE;
-    }
-}
-
-char** rats_get_topic_peers(rats_client_t handle, const char* topic, int* count) {
-    if (!handle || !topic || !count) {
-        if (count) *count = 0;
-        return nullptr;
-    }
-    
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    auto peers = wrap->client->get_topic_peers(std::string(topic));
-    
-    *count = static_cast<int>(peers.size());
-    if (*count == 0) return nullptr;
-    
-    char** peer_array = static_cast<char**>(malloc(*count * sizeof(char*)));
-    if (!peer_array) {
-        *count = 0;
-        return nullptr;
-    }
-    
-    for (int i = 0; i < *count; ++i) {
-        peer_array[i] = rats_strdup_owned(peers[i]);
-        if (!peer_array[i]) {
-            // Clean up on allocation failure
-            for (int j = 0; j < i; ++j) {
-                free(peer_array[j]);
-            }
-            free(peer_array);
-            *count = 0;
-            return nullptr;
-        }
-    }
-    
-    return peer_array;
-}
-
-char** rats_get_topic_mesh_peers(rats_client_t handle, const char* topic, int* count) {
-    if (!handle || !topic || !count) {
-        if (count) *count = 0;
-        return nullptr;
-    }
-    
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    auto peers = wrap->client->get_topic_mesh_peers(std::string(topic));
-    
-    *count = static_cast<int>(peers.size());
-    if (*count == 0) return nullptr;
-    
-    char** peer_array = static_cast<char**>(malloc(*count * sizeof(char*)));
-    if (!peer_array) {
-        *count = 0;
-        return nullptr;
-    }
-    
-    for (int i = 0; i < *count; ++i) {
-        peer_array[i] = rats_strdup_owned(peers[i]);
-        if (!peer_array[i]) {
-            // Clean up on allocation failure
-            for (int j = 0; j < i; ++j) {
-                free(peer_array[j]);
-            }
-            free(peer_array);
-            *count = 0;
-            return nullptr;
-        }
-    }
-    
-    return peer_array;
-}
-
-char* rats_get_gossipsub_statistics_json(rats_client_t handle) {
-    if (!handle) return nullptr;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    auto stats = wrap->client->get_gossipsub_statistics();
-    return rats_strdup_owned(stats.dump());
-}
-
-// GossipSub callback setters
-void rats_set_topic_message_callback(rats_client_t handle, const char* topic, rats_topic_message_cb cb, void* user_data) {
-    if (!handle || !topic) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    std::string topic_str(topic);
-    if (cb) {
-        wrap->topic_message_handlers[topic_str] = std::make_pair(cb, user_data);
-        wrap->client->on_topic_message(topic_str, [wrap, cb, user_data](const std::string& peer_id, const std::string& topic, const std::string& message) {
-            if (cb) {
-                cb(user_data, peer_id.c_str(), topic.c_str(), message.c_str());
-            }
-        });
-    } else {
-        wrap->topic_message_handlers.erase(topic_str);
-    }
-}
-
-void rats_set_topic_json_message_callback(rats_client_t handle, const char* topic, rats_topic_json_message_cb cb, void* user_data) {
-    if (!handle || !topic) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    std::string topic_str(topic);
-    if (cb) {
-        wrap->topic_json_message_handlers[topic_str] = std::make_pair(cb, user_data);
-        wrap->client->on_topic_json_message(topic_str, [wrap, cb, user_data](const std::string& peer_id, const std::string& topic, const nlohmann::json& message) {
-            if (cb) {
-                std::string json_str = message.dump();
-                cb(user_data, peer_id.c_str(), topic.c_str(), json_str.c_str());
-            }
-        });
-    } else {
-        wrap->topic_json_message_handlers.erase(topic_str);
-    }
-}
-
-void rats_set_topic_peer_joined_callback(rats_client_t handle, const char* topic, rats_topic_peer_joined_cb cb, void* user_data) {
-    if (!handle || !topic) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    std::string topic_str(topic);
-    if (cb) {
-        wrap->topic_peer_joined_handlers[topic_str] = std::make_pair(cb, user_data);
-        wrap->client->on_topic_peer_joined(topic_str, [wrap, cb, user_data](const std::string& peer_id, const std::string& topic) {
-            if (cb) {
-                cb(user_data, peer_id.c_str(), topic.c_str());
-            }
-        });
-    } else {
-        wrap->topic_peer_joined_handlers.erase(topic_str);
-    }
-}
-
-void rats_set_topic_peer_left_callback(rats_client_t handle, const char* topic, rats_topic_peer_left_cb cb, void* user_data) {
-    if (!handle || !topic) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    std::string topic_str(topic);
-    if (cb) {
-        wrap->topic_peer_left_handlers[topic_str] = std::make_pair(cb, user_data);
-        wrap->client->on_topic_peer_left(topic_str, [wrap, cb, user_data](const std::string& peer_id, const std::string& topic) {
-            if (cb) {
-                cb(user_data, peer_id.c_str(), topic.c_str());
-            }
-        });
-    } else {
-        wrap->topic_peer_left_handlers.erase(topic_str);
-    }
-}
-
-void rats_clear_topic_callbacks(rats_client_t handle, const char* topic) {
-    if (!handle || !topic) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    std::string topic_str(topic);
-    wrap->topic_message_handlers.erase(topic_str);
-    wrap->topic_json_message_handlers.erase(topic_str);
-    wrap->topic_peer_joined_handlers.erase(topic_str);
-    wrap->topic_peer_left_handlers.erase(topic_str);
-    
-    wrap->client->off_topic(topic_str);
-}
-
-// ===================== ADDRESS BLOCKING =====================
-
-void rats_add_ignored_address(rats_client_t handle, const char* ip_address) {
-    if (!handle || !ip_address) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->add_ignored_address(std::string(ip_address));
-}
-
-// ===================== CONFIGURATION PERSISTENCE =====================
-
-rats_error_t rats_load_configuration(rats_client_t handle) {
-    if (!handle) return RATS_ERROR_INVALID_HANDLE;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->load_configuration() ? RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-}
-
-rats_error_t rats_save_configuration(rats_client_t handle) {
-    if (!handle) return RATS_ERROR_INVALID_HANDLE;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->save_configuration() ? RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-}
-
-rats_error_t rats_set_data_directory(rats_client_t handle, const char* directory_path) {
-    if (!handle || !directory_path) return RATS_ERROR_INVALID_PARAMETER;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->set_data_directory(std::string(directory_path)) ? RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-}
-
-char* rats_get_data_directory(rats_client_t handle) {
-    if (!handle) return nullptr;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return rats_strdup_owned(wrap->client->get_data_directory());
-}
-
-int rats_load_and_reconnect_peers(rats_client_t handle) {
-    if (!handle) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->load_and_reconnect_peers();
-}
-
-int rats_load_historical_peers(rats_client_t handle) {
-    if (!handle) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->load_historical_peers() ? 1 : 0;
-}
-
-int rats_save_historical_peers(rats_client_t handle) {
-    if (!handle) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->save_historical_peers() ? 1 : 0;
-}
-
-void rats_clear_historical_peers(rats_client_t handle) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->clear_historical_peers();
-}
-
-char** rats_get_historical_peer_ids(rats_client_t handle, int* count) {
-    if (!handle || !count) {
-        if (count) *count = 0;
-        return nullptr;
-    }
-    
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    auto historical_peers = wrap->client->get_historical_peers();
-    
-    *count = static_cast<int>(historical_peers.size());
-    if (*count == 0) return nullptr;
-    
-    char** peer_ids = static_cast<char**>(malloc(*count * sizeof(char*)));
-    if (!peer_ids) {
-        *count = 0;
-        return nullptr;
-    }
-    
-    for (int i = 0; i < *count; ++i) {
-        peer_ids[i] = rats_strdup_owned(historical_peers[i].peer_id);
-        if (!peer_ids[i]) {
-            // Clean up on allocation failure
-            for (int j = 0; j < i; ++j) {
-                free(peer_ids[j]);
-            }
-            free(peer_ids);
-            *count = 0;
-            return nullptr;
-        }
-    }
-    
-    return peer_ids;
-}
-
-// ===================== ENHANCED ENCRYPTION API =====================
-
-rats_error_t rats_initialize_encryption(rats_client_t handle, int enable) {
-    if (!handle) return RATS_ERROR_INVALID_HANDLE;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->initialize_encryption(enable != 0) ? RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-}
-
-int rats_is_peer_encrypted(rats_client_t handle, const char* peer_id) {
-    if (!handle || !peer_id) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->is_peer_encrypted(std::string(peer_id)) ? 1 : 0;
-}
-
-rats_error_t rats_set_noise_static_keypair(rats_client_t handle, const char* private_key_hex) {
-    if (!handle || !private_key_hex) return RATS_ERROR_INVALID_PARAMETER;
-    if (strlen(private_key_hex) != 64) return RATS_ERROR_INVALID_PARAMETER; // 32 bytes = 64 hex chars
-    
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    // Convert hex string to bytes
-    uint8_t private_key[32];
-    for (int i = 0; i < 32; i++) {
-        unsigned int byte;
-        if (sscanf(private_key_hex + i * 2, "%02x", &byte) != 1) {
-            return RATS_ERROR_INVALID_PARAMETER;
-        }
-        private_key[i] = static_cast<uint8_t>(byte);
-    }
-    
-    return wrap->client->set_noise_static_keypair(private_key) ? RATS_SUCCESS : RATS_ERROR_OPERATION_FAILED;
-}
-
-static std::string bytes_to_hex(const std::vector<uint8_t>& bytes) {
-    std::string hex;
-    hex.reserve(bytes.size() * 2);
-    for (uint8_t b : bytes) {
-        char buf[3];
-        snprintf(buf, sizeof(buf), "%02x", b);
-        hex += buf;
-    }
-    return hex;
-}
-
-char* rats_get_noise_static_public_key(rats_client_t handle) {
-    if (!handle) return nullptr;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    auto key = wrap->client->get_noise_static_public_key();
-    if (key.empty()) return nullptr;
-    return rats_strdup_owned(bytes_to_hex(key));
-}
-
-char* rats_get_peer_noise_public_key(rats_client_t handle, const char* peer_id) {
-    if (!handle || !peer_id) return nullptr;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    auto key = wrap->client->get_peer_noise_public_key(std::string(peer_id));
-    if (key.empty()) return nullptr;
-    return rats_strdup_owned(bytes_to_hex(key));
-}
-
-char* rats_get_peer_handshake_hash(rats_client_t handle, const char* peer_id) {
-    if (!handle || !peer_id) return nullptr;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    auto hash = wrap->client->get_peer_handshake_hash(std::string(peer_id));
-    if (hash.empty()) return nullptr;
-    return rats_strdup_owned(bytes_to_hex(hash));
-}
-
-// ===================== ICE (NAT TRAVERSAL) API =====================
-
-int rats_is_ice_available(rats_client_t handle) {
-    if (!handle) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->is_ice_available() ? 1 : 0;
-}
-
-void rats_add_stun_server(rats_client_t handle, const char* host, uint16_t port) {
-    if (!handle || !host) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->add_stun_server(std::string(host), port);
-}
-
-void rats_add_turn_server(rats_client_t handle, const char* host, uint16_t port,
-                          const char* username, const char* password) {
-    if (!handle || !host || !username || !password) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->add_turn_server(std::string(host), port, 
-                                  std::string(username), std::string(password));
-}
-
-void rats_clear_ice_servers(rats_client_t handle) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->clear_ice_servers();
-}
-
-int rats_gather_ice_candidates(rats_client_t handle) {
-    if (!handle) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->gather_ice_candidates() ? 1 : 0;
-}
-
-char* rats_get_ice_candidates_json(rats_client_t handle) {
-    if (!handle) return nullptr;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    auto candidates = wrap->client->get_ice_candidates();
-    nlohmann::json candidates_json = nlohmann::json::array();
-    
-    for (const auto& c : candidates) {
-        nlohmann::json cj;
-        cj["type"] = static_cast<int>(c.type);
-        cj["foundation"] = c.foundation;
-        cj["component_id"] = c.component_id;
-        cj["transport"] = static_cast<int>(c.transport);
-        cj["priority"] = c.priority;
-        cj["address"] = c.address;
-        cj["port"] = c.port;
-        cj["related_address"] = c.related_address;
-        cj["related_port"] = c.related_port;
-        cj["sdp"] = c.to_sdp_attribute();
-        candidates_json.push_back(cj);
-    }
-    
-    return rats_strdup_owned(candidates_json.dump());
-}
-
-int rats_is_ice_gathering_complete(rats_client_t handle) {
-    if (!handle) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->is_ice_gathering_complete() ? 1 : 0;
-}
-
-char* rats_get_public_address(rats_client_t handle) {
-    if (!handle) return nullptr;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    auto addr = wrap->client->get_public_address();
-    if (!addr.has_value()) return nullptr;
-    
-    std::string result = addr->first + ":" + std::to_string(addr->second);
-    return rats_strdup_owned(result);
-}
-
-char* rats_discover_public_address(rats_client_t handle, const char* stun_server, 
-                                   uint16_t port, int timeout_ms) {
-    if (!handle) return nullptr;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    std::string server = stun_server ? std::string(stun_server) : "stun.l.google.com";
-    uint16_t server_port = (port > 0) ? port : 19302;
-    int timeout = (timeout_ms > 0) ? timeout_ms : 5000;
-    
-    auto addr = wrap->client->discover_public_address(server, server_port, timeout);
-    if (!addr.has_value()) return nullptr;
-    
-    std::string result = addr->address + ":" + std::to_string(addr->port);
-    return rats_strdup_owned(result);
-}
-
-void rats_add_remote_ice_candidate(rats_client_t handle, const char* candidate_sdp) {
-    if (!handle || !candidate_sdp) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    auto candidate = IceCandidate::from_sdp_attribute(std::string(candidate_sdp));
-    if (candidate.has_value()) {
-        wrap->client->add_remote_ice_candidate(candidate.value());
-    }
-}
-
-void rats_add_remote_ice_candidates_from_sdp(rats_client_t handle, 
-                                             const char** sdp_lines, int count) {
-    if (!handle || !sdp_lines || count <= 0) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    std::vector<std::string> lines;
-    for (int i = 0; i < count; i++) {
-        if (sdp_lines[i]) {
-            lines.push_back(std::string(sdp_lines[i]));
-        }
-    }
-    
-    wrap->client->add_remote_ice_candidates_from_sdp(lines);
-}
-
-void rats_end_of_remote_ice_candidates(rats_client_t handle) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->end_of_remote_ice_candidates();
-}
-
-void rats_start_ice_checks(rats_client_t handle) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->start_ice_checks();
-}
-
-rats_ice_connection_state_t rats_get_ice_connection_state(rats_client_t handle) {
-    if (!handle) return RATS_ICE_STATE_CLOSED;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return static_cast<rats_ice_connection_state_t>(wrap->client->get_ice_connection_state());
-}
-
-rats_ice_gathering_state_t rats_get_ice_gathering_state(rats_client_t handle) {
-    if (!handle) return RATS_ICE_GATHERING_NEW;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return static_cast<rats_ice_gathering_state_t>(wrap->client->get_ice_gathering_state());
-}
-
-int rats_is_ice_connected(rats_client_t handle) {
-    if (!handle) return 0;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    return wrap->client->is_ice_connected() ? 1 : 0;
-}
-
-char* rats_get_ice_selected_pair_json(rats_client_t handle) {
-    if (!handle) return nullptr;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    auto pair = wrap->client->get_ice_selected_pair();
-    if (!pair.has_value()) return nullptr;
-    
-    nlohmann::json pair_json;
-    
-    nlohmann::json local_json;
-    local_json["type"] = static_cast<int>(pair->local.type);
-    local_json["address"] = pair->local.address;
-    local_json["port"] = pair->local.port;
-    local_json["priority"] = pair->local.priority;
-    local_json["sdp"] = pair->local.to_sdp_attribute();
-    
-    nlohmann::json remote_json;
-    remote_json["type"] = static_cast<int>(pair->remote.type);
-    remote_json["address"] = pair->remote.address;
-    remote_json["port"] = pair->remote.port;
-    remote_json["priority"] = pair->remote.priority;
-    remote_json["sdp"] = pair->remote.to_sdp_attribute();
-    
-    pair_json["local"] = local_json;
-    pair_json["remote"] = remote_json;
-    pair_json["state"] = static_cast<int>(pair->state);
-    pair_json["priority"] = pair->priority;
-    pair_json["nominated"] = pair->nominated;
-    
-    return rats_strdup_owned(pair_json.dump());
-}
-
-void rats_set_ice_candidates_gathered_callback(rats_client_t handle,
-                                               rats_ice_candidates_cb cb, void* user_data) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    if (cb) {
-        wrap->client->on_ice_candidates_gathered([cb, user_data](const std::vector<IceCandidate>& candidates) {
-            nlohmann::json candidates_json = nlohmann::json::array();
-            for (const auto& c : candidates) {
-                nlohmann::json cj;
-                cj["sdp"] = c.to_sdp_attribute();
-                cj["address"] = c.address;
-                cj["port"] = c.port;
-                cj["type"] = static_cast<int>(c.type);
-                candidates_json.push_back(cj);
-            }
-            cb(user_data, candidates_json.dump().c_str());
-        });
-    }
-}
-
-void rats_set_ice_new_candidate_callback(rats_client_t handle,
-                                         rats_ice_new_candidate_cb cb, void* user_data) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    if (cb) {
-        wrap->client->on_ice_new_candidate([cb, user_data](const IceCandidate& candidate) {
-            cb(user_data, candidate.to_sdp_attribute().c_str());
-        });
-    }
-}
-
-void rats_set_ice_gathering_state_callback(rats_client_t handle,
-                                           rats_ice_gathering_state_cb cb, void* user_data) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    if (cb) {
-        wrap->client->on_ice_gathering_state_changed([cb, user_data](IceGatheringState state) {
-            cb(user_data, static_cast<rats_ice_gathering_state_t>(state));
-        });
-    }
-}
-
-void rats_set_ice_connection_state_callback(rats_client_t handle,
-                                            rats_ice_connection_state_cb cb, void* user_data) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    if (cb) {
-        wrap->client->on_ice_connection_state_changed([cb, user_data](IceConnectionState state) {
-            cb(user_data, static_cast<rats_ice_connection_state_t>(state));
-        });
-    }
-}
-
-void rats_set_ice_selected_pair_callback(rats_client_t handle,
-                                         rats_ice_selected_pair_cb cb, void* user_data) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    
-    if (cb) {
-        wrap->client->on_ice_selected_pair([cb, user_data](const IceCandidatePair& pair) {
-            nlohmann::json local_json;
-            local_json["sdp"] = pair.local.to_sdp_attribute();
-            local_json["address"] = pair.local.address;
-            local_json["port"] = pair.local.port;
-            
-            nlohmann::json remote_json;
-            remote_json["sdp"] = pair.remote.to_sdp_attribute();
-            remote_json["address"] = pair.remote.address;
-            remote_json["port"] = pair.remote.port;
-            
-            cb(user_data, local_json.dump().c_str(), remote_json.dump().c_str());
-        });
-    }
-}
-
-void rats_close_ice(rats_client_t handle) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->close_ice();
-}
-
-void rats_restart_ice(rats_client_t handle) {
-    if (!handle) return;
-    rats_client_wrapper* wrap = static_cast<rats_client_wrapper*>(handle);
-    wrap->client->restart_ice();
-}
-
-} // extern "C"
-
-