Add sc-proof-of-time dependency and integrate synthetic PoT slot handling in development mode for enhanced block production. Update configurations and structures in manual_seal.rs and lib.rs to support new functionality.

Author: jfrank-summit

Cargo.lock

@@ -21,6 +21,7 @@ sc-consensus.workspace = true
 sc-telemetry.workspace = true
 sc-transaction-pool-api.workspace = true
 sc-utils.workspace = true
+sc-proof-of-time.workspace = true
 sp-api.workspace = true
 sp-block-builder = { workspace = true, features = ["std"] }
 sp-blockchain.workspace = true

crates/sc-consensus-subspace-dev/Cargo.toml

@@ -8,6 +8,7 @@ use crate::mock_digest::{MockSlotCalculator, create_genesis_solution, create_moc
 use sc_client_api::BlockBackend;
 use sc_consensus::{BlockImport, BlockImportParams, ForkChoiceStrategy, ImportResult, StateAction};
 use sc_transaction_pool_api::TransactionPool;
+use sc_proof_of_time::source::PotSlotInfo;
 use sp_api::ProvideRuntimeApi;
 use sp_blockchain::{HeaderBackend, HeaderMetadata};
 use sp_consensus::{BlockOrigin, Environment, Proposer};
@@ -17,7 +18,9 @@ use std::marker::PhantomData;
 use std::sync::Arc;
 use std::time::Duration;
 use subspace_core_primitives::PublicKey;
+use subspace_core_primitives::pot::PotCheckpoints;
 use tokio::time::sleep;
+use tokio::sync::broadcast::Sender as BroadcastSender;
 use tracing::{debug, info, warn};
 
 /// Parameters for dev consensus
@@ -39,6 +42,8 @@ pub struct DevConsensusParams<Block, Client, E, TP, CIDP> {
     pub farmer_public_key: PublicKey,
     /// Whether to finalize blocks immediately
     pub finalize: bool,
+    /// Sender for synthetic PoT slot notifications (dev mode only)
+    pub pot_slot_sender: Option<BroadcastSender<PotSlotInfo>>,
     /// Marker
     pub _phantom: PhantomData<Block>,
 }
@@ -55,6 +60,7 @@ pub struct DevConsensus<Block, Client, E, TP, CIDP> {
     farmer_public_key: PublicKey,
     finalize: bool,
     slot_calculator: MockSlotCalculator,
+    pot_slot_sender: Option<BroadcastSender<PotSlotInfo>>,
     _phantom: PhantomData<Block>,
 }
 
@@ -91,6 +97,7 @@ where
             farmer_public_key: params.farmer_public_key,
             finalize: params.finalize,
             slot_calculator: MockSlotCalculator::new(slot_duration_ms),
+            pot_slot_sender: params.pot_slot_sender,
             _phantom: PhantomData,
         }
     }
@@ -152,6 +159,15 @@ where
             next_block_number, *slot, parent_hash
         );
 
+        // Emit synthetic PoT slot info (dev mode)
+        if let Some(sender) = &self.pot_slot_sender {
+            // Use empty checkpoints; PoT verification is bypassed in dev mode
+            let _ = sender.send(PotSlotInfo {
+                slot,
+                checkpoints: PotCheckpoints::default(),
+            });
+        }
+
         // Create mock solution and pre-digest
         let solution = create_genesis_solution(self.farmer_public_key, self.farmer_public_key);
         let pre_digest = create_mock_pre_digest(slot, solution);

crates/sc-consensus-subspace-dev/src/manual_seal.rs

@@ -1222,26 +1222,43 @@ where
     let object_mapping_notification_stream = subspace_link.object_mapping_notification_stream();
     let archived_segment_notification_stream = subspace_link.archived_segment_notification_stream();
 
-    let (pot_source_worker, pot_gossip_worker, pot_slot_info_stream) = PotSourceWorker::new(
-        config.is_timekeeper,
-        config.timekeeper_cpu_cores,
-        client.clone(),
-        pot_verifier.clone(),
-        Arc::clone(&network_service),
-        pot_gossip_notification_service,
-        sync_service.clone(),
-        sync_oracle.clone(),
-    )
-    .map_err(|error| Error::Other(error.into()))?;
+    // Pot slot info stream used by domains and block production
+    // In dev mode, use synthetic stream; otherwise start real PoT workers
+    let (dev_pot_slot_sender_opt, pot_slot_info_stream_opt, additional_pot_slot_info_stream): (
+        Option<broadcast::Sender<PotSlotInfo>>,
+        Option<sc_proof_of_time::source::PotSlotInfoStream>,
+        broadcast::Receiver<PotSlotInfo>,
+    ) = if config.dev_no_farming {
+        // Dev mode: create synthetic PoT slot stream (no real PoT workers needed)
+        let (dev_pot_slot_sender, dev_pot_slot_receiver) =
+            tokio::sync::broadcast::channel::<PotSlotInfo>(16);
+        // In dev mode, slot worker is not used, so pot_slot_info_stream_opt is None
+        (Some(dev_pot_slot_sender), None, dev_pot_slot_receiver)
+    } else {
+        // Production mode: start real PoT source workers (needed for domains and block production)
+        let (pot_source_worker, pot_gossip_worker, pot_slot_info_stream) = PotSourceWorker::new(
+            config.is_timekeeper,
+            config.timekeeper_cpu_cores,
+            client.clone(),
+            pot_verifier.clone(),
+            Arc::clone(&network_service),
+            pot_gossip_notification_service,
+            sync_service.clone(),
+            sync_oracle.clone(),
+        )
+        .map_err(|error| Error::Other(error.into()))?;
 
-    let additional_pot_slot_info_stream = pot_source_worker.subscribe_pot_slot_info_stream();
+        let additional_pot_slot_info_stream = pot_source_worker.subscribe_pot_slot_info_stream();
 
-    task_manager
-        .spawn_essential_handle()
-        .spawn("pot-source", Some("pot"), pot_source_worker.run());
-    task_manager
-        .spawn_essential_handle()
-        .spawn("pot-gossip", Some("pot"), pot_gossip_worker.run());
+        task_manager
+            .spawn_essential_handle()
+            .spawn("pot-source", Some("pot"), pot_source_worker.run());
+        task_manager
+            .spawn_essential_handle()
+            .spawn("pot-gossip", Some("pot"), pot_gossip_worker.run());
+
+        (None, Some(pot_slot_info_stream), additional_pot_slot_info_stream)
+    };
 
     if config.base.role.is_authority() || config.force_new_slot_notifications {
         // Check if dev-no-farming mode is enabled
@@ -1250,6 +1267,9 @@ where
             warn!("⚠️  This mode bypasses consensus and is FOR DEVELOPMENT ONLY");
             warn!("⚠️  DO NOT USE IN PRODUCTION");
 
+            // Use the synthetic PoT slot sender created above for dev mode block production
+            let dev_pot_slot_sender = dev_pot_slot_sender_opt.expect("dev_pot_slot_sender should be Some in dev mode; qed");
+
             let proposer_factory = ProposerFactory::new(
                 task_manager.spawn_handle(),
                 client.clone(),
@@ -1316,6 +1336,7 @@ where
                 block_interval,
                 farmer_public_key,
                 finalize: false, // TODO: Add finalization support if needed
+                pot_slot_sender: Some(dev_pot_slot_sender),
                 _phantom: std::marker::PhantomData,
             });
 
@@ -1335,6 +1356,9 @@ where
             );
         } else {
             // Production consensus path
+            // PoT workers already started unconditionally above
+            let pot_slot_info_stream = pot_slot_info_stream_opt.expect("pot_slot_info_stream should be Some in production mode; qed");
+
             let proposer_factory = ProposerFactory::new(
                 task_manager.spawn_handle(),
                 client.clone(),