tari-project
diff --git a/‎base_layer/core/src/base_node/state_machine_service/initializer.rs‎
Lines changed: 4 additions & 6 deletions b/‎base_layer/core/src/base_node/state_machine_service/initializer.rs‎
Lines changed: 4 additions & 6 deletions
diff --git a/‎base_layer/core/src/base_node/state_machine_service/state_machine.rs‎
Lines changed: 41 additions & 6 deletions b/‎base_layer/core/src/base_node/state_machine_service/state_machine.rs‎
Lines changed: 41 additions & 6 deletions
diff --git a/‎base_layer/core/src/base_node/state_machine_service/states/events_and_states.rs‎
Lines changed: 55 additions & 2 deletions b/‎base_layer/core/src/base_node/state_machine_service/states/events_and_states.rs‎
Lines changed: 55 additions & 2 deletions
@@ -20,10 +20,9 @@
 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 // USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-use std::sync::Arc;
-
 use log::*;
-use tari_comms::{connectivity::ConnectivityRequester, PeerManager};
+use tari_comms::connectivity::ConnectivityRequester;
+use tari_comms_dht::Dht;
 use tari_service_framework::{async_trait, ServiceInitializationError, ServiceInitializer, ServiceInitializerContext};
 use tokio::sync::{broadcast, watch};
 
@@ -104,17 +103,17 @@ where B: BlockchainBackend + 'static
             let chain_metadata_service = handles.expect_handle::<ChainMetadataHandle>();
             let node_local_interface = handles.expect_handle::<LocalNodeCommsInterface>();
             let connectivity = handles.expect_handle::<ConnectivityRequester>();
-            let peer_manager = handles.expect_handle::<Arc<PeerManager>>();
 
             let sync_validators =
                 SyncValidators::full_consensus(rules.clone(), factories, bypass_range_proof_verification);
 
+            let dht = handles.expect_handle::<Dht>(); // Get Dht handle
             let node = BaseNodeStateMachine::new(
                 db,
                 node_local_interface,
                 connectivity,
-                peer_manager,
                 chain_metadata_service.get_event_stream(),
+                dht.subscribe_dht_events(), // Pass DhtEventReceiver
                 config,
                 sync_validators,
                 status_event_sender,
@@ -123,7 +122,6 @@ where B: BlockchainBackend + 'static
                 rules,
                 handles.get_shutdown_signal(),
             );
-
             node.run().await;
             info!(target: LOG_TARGET, "Base Node State Machine Service has shut down");
         });
 
@@ -26,7 +26,8 @@ use log::*;
 use randomx_rs::RandomXFlag;
 use serde::{Deserialize, Serialize};
 use tari_common::configuration::serializers;
-use tari_comms::{connectivity::ConnectivityRequester, PeerManager};
+use tari_comms::connectivity::ConnectivityRequester;
+use tari_comms_dht::event::DhtEventReceiver;
 use tari_shutdown::ShutdownSignal;
 use tokio::sync::{broadcast, watch};
 
@@ -44,7 +45,6 @@ use crate::{
     consensus::ConsensusManager,
     proof_of_work::randomx_factory::RandomXFactory,
 };
-
 const LOG_TARGET: &str = "c::bn::base_node";
 
 /// Configuration for the BaseNodeStateMachine.
@@ -90,27 +90,29 @@ pub struct BaseNodeStateMachine<B: BlockchainBackend> {
     pub(super) db: AsyncBlockchainDb<B>,
     pub(super) local_node_interface: LocalNodeCommsInterface,
     pub(super) connectivity: ConnectivityRequester,
-    pub(super) peer_manager: Arc<PeerManager>,
     pub(super) metadata_event_stream: broadcast::Receiver<Arc<ChainMetadataEvent>>,
+    pub(super) dht_event_stream: DhtEventReceiver,
     pub(super) config: BaseNodeStateMachineConfig,
     pub(super) info: StateInfo,
     pub(super) sync_validators: SyncValidators<B>,
     pub(super) consensus_rules: ConsensusManager,
     pub(super) status_event_sender: Arc<watch::Sender<StatusInfo>>,
     pub(super) randomx_factory: RandomXFactory,
     is_bootstrapped: bool,
+    pub(super) is_primary_bootstrap_complete: bool,
     event_publisher: broadcast::Sender<Arc<StateEvent>>,
     interrupt_signal: ShutdownSignal,
 }
 
 impl<B: BlockchainBackend + 'static> BaseNodeStateMachine<B> {
-    /// Instantiate a new Base Node.
+    // Instantiate a new Base Node.
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         db: AsyncBlockchainDb<B>,
         local_node_interface: LocalNodeCommsInterface,
         connectivity: ConnectivityRequester,
-        peer_manager: Arc<PeerManager>,
         metadata_event_stream: broadcast::Receiver<Arc<ChainMetadataEvent>>,
+        dht_event_stream: DhtEventReceiver, // New parameter
         config: BaseNodeStateMachineConfig,
         sync_validators: SyncValidators<B>,
         status_event_sender: watch::Sender<StatusInfo>,
@@ -123,15 +125,16 @@ impl<B: BlockchainBackend + 'static> BaseNodeStateMachine<B> {
             db,
             local_node_interface,
             connectivity,
-            peer_manager,
             metadata_event_stream,
+            dht_event_stream, // Initialize new field
             config,
             info: StateInfo::StartUp,
             event_publisher,
             status_event_sender: Arc::new(status_event_sender),
             sync_validators,
             randomx_factory,
             is_bootstrapped: false,
+            is_primary_bootstrap_complete: false,
             consensus_rules,
             interrupt_signal,
         }
@@ -283,6 +286,38 @@ impl<B: BlockchainBackend + 'static> BaseNodeStateMachine<B> {
         }
     }
 
+    pub fn set_primary_bootstrap_complete(&mut self, complete: bool) {
+        info!(
+            target: LOG_TARGET,
+            "[BN SM UPDATE] Setting primary_bootstrap_complete to {}. Was: {}. Current state: {}",
+            complete,
+            self.is_primary_bootstrap_complete,
+            self.info.short_desc()
+        );
+
+        self.is_primary_bootstrap_complete = complete;
+
+        if let StateInfo::Listening(mut info) = self.info.clone() {
+            let had_bootstrap_phase = info.bootstrap_phase.is_some();
+            if complete {
+                info.bootstrap_phase = None;
+            }
+            self.set_state_info(StateInfo::Listening(info));
+
+            info!(
+                target: LOG_TARGET,
+                "[BN SM UPDATE] Updated Listening state. Removed bootstrap_phase: {}. Console should now show 'Listening'",
+                had_bootstrap_phase
+            );
+        } else {
+            warn!(
+                target: LOG_TARGET,
+                "[BN SM UPDATE] Not in Listening state ({}), bootstrap_complete flag updated but UI unchanged",
+                self.info.short_desc()
+            );
+        }
+    }
+
     /// Return a copy of the `interrupt_signal` for this node. This is a `ShutdownSignal` future that will be ready when
     /// the node will enter a `Shutdown` state.
     pub fn get_interrupt_signal(&self) -> ShutdownSignal {
 
@@ -32,7 +32,6 @@ use crate::base_node::{
         HeaderSyncState,
         HorizonStateSync,
         Listening,
-        ListeningInfo,
         Shutdown,
         Starting,
         Waiting,
@@ -179,6 +178,54 @@ impl Display for BaseNodeState {
     }
 }
 
+// Add BootstrapPhaseInfo struct
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct BootstrapPhaseInfo {
+    pub current_round: usize,
+    pub total_rounds: usize,
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
+/// This struct contains info that is useful for external viewing of state info
+pub struct ListeningInfo {
+    pub synced: bool,
+    pub initial_delay_connected_count: u64,
+    pub initial_sync_peer_wait_count: u64,
+    pub bootstrap_phase: Option<BootstrapPhaseInfo>,
+}
+impl Display for ListeningInfo {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        fmt.write_str("Node in listening state\n")
+    }
+}
+
+impl ListeningInfo {
+    /// Creates a new ListeningInfo
+    pub const fn new(is_synced: bool, initial_delay_connected_count: u64, initial_sync_peer_wait_count: u64) -> Self {
+        Self {
+            synced: is_synced,
+            initial_delay_connected_count,
+            initial_sync_peer_wait_count,
+            bootstrap_phase: None,
+        }
+    }
+
+    pub fn is_synced(&self) -> bool {
+        self.synced
+    }
+
+    pub fn is_bootstrapping(&self) -> bool {
+        self.bootstrap_phase.is_some()
+    }
+
+    pub fn initial_delay_connected_count(&self) -> u64 {
+        self.initial_delay_connected_count
+    }
+
+    pub fn initial_sync_peer_wait_count(&self) -> u64 {
+        self.initial_sync_peer_wait_count
+    }
+}
+
 /// This enum will display all info inside of the state engine
 #[derive(Debug, Clone, PartialEq)]
 pub enum StateInfo {
@@ -211,7 +258,13 @@ impl StateInfo {
 
             BlockSync(info) => format!("Syncing blocks: {}", info.sync_progress_string_blocks()),
             Listening(info) => {
-                if info.is_synced() {
+                // NEW: Prioritize bootstrap display if active
+                if let Some(bootstrap_info) = info.bootstrap_phase {
+                    format!(
+                        "Bootstrapping via seeds (Round {}/{})",
+                        bootstrap_info.current_round, bootstrap_info.total_rounds
+                    )
+                } else if info.is_synced() {
                     "Listening".to_string()
                 } else {
                     format!(