fix(validator): use CRv4 commit-reveal for standalone weight submitter

Change from direct set_weights to WeightSubmitter which handles:
- CRv4 timelock encryption automatically
- Chain auto-reveals when DRAND pulse arrives
- No manual reveal needed

The WeightSubmitter detects chain version and encrypts weights
with DRAND-based timelock encryption.

Author: echobt

bins/validator-node/src/main.rs

@@ -739,12 +739,19 @@ async fn main() -> Result<()> {
                         info!("Background hourly weight handler spawned");
 
                         // Spawn standalone hourly weight submitter (decoupled from P2P)
-                        standalone_weight_submitter = Some(spawn_standalone_weight_submitter(
-                            subtensor.as_ref().unwrap().clone(),
-                            (**subtensor_signer.as_ref().unwrap()).clone(),
+                        match spawn_standalone_weight_submitter(
+                            endpoint,
                             args.netuid,
-                        ));
-                        info!("Standalone hourly weight submitter spawned");
+                            secret,
+                        ).await {
+                            Ok(handle) => {
+                                standalone_weight_submitter = Some(handle);
+                                info!("Standalone hourly weight submitter spawned");
+                            }
+                            Err(e) => {
+                                error!("Failed to spawn standalone weight submitter: {}", e);
+                            }
+                        }
 
                         if endpoint != &args.subtensor_endpoint {
                             warn!(

bins/validator-node/src/standalone_weight_submitter.rs

@@ -1,6 +1,10 @@
 //! Standalone weight submission thread.
 //! Completely decoupled from P2P rate limiting and block sync.
 //! Fetches weights from chain.platform.zip and submits directly to Bittensor.
+//!
+//! Uses CRv4 commit-reveal for weight submission:
+//! - Commit: Encrypt weights with timelock (DRAND-based)
+//! - Reveal: Automatic when DRAND pulse becomes available
 
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
@@ -10,9 +14,12 @@ use anyhow::Result;
 use chrono::{Timelike, Utc};
 use reqwest::Client;
 use serde::Deserialize;
+use tokio::sync::Mutex;
 use tracing::{debug, error, info, warn};
 
-use platform_bittensor::{BittensorSigner, ExtrinsicWait, Subtensor};
+use platform_bittensor::{
+    BittensorConfig, SubtensorClient, WeightSubmitter,
+};
 
 /// URL for fetching pre-computed weights
 const WEIGHT_RPC_URL: &str = "https://chain.platform.zip/rpc";
@@ -48,35 +55,44 @@ struct WeightEntry {
 }
 
 /// Standalone weight submitter - no P2P dependencies
+/// Uses WeightSubmitter internally for CRv4 commit-reveal support
 pub struct StandaloneWeightSubmitter {
-    subtensor: Arc<Subtensor>,
-    signer: BittensorSigner,
-    netuid: u16,
+    weight_submitter: Arc<Mutex<WeightSubmitter>>,
     http_client: Client,
-    last_submission_hour: Arc<tokio::sync::Mutex<Option<i64>>>,
+    last_submission_hour: Arc<Mutex<Option<i64>>>,
     running: Arc<AtomicBool>,
 }
 
 impl StandaloneWeightSubmitter {
-    /// Create a new standalone weight submitter
-    pub fn new(
-        subtensor: Arc<Subtensor>,
-        signer: BittensorSigner,
+    pub async fn new(
+        endpoint: &str,
         netuid: u16,
-    ) -> Self {
+        signer_seed: &str,
+    ) -> Result<Self> {
         let http_client = Client::builder()
             .timeout(Duration::from_secs(30))
             .build()
             .expect("Failed to create HTTP client");
 
-        Self {
-            subtensor,
-            signer,
+        let config = BittensorConfig {
+            endpoint: endpoint.to_string(),
             netuid,
+            use_commit_reveal: true,
+            version_key: 1,
+        };
+        
+        let mut client = SubtensorClient::new(config);
+        client.connect().await?;
+        client.set_signer(signer_seed)?;
+        
+        let weight_submitter = WeightSubmitter::new(client, None);
+        
+        Ok(Self {
+            weight_submitter: Arc::new(Mutex::new(weight_submitter)),
             http_client,
-            last_submission_hour: Arc::new(tokio::sync::Mutex::new(None)),
+            last_submission_hour: Arc::new(Mutex::new(None)),
             running: Arc::new(AtomicBool::new(true)),
-        }
+        })
     }
 
     /// Shutdown gracefully
@@ -85,26 +101,26 @@ impl StandaloneWeightSubmitter {
         info!("Standalone weight submitter shutdown requested");
     }
 
-    /// Run the submission loop (call in a spawned task)
     pub async fn run(&self) {
         let mut interval = tokio::time::interval(Duration::from_secs(CHECK_INTERVAL_SECS));
 
         info!(
             url = WEIGHT_RPC_URL,
-            netuid = self.netuid,
             "Standalone weight submitter started (hourly at :00)"
         );
 
-        while self.running.load(Ordering::SeqCst) {
+        loop {
             interval.tick().await;
 
+            if !self.running.load(Ordering::SeqCst) {
+                break;
+            }
+            
             let now = Utc::now();
 
-            // Check if we're at the top of the hour (minute 0)
             if now.minute() == 0 {
                 let hour_epoch = now.timestamp() / 3600;
 
-                // Dedup: only submit once per hour
                 let mut last = self.last_submission_hour.lock().await;
                 if let Some(last_hour) = *last {
                     if last_hour == hour_epoch {
@@ -113,7 +129,6 @@ impl StandaloneWeightSubmitter {
                     }
                 }
 
-                // Try to submit with retries
                 match self.submit_with_retry().await {
                     Ok(()) => {
                         *last = Some(hour_epoch);
@@ -155,40 +170,31 @@ impl StandaloneWeightSubmitter {
         Err(last_error.unwrap_or_else(|| anyhow::anyhow!("Unknown error")))
     }
 
-    /// Fetch weights from RPC and submit to chain
     async fn fetch_and_submit(&self) -> Result<()> {
-        // 1. Fetch from chain.platform.zip
         let weights = self.fetch_weights().await?;
 
         if weights.is_empty() {
             warn!("Empty weights from RPC");
             return Ok(());
         }
 
-        // 2. Submit each mechanism
-        for mw in weights {
-            let uids: Vec<u16> = mw.entries.iter().map(|e| e.uid).collect();
-            let weights: Vec<u16> = mw.entries.iter().map(|e| e.weight).collect();
-            
-            info!(
-                mechanism_id = mw.mechanism_id,
-                uid_count = uids.len(),
-                total_weight = weights.iter().map(|w| *w as u64).sum::<u64>(),
-                "Submitting weights to Bittensor"
-            );
-            
-            self.subtensor
-                .set_weights(
-                    &self.signer,
-                    self.netuid,
-                    &uids,
-                    &weights,
-                    mw.mechanism_id as u64,
-                    ExtrinsicWait::Finalized,
-                )
-                .await
-                .map_err(|e| anyhow::anyhow!("set_weights failed: {}", e))?;
-        }
+        let mechanism_weights: Vec<(u8, Vec<u16>, Vec<u16>)> = weights
+            .into_iter()
+            .map(|mw| {
+                let uids: Vec<u16> = mw.entries.iter().map(|e| e.uid).collect();
+                let weights: Vec<u16> = mw.entries.iter().map(|e| e.weight).collect();
+                info!(
+                    mechanism_id = mw.mechanism_id,
+                    uid_count = uids.len(),
+                    total_weight = weights.iter().map(|w| *w as u64).sum::<u64>(),
+                    "Submitting weights to Bittensor via CRv4"
+                );
+                (mw.mechanism_id, uids, weights)
+            })
+            .collect();
+        
+        let mut submitter = self.weight_submitter.lock().await;
+        submitter.submit_mechanism_weights_batch(&mechanism_weights).await?;
 
         Ok(())
     }
@@ -224,20 +230,20 @@ impl StandaloneWeightSubmitter {
     }
 }
 
-/// Spawn the standalone weight submitter in a dedicated task.
-pub fn spawn_standalone_weight_submitter(
-    subtensor: Arc<Subtensor>,
-    signer: BittensorSigner,
+pub async fn spawn_standalone_weight_submitter(
+    endpoint: &str,
     netuid: u16,
-) -> Arc<StandaloneWeightSubmitter> {
-    let submitter = Arc::new(StandaloneWeightSubmitter::new(subtensor, signer, netuid));
+    signer_seed: &str,
+) -> Result<Arc<StandaloneWeightSubmitter>> {
+    let submitter = Arc::new(StandaloneWeightSubmitter::new(endpoint, netuid, signer_seed).await?);
     let submitter_clone = submitter.clone();
 
-    tokio::spawn(async move {
-        submitter_clone.run().await;
+    std::thread::spawn(move || {
+        let rt = tokio::runtime::Runtime::new().expect("Failed to create runtime for weight submitter");
+        rt.block_on(submitter_clone.run());
     });
 
-    submitter
+    Ok(submitter)
 }
 
 #[cfg(test)]