librats 0.5.1 → 0.5.2

package/README.md

@@ -205,7 +205,7 @@ client.publishJsonToTopic('general-chat', JSON.stringify(message));
 - `startDhtDiscovery(dhtPort: number): boolean` - Start DHT discovery
 - `stopDhtDiscovery(): void` - Stop DHT discovery
 - `isDhtRunning(): boolean` - Check if DHT is running
-- `announceForHash(contentHash: string, port: number): boolean` - Announce for hash
+- `announceForHash(contentHash: string, port: number, callback?: (peers: string[]) => void): boolean` - Announce for hash with optional peer discovery callback
 
 #### Encryption
 

package/lib/index.d.ts

@@ -370,9 +370,10 @@ export class RatsClient {
    * Announce availability for a content hash
    * @param contentHash - Hash to announce for
    * @param port - Port to announce
+   * @param callback - Optional callback to receive discovered peers during DHT traversal
    * @returns true if announced successfully
    */
-  announceForHash(contentHash: string, port: number): boolean;
+  announceForHash(contentHash: string, port: number, callback?: (peers: string[]) => void): boolean;
 
   // ============ mDNS ============
 

package/native-src/src/dht.cpp

@@ -210,7 +210,7 @@ bool DhtClient::find_peers(const InfoHash& info_hash, PeerDiscoveryCallback call
     return true;
 }
 
-bool DhtClient::announce_peer(const InfoHash& info_hash, uint16_t port) {
+bool DhtClient::announce_peer(const InfoHash& info_hash, uint16_t port, PeerDiscoveryCallback callback) {
     if (!running_) {
         LOG_DHT_ERROR("DHT client not running");
         return false;
@@ -220,24 +220,64 @@ bool DhtClient::announce_peer(const InfoHash& info_hash, uint16_t port) {
         port = port_;
     }
     
-    LOG_DHT_INFO("Announcing peer for info hash: " << node_id_to_hex(info_hash) << " on port " << port);
+    std::string hash_key = node_id_to_hex(info_hash);
+    LOG_DHT_INFO("Announcing peer for info hash: " << hash_key << " on port " << port);
     
-    // First find nodes close to the info hash and send get_peers to them
-    // This is the proper BEP 5 flow: get_peers -> collect tokens -> announce_peer
-    auto closest_nodes = find_closest_nodes(info_hash, ALPHA);
-    for (const auto& node : closest_nodes) {
-            // Generate transaction ID and track this as a pending announce for KRPC
-            std::string transaction_id = KrpcProtocol::generate_transaction_id();
-            
-            {
-                std::lock_guard<std::mutex> lock(pending_announces_mutex_);
-                pending_announces_.emplace(transaction_id, PendingAnnounce(info_hash, port));
+    // BEP 5 compliant announce: 
+    // 1. Perform iterative Kademlia lookup (like find_peers)
+    // 2. Collect tokens from responding nodes
+    // 3. Send announce_peer to k closest nodes with their tokens
+    
+    // Get initial nodes from routing table
+    auto closest_nodes = find_closest_nodes(info_hash, K_BUCKET_SIZE);
+    
+    if (closest_nodes.empty()) {
+        LOG_DHT_WARN("No nodes in routing table to announce to for info_hash " << hash_key);
+        return false;
+    }
+    
+    DeferredCallbacks deferred;
+    
+    {
+        std::lock_guard<std::mutex> lock(pending_searches_mutex_);
+        
+        // Check if a search/announce is already ongoing for this info_hash
+        auto search_it = pending_searches_.find(hash_key);
+        if (search_it != pending_searches_.end()) {
+            if (search_it->second.is_announce) {
+                LOG_DHT_INFO("Announce already in progress for info hash " << hash_key);
+                return true;
             }
-            
-            auto message = KrpcProtocol::create_get_peers_query(transaction_id, node_id_, info_hash);
-            send_krpc_message(message, node.peer);
+            // Regular find_peers in progress - let it complete, then user can announce again
+            LOG_DHT_WARN("find_peers already in progress for info hash " << hash_key << " - announce will wait");
+            return false;
+        }
+        
+        // Create new search with announce flag
+        PendingSearch new_search(info_hash);
+        new_search.is_announce = true;
+        new_search.announce_port = port;
+        
+        // Add callback if provided - peers discovered during traversal will be returned through it
+        if (callback) {
+            new_search.callbacks.push_back(callback);
+        }
+        
+        // Initialize search_nodes with closest nodes from routing table (already sorted)
+        new_search.search_nodes = std::move(closest_nodes);
+        
+        auto insert_result = pending_searches_.emplace(hash_key, std::move(new_search));
+        PendingSearch& search_ref = insert_result.first->second;
+        
+        LOG_DHT_DEBUG("Initialized announce search with " << search_ref.search_nodes.size() << " nodes from routing table");
+        
+        // Start sending requests
+        add_search_requests(search_ref, deferred);
     }
     
+    // Invoke callbacks outside the lock to avoid deadlock
+    deferred.invoke();
+    
     return true;
 }
 
@@ -262,6 +302,13 @@ bool DhtClient::is_search_active(const InfoHash& info_hash) const {
     return it != pending_searches_.end() && !it->second.is_finished;
 }
 
+bool DhtClient::is_announce_active(const InfoHash& info_hash) const {
+    std::lock_guard<std::mutex> lock(pending_searches_mutex_);
+    std::string hash_key = node_id_to_hex(info_hash);
+    auto it = pending_searches_.find(hash_key);
+    return it != pending_searches_.end() && !it->second.is_finished && it->second.is_announce;
+}
+
 size_t DhtClient::get_active_searches_count() const {
     std::lock_guard<std::mutex> lock(pending_searches_mutex_);
     size_t count = 0;
@@ -273,6 +320,17 @@ size_t DhtClient::get_active_searches_count() const {
     return count;
 }
 
+size_t DhtClient::get_active_announces_count() const {
+    std::lock_guard<std::mutex> lock(pending_searches_mutex_);
+    size_t count = 0;
+    for (const auto& [hash, search] : pending_searches_) {
+        if (!search.is_finished && search.is_announce) {
+            count++;
+        }
+    }
+    return count;
+}
+
 std::vector<Peer> DhtClient::get_default_bootstrap_nodes() {
     return {
         {"router.bittorrent.com", 6881},
@@ -340,9 +398,6 @@ void DhtClient::maintenance_loop() {
             // Cleanup stale peer tokens
             cleanup_stale_peer_tokens();
             
-            // Cleanup stale pending announces
-            cleanup_stale_announces();
-            
             // Cleanup stale pending searches
             cleanup_stale_searches();
             
@@ -763,9 +818,16 @@ void DhtClient::handle_krpc_response(const KrpcMessage& message, const Peer& sen
         handle_get_peers_empty_response(message.transaction_id, sender);
     }
     
-    // Check if this is a response to a pending announce (get_peers with token)
+    // Save write token if present (needed for announce_peer after traversal completes)
     if (!message.token.empty()) {
-        handle_get_peers_response_for_announce(message.transaction_id, sender, message.token);
+        std::lock_guard<std::mutex> lock(pending_searches_mutex_);
+        auto trans_it = transaction_to_search_.find(message.transaction_id);
+        if (trans_it != transaction_to_search_.end()) {
+            auto search_it = pending_searches_.find(trans_it->second.info_hash_hex);
+            if (search_it != pending_searches_.end()) {
+                save_write_token(search_it->second, trans_it->second.queried_node_id, message.token);
+            }
+        }
     }
     
     // Clean up finished searches AFTER all response data has been processed
@@ -1028,8 +1090,10 @@ void DhtClient::print_statistics() {
     
     // Pending searches statistics
     size_t pending_searches = 0;
+    size_t pending_announces = 0;
     size_t total_search_nodes = 0;
     size_t total_found_peers = 0;
+    size_t total_write_tokens = 0;
     size_t active_transactions = 0;
     {
         std::lock_guard<std::mutex> search_lock(pending_searches_mutex_);
@@ -1038,16 +1102,13 @@ void DhtClient::print_statistics() {
         for (const auto& [hash, search] : pending_searches_) {
             total_search_nodes += search.search_nodes.size();
             total_found_peers += search.found_peers.size();
+            total_write_tokens += search.write_tokens.size();
+            if (search.is_announce) {
+                pending_announces++;
+            }
         }
     }
     
-    // Pending announces statistics
-    size_t pending_announces_count = 0;
-    {
-        std::lock_guard<std::mutex> announce_lock(pending_announces_mutex_);
-        pending_announces_count = pending_announces_.size();
-    }
-    
     // Announced peers statistics
     size_t announced_peers_total = 0;
     size_t announced_peers_infohashes = 0;
@@ -1084,9 +1145,11 @@ void DhtClient::print_statistics() {
                  << ", Max bucket size: " << max_bucket_size << "/" << K_BUCKET_SIZE);
     LOG_DHT_INFO("[ACTIVE OPERATIONS]");
     LOG_DHT_INFO("  Pending searches: " << pending_searches 
-                 << " (nodes: " << total_search_nodes << ", found peers: " << total_found_peers << ")");
+                 << " (announces: " << pending_announces 
+                 << ", nodes: " << total_search_nodes 
+                 << ", peers: " << total_found_peers 
+                 << ", tokens: " << total_write_tokens << ")");
     LOG_DHT_INFO("  Active transactions: " << active_transactions);
-    LOG_DHT_INFO("  Pending announces: " << pending_announces_count);
     LOG_DHT_INFO("  Pending ping verifications: " << pending_pings 
                  << " (nodes being replaced: " << nodes_being_replaced << ")");
     LOG_DHT_INFO("[STORED DATA]");
@@ -1203,23 +1266,6 @@ void DhtClient::refresh_buckets() {
     }
 }
 
-void DhtClient::cleanup_stale_announces() {
-    std::lock_guard<std::mutex> lock(pending_announces_mutex_);
-    
-    auto now = std::chrono::steady_clock::now();
-    auto stale_threshold = std::chrono::minutes(5);  // Remove announces older than 5 minutes
-    
-    auto it = pending_announces_.begin();
-    while (it != pending_announces_.end()) {
-        if (now - it->second.created_at > stale_threshold) {
-            LOG_DHT_DEBUG("Removing stale pending announce for transaction " << it->first);
-            it = pending_announces_.erase(it);
-        } else {
-            ++it;
-        }
-    }
-}
-
 void DhtClient::cleanup_stale_searches() {
     std::lock_guard<std::mutex> lock(pending_searches_mutex_);
     
@@ -1475,24 +1521,6 @@ void DhtClient::cleanup_timed_out_search_requests() {
     }
 }
 
-void DhtClient::handle_get_peers_response_for_announce(const std::string& transaction_id, const Peer& responder, const std::string& token) {
-    std::lock_guard<std::mutex> lock(pending_announces_mutex_);
-    
-    auto it = pending_announces_.find(transaction_id);
-    if (it != pending_announces_.end()) {
-        const auto& pending_announce = it->second;
-        LOG_DHT_DEBUG("Found pending announce for transaction " << transaction_id 
-                      << " - sending announce_peer for info_hash " << node_id_to_hex(pending_announce.info_hash) 
-                      << " to " << responder.ip << ":" << responder.port);
-        
-        // Send announce_peer with the received token
-        send_krpc_announce_peer(responder, pending_announce.info_hash, pending_announce.port, token);
-        
-        // Remove the pending announce since we've handled it
-        pending_announces_.erase(it);
-    }
-}
-
 void DhtClient::handle_get_peers_empty_response(const std::string& transaction_id, const Peer& responder) {
     DeferredCallbacks deferred;
     {
@@ -1796,6 +1824,86 @@ void DhtClient::add_node_to_search(PendingSearch& search, const DhtNode& node) {
     }
 }
 
+void DhtClient::save_write_token(PendingSearch& search, const NodeId& node_id, const std::string& token) {
+    // Save the write token received from a node (BEP 5 compliant)
+    // This token will be used later when sending announce_peer to this node
+    
+    if (token.empty()) {
+        return;
+    }
+    
+    // Only save token if we don't already have one from this node
+    // (first token is usually the valid one)
+    if (search.write_tokens.find(node_id) == search.write_tokens.end()) {
+        search.write_tokens[node_id] = token;
+        LOG_DHT_DEBUG("Saved write token from node " << node_id_to_hex(node_id) 
+                      << " for info_hash " << node_id_to_hex(search.info_hash)
+                      << " (total tokens: " << search.write_tokens.size() << ")");
+    }
+}
+
+void DhtClient::send_announce_to_closest_nodes(PendingSearch& search) {
+    // BEP 5: Send announce_peer to the k closest nodes that:
+    // 1. Responded to our get_peers query
+    // 2. Gave us a valid write token
+    
+    if (!search.is_announce) {
+        return;
+    }
+    
+    std::string hash_key = node_id_to_hex(search.info_hash);
+    
+    LOG_DHT_INFO("Sending announce_peer to closest nodes for info_hash " << hash_key 
+                 << " on port " << search.announce_port);
+    
+    // Collect nodes that responded and have tokens, sorted by distance (closest first)
+    std::vector<std::pair<DhtNode, std::string>> announce_targets;
+    announce_targets.reserve(K_BUCKET_SIZE);
+    
+    for (const auto& node : search.search_nodes) {
+        if (announce_targets.size() >= K_BUCKET_SIZE) {
+            break;  // We have enough targets
+        }
+        
+        // Check if node responded successfully
+        auto state_it = search.node_states.find(node.id);
+        if (state_it == search.node_states.end()) {
+            continue;
+        }
+        if (!(state_it->second & SearchNodeFlags::RESPONDED)) {
+            continue;  // Node didn't respond
+        }
+        
+        // Check if we have a token from this node
+        auto token_it = search.write_tokens.find(node.id);
+        if (token_it == search.write_tokens.end()) {
+            LOG_DHT_DEBUG("Node " << node_id_to_hex(node.id) << " responded but no token - skipping");
+            continue;  // No token from this node
+        }
+        
+        announce_targets.emplace_back(node, token_it->second);
+    }
+    
+    if (announce_targets.empty()) {
+        LOG_DHT_WARN("No nodes with tokens to announce to for info_hash " << hash_key);
+        return;
+    }
+    
+    LOG_DHT_INFO("Announcing to " << announce_targets.size() << " closest nodes with tokens");
+    
+    // Send announce_peer to each target
+    for (const auto& [node, token] : announce_targets) {
+        LOG_DHT_DEBUG("Sending announce_peer to node " << node_id_to_hex(node.id) 
+                      << " at " << node.peer.ip << ":" << node.peer.port
+                      << " with token (distance: " << get_bucket_index(node.id) << ")");
+        
+        send_krpc_announce_peer(node.peer, search.info_hash, search.announce_port, token);
+    }
+    
+    LOG_DHT_INFO("Announce completed: sent announce_peer to " << announce_targets.size() 
+                 << " nodes for info_hash " << hash_key);
+}
+
 bool DhtClient::add_search_requests(PendingSearch& search, DeferredCallbacks& deferred) {
     // Returns true if search is done (completed or should be finished)
     
@@ -1875,7 +1983,7 @@ bool DhtClient::add_search_requests(PendingSearch& search, DeferredCallbacks& de
         queries_sent++;
     }
     
-    LOG_DHT_DEBUG("Search [" << hash_key << "] progress [ms: " << std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - search.created_at).count() << "]:");
+    LOG_DHT_DEBUG((search.is_announce ? "Announce" : "Search") << " [" << hash_key << "] progress [ms: " << std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - search.created_at).count() << "]:");
     LOG_DHT_DEBUG(" * search_nodes: " << search.search_nodes.size());
     LOG_DHT_DEBUG(" * queries_sent: " << queries_sent);
     LOG_DHT_DEBUG(" * invoke_count: " << search.invoke_count);
@@ -1903,7 +2011,7 @@ bool DhtClient::add_search_requests(PendingSearch& search, DeferredCallbacks& de
             if (f & SearchNodeFlags::ABANDONED) abandoned_total++;
         }
         
-        LOG_DHT_INFO("=== Search Completed for info_hash " << hash_key << " ===");
+        LOG_DHT_INFO("=== " << (search.is_announce ? "Announce" : "Search") << " Completed for info_hash " << hash_key << " ===");
         LOG_DHT_INFO("  Duration: " << duration_ms << "ms");
         LOG_DHT_INFO("  Total nodes queried: " << queried_total);
         LOG_DHT_INFO("  Total nodes responded: " << responded_total);
@@ -1911,8 +2019,18 @@ bool DhtClient::add_search_requests(PendingSearch& search, DeferredCallbacks& de
         LOG_DHT_INFO("  Nodes with short timeout: " << short_timeout_total);
         LOG_DHT_INFO("  Nodes abandoned (truncation): " << abandoned_total);
         LOG_DHT_INFO("  Final branch_factor: " << search.branch_factor << " (initial: " << ALPHA << ")");
-        LOG_DHT_INFO("  Total peers found: " << search.found_peers.size());
-        LOG_DHT_INFO("  Callbacks to invoke: " << search.callbacks.size());
+        if (search.is_announce) {
+            LOG_DHT_INFO("  Write tokens collected: " << search.write_tokens.size());
+            LOG_DHT_INFO("  Announce port: " << search.announce_port);
+        } else {
+            LOG_DHT_INFO("  Total peers found: " << search.found_peers.size());
+            LOG_DHT_INFO("  Callbacks to invoke: " << search.callbacks.size());
+        }
+        
+        // If this is an announce search, send announce_peer to k closest nodes with tokens
+        if (search.is_announce) {
+            send_announce_to_closest_nodes(search);
+        }
         
         // Collect callbacks for deferred invocation (avoid deadlock - don't call user callbacks while holding mutex)
         deferred.should_invoke = true;

package/native-src/src/dht.h

@@ -198,9 +198,10 @@ public:
      * Announce that this node is a peer for a specific info hash
      * @param info_hash The info hash to announce
      * @param port The port to announce (0 for DHT port)
+     * @param callback Optional callback to receive discovered peers during traversal
      * @return true if announcement started successfully, false otherwise
      */
-    bool announce_peer(const InfoHash& info_hash, uint16_t port = 0);
+    bool announce_peer(const InfoHash& info_hash, uint16_t port = 0, PeerDiscoveryCallback callback = nullptr);
     
     /**
      * Get our node ID
@@ -227,12 +228,25 @@ public:
      */
     bool is_search_active(const InfoHash& info_hash) const;
     
+    /**
+     * Check if an announce is currently active for an info hash
+     * @param info_hash The info hash to check
+     * @return true if announce is active, false otherwise
+     */
+    bool is_announce_active(const InfoHash& info_hash) const;
+    
     /**
      * Get number of active searches
      * @return Number of active searches
      */
     size_t get_active_searches_count() const;
     
+    /**
+     * Get number of active announces
+     * @return Number of active announces
+     */
+    size_t get_active_announces_count() const;
+    
     /**
      * Check if DHT is running
      * @return true if running, false otherwise
@@ -279,10 +293,9 @@ private:
     // 1. pending_pings_mutex_           (Ping verification state, nodes_being_replaced_)
     // 2. pending_searches_mutex_        (Search state and transaction mappings)
     // 3. routing_table_mutex_           (core routing data)
-    // 4. pending_announces_mutex_       (Announce state)
-    // 5. announced_peers_mutex_         (Stored peer data)
-    // 6. peer_tokens_mutex_             (Token validation data)
-    // 7. shutdown_mutex_                (Lowest priority - can be locked independently)
+    // 4. announced_peers_mutex_         (Stored peer data)
+    // 5. peer_tokens_mutex_             (Token validation data)
+    // 6. shutdown_mutex_                (Lowest priority - can be locked independently)
     //
     // Routing table (k-buckets)
     std::vector<std::vector<DhtNode>> routing_table_;
@@ -301,17 +314,6 @@ private:
     std::mutex peer_tokens_mutex_;  // Lock order: 6
     
 
-    // Pending announce tracking (for BEP 5 compliance)
-    struct PendingAnnounce {
-        InfoHash info_hash;
-        uint16_t port;
-        std::chrono::steady_clock::time_point created_at;
-        
-        PendingAnnounce(const InfoHash& hash, uint16_t p)
-            : info_hash(hash), port(p), created_at(std::chrono::steady_clock::now()) {}
-    };
-    std::unordered_map<std::string, PendingAnnounce> pending_announces_;
-    std::mutex pending_announces_mutex_;  // Lock order: 4
     
     // Pending find_peers tracking (to map transaction IDs to info_hash)
     struct PendingSearch {
@@ -332,9 +334,16 @@ private:
         // Callbacks to invoke when peers are found (supports multiple concurrent searches for same info_hash)
         std::vector<PeerDiscoveryCallback> callbacks;
         
+        // Announce support: tokens collected during traversal (BEP 5 compliant)
+        // Maps node_id -> write_token received from that node
+        std::unordered_map<NodeId, std::string> write_tokens;
+        bool is_announce;                           // true if this search is for announce_peer
+        uint16_t announce_port;                     // port to announce (only valid if is_announce)
+        
         PendingSearch(const InfoHash& hash)
             : info_hash(hash), created_at(std::chrono::steady_clock::now()), 
-              invoke_count(0), branch_factor(ALPHA), is_finished(false) {}
+              invoke_count(0), branch_factor(ALPHA), is_finished(false),
+              is_announce(false), announce_port(0) {}
     };
     std::unordered_map<std::string, PendingSearch> pending_searches_; // info_hash (hex) -> PendingSearch
     mutable std::mutex pending_searches_mutex_;  // Lock order: 2
@@ -434,10 +443,6 @@ private:
     void refresh_buckets();
     void print_statistics();
     
-    // Pending announce management
-    void cleanup_stale_announces();
-    void handle_get_peers_response_for_announce(const std::string& transaction_id, const Peer& responder, const std::string& token);
-    
     // Pending search management
     void cleanup_stale_searches();
     void cleanup_timed_out_search_requests();
@@ -445,8 +450,10 @@ private:
     void handle_get_peers_response_for_search(const std::string& transaction_id, const Peer& responder, const std::vector<Peer>& peers);
     void handle_get_peers_response_with_nodes(const std::string& transaction_id, const Peer& responder, const std::vector<KrpcNode>& nodes);
     void handle_get_peers_empty_response(const std::string& transaction_id, const Peer& responder);
+    void save_write_token(PendingSearch& search, const NodeId& node_id, const std::string& token);
     bool add_search_requests(PendingSearch& search, DeferredCallbacks& deferred);
     void add_node_to_search(PendingSearch& search, const DhtNode& node);
+    void send_announce_to_closest_nodes(PendingSearch& search);
     
     // Peer announcement storage management
     void store_announced_peer(const InfoHash& info_hash, const Peer& peer);

package/native-src/src/librats.cpp

@@ -1817,7 +1817,8 @@ bool RatsClient::find_peers_by_hash(const std::string& content_hash, std::functi
     });
 }
 
-bool RatsClient::announce_for_hash(const std::string& content_hash, uint16_t port) {
+bool RatsClient::announce_for_hash(const std::string& content_hash, uint16_t port,
+                                   std::function<void(const std::vector<std::string>&)> callback) {
     if (!dht_client_ || !dht_client_->is_running()) {
         LOG_CLIENT_ERROR("DHT client not running");
         return false;
@@ -1832,10 +1833,25 @@ bool RatsClient::announce_for_hash(const std::string& content_hash, uint16_t por
         port = listen_port_;
     }
     
-    LOG_CLIENT_INFO("Announcing for content hash: " << content_hash << " on port " << port);
+    LOG_CLIENT_INFO("Announcing for content hash: " << content_hash << " on port " << port
+                   << (callback ? " with peer callback" : ""));
     
     InfoHash info_hash = hex_to_node_id(content_hash);
-    return dht_client_->announce_peer(info_hash, port);
+    
+    // Create wrapper callback that converts Peer to string addresses (if callback provided)
+    PeerDiscoveryCallback peer_callback = nullptr;
+    if (callback) {
+        peer_callback = [callback](const std::vector<Peer>& peers, const InfoHash& hash) {
+            std::vector<std::string> peer_addresses;
+            peer_addresses.reserve(peers.size());
+            for (const auto& peer : peers) {
+                peer_addresses.push_back(peer.ip + ":" + std::to_string(peer.port));
+            }
+            callback(peer_addresses);
+        };
+    }
+    
+    return dht_client_->announce_peer(info_hash, port, peer_callback);
 }
 
 bool RatsClient::is_dht_running() const {
@@ -1931,46 +1947,23 @@ void RatsClient::automatic_discovery_loop() {
         }
     }
 
-    // Search immediately
-    search_rats_peers();
-    
-    {
-        std::unique_lock<std::mutex> lock(shutdown_mutex_);
-        if (shutdown_cv_.wait_for(lock, std::chrono::seconds(10), [this] { return !auto_discovery_running_.load() || !running_.load(); })) {
-            LOG_CLIENT_INFO("Automatic peer discovery loop stopped during search delay");
-            return;
-        }
-    }
-    
-    // Announce immediately
+    // Announce immediately - this also discovers peers during traversal
     announce_rats_peer();
 
     auto last_announce = std::chrono::steady_clock::now();
-    auto last_search = std::chrono::steady_clock::now();
     
     while (auto_discovery_running_.load()) {
         auto now = std::chrono::steady_clock::now();
         
-        if (get_peer_count() == 0) {
-            // No peers: aggressive search and announce
-            if (now - last_search >= std::chrono::seconds(5)) {
-                search_rats_peers();
-                last_search = now;
-            }
-            if (now - last_announce >= std::chrono::seconds(20)) {
-                announce_rats_peer();
-                last_announce = now;
-            }
-        } else {
-            // Peers connected: less aggressive, similar to original logic
-            if (now - last_search >= std::chrono::minutes(5)) {
-                search_rats_peers();
-                last_search = now;
-            }
-            if (now - last_announce >= std::chrono::minutes(10)) {
-                announce_rats_peer();
-                last_announce = now;
-            }
+        // Announce combines both announcing our presence and discovering peers
+        // Adjust frequency based on whether we have peers
+        auto interval = (get_peer_count() == 0) 
+            ? std::chrono::seconds(15)    // Aggressive when no peers
+            : std::chrono::minutes(10);   // Less aggressive when connected
+        
+        if (now - last_announce >= interval) {
+            announce_rats_peer();
+            last_announce = now;
         }
         
         // Use conditional variable for responsive shutdown
@@ -1994,8 +1987,35 @@ void RatsClient::announce_rats_peer() {
     std::string discovery_hash = get_discovery_hash();
     LOG_CLIENT_INFO("Announcing peer for discovery hash: " << discovery_hash << " on port " << listen_port_);
     
-    if (announce_for_hash(discovery_hash, listen_port_)) {
-        LOG_CLIENT_DEBUG("Successfully announced peer for discovery");
+    InfoHash info_hash = hex_to_node_id(discovery_hash);
+
+    if (dht_client_->is_announce_active(info_hash)) {
+        LOG_CLIENT_WARN("Announce already in progress for info hash: " << node_id_to_hex(info_hash));
+        return;
+    }
+    
+    // Use announce with callback - combines announce and find_peers in one traversal
+    // Peers discovered during traversal will be returned through the callback
+    if (announce_for_hash(discovery_hash, listen_port_, [this, info_hash](const std::vector<std::string>& peer_addresses) {
+        LOG_CLIENT_INFO("Announce discovered " << peer_addresses.size() << " peers during traversal");
+        
+        // Convert peer addresses to Peer objects for handle_dht_peer_discovery()
+        std::vector<Peer> peers;
+        peers.reserve(peer_addresses.size());
+        for (const auto& peer_address : peer_addresses) {
+            std::string ip;
+            int port;
+            if (parse_address_string(peer_address, ip, port)) {
+                peers.push_back(Peer(ip, port));
+            }
+        }
+        
+        // Auto-connect to discovered peers
+        if (!peers.empty()) {
+            handle_dht_peer_discovery(peers, info_hash);
+        }
+    })) {
+        LOG_CLIENT_DEBUG("Successfully started announce with peer discovery for discovery hash");
     } else {
         LOG_CLIENT_WARN("Failed to announce peer for discovery");
     }

package/native-src/src/librats.h

@@ -606,12 +606,15 @@ public:
                            std::function<void(const std::vector<std::string>&)> callback);
 
     /**
-     * Announce our presence for a content hash
+     * Announce our presence for a content hash with optional peer discovery callback
+     * If callback is provided, peers discovered during DHT traversal will be returned through it
      * @param content_hash Hash to announce for (40-character hex string)
      * @param port Port to announce (default: our listen port)
+     * @param callback Optional function to call with discovered peers during traversal
      * @return true if announced successfully
      */
-    bool announce_for_hash(const std::string& content_hash, uint16_t port = 0);
+    bool announce_for_hash(const std::string& content_hash, uint16_t port = 0,
+                          std::function<void(const std::vector<std::string>&)> callback = nullptr);
 
     /**
      * Check if DHT is currently running

package/native-src/src/librats_c.cpp

@@ -386,13 +386,29 @@ int rats_is_dht_running(rats_client_t 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_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);
-    return wrap->client->announce_for_hash(std::string(content_hash), announce_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;
 }
 

package/native-src/src/librats_c.h

@@ -82,6 +82,7 @@ typedef void (*rats_json_cb)(void* user_data, const char* peer_id, const char* j
 typedef void (*rats_disconnect_cb)(void* user_data, const char* peer_id);
 typedef void (*rats_peer_discovered_cb)(void* user_data, const char* host, int port, const char* service_name);
 typedef void (*rats_message_cb)(void* user_data, const char* peer_id, const char* message_data);
+typedef void (*rats_peers_found_cb)(void* user_data, const char** peer_addresses, int count);
 
 // Peer configuration
 RATS_API rats_error_t rats_set_max_peers(rats_client_t client, int max_peers);
@@ -106,7 +107,8 @@ RATS_API int rats_broadcast_json(rats_client_t client, const char* json_str);
 RATS_API rats_error_t rats_start_dht_discovery(rats_client_t client, int dht_port);
 RATS_API void rats_stop_dht_discovery(rats_client_t client);
 RATS_API int rats_is_dht_running(rats_client_t client);
-RATS_API rats_error_t rats_announce_for_hash(rats_client_t client, const char* content_hash, int port);
+RATS_API rats_error_t rats_announce_for_hash(rats_client_t client, const char* content_hash, int port,
+                                               rats_peers_found_cb callback, void* user_data);
 RATS_API size_t rats_get_dht_routing_table_size(rats_client_t client);
 
 // Automatic discovery

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "librats",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "Node.js bindings for librats - A high-performance peer-to-peer networking library",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/librats_node.cpp

@@ -473,7 +473,52 @@ private:
         std::string content_hash = info[0].As<Napi::String>().Utf8Value();
         int port = info[1].As<Napi::Number>().Int32Value();
         
-        rats_error_t result = rats_announce_for_hash(client_, content_hash.c_str(), port);
+        // Check if optional callback is provided
+        rats_peers_found_cb c_callback = nullptr;
+        void* callback_user_data = nullptr;
+        Napi::ThreadSafeFunction* tsfn_ptr = nullptr;
+        
+        if (info.Length() >= 3 && info[2].IsFunction()) {
+            // Create thread-safe function for callback
+            auto tsfn = new Napi::ThreadSafeFunction();
+            *tsfn = Napi::ThreadSafeFunction::New(
+                env,
+                info[2].As<Napi::Function>(),
+                "AnnounceForHashCallback",
+                0,
+                1,
+                [](Napi::Env) {} // Release callback
+            );
+            tsfn_ptr = tsfn;
+            
+            c_callback = [](void* user_data, const char** peer_addresses, int count) {
+                auto* tsfn = static_cast<Napi::ThreadSafeFunction*>(user_data);
+                if (!tsfn) return;
+                
+                // Copy peer addresses for async callback
+                std::vector<std::string>* peers = new std::vector<std::string>();
+                for (int i = 0; i < count; i++) {
+                    if (peer_addresses[i]) {
+                        peers->push_back(peer_addresses[i]);
+                    }
+                }
+                
+                tsfn->BlockingCall(peers, [](Napi::Env env, Napi::Function jsCallback, std::vector<std::string>* data) {
+                    Napi::Array arr = Napi::Array::New(env, data->size());
+                    for (size_t i = 0; i < data->size(); i++) {
+                        arr.Set(static_cast<uint32_t>(i), Napi::String::New(env, (*data)[i]));
+                    }
+                    jsCallback.Call({arr});
+                    delete data;
+                });
+                
+                tsfn->Release();
+                delete tsfn;
+            };
+            callback_user_data = tsfn_ptr;
+        }
+        
+        rats_error_t result = rats_announce_for_hash(client_, content_hash.c_str(), port, c_callback, callback_user_data);
         return Napi::Boolean::New(env, result == RATS_SUCCESS);
     }