allow validator to validate nodes using sdk

Author: JannikSt

crates/prime-protocol-py/examples/validator_list_nodes.py

@@ -11,37 +11,6 @@
 logging.basicConfig(format=FORMAT)
 logging.getLogger().setLevel(logging.INFO)
 
-
-def print_node_summary(nodes: List) -> None:
-    """Print a summary of nodes"""
-    print(f"\nTotal nodes found: {len(nodes)}")
-    
-    if not nodes:
-        print("No non-validated nodes found.")
-        return
-    
-    print("\nNon-validated nodes:")
-    print("-" * 80)
-    
-    for idx, node in enumerate(nodes, 1):
-        print(f"\n{idx}. Node ID: {node.id}")
-        print(f"   Provider Address: {node.provider_address}")
-        print(f"   IP: {node.ip_address}:{node.port}")
-        print(f"   Compute Pool ID: {node.compute_pool_id}")
-        print(f"   Active: {node.is_active}")
-        print(f"   Whitelisted: {node.is_provider_whitelisted}")
-        print(f"   Blacklisted: {node.is_blacklisted}")
-        
-        if node.worker_p2p_id:
-            print(f"   P2P ID: {node.worker_p2p_id}")
-        
-        if node.created_at:
-            print(f"   Created At: {node.created_at}")
-        
-        if node.last_updated:
-            print(f"   Last Updated: {node.last_updated}")
-
-
 def main():
     # Get configuration from environment variables
     rpc_url = os.getenv("RPC_URL", "http://localhost:8545")
@@ -62,19 +31,28 @@ def main():
         validator = ValidatorClient(
             rpc_url=rpc_url,
             private_key=private_key,
-            discovery_urls=discovery_urls
+            discovery_urls=discovery_urls,
         )
+        print("Starting validator client...")
+        validator.start()
+        print("Validator client started")
 
         # List all non-validated nodes
         print("\nFetching non-validated nodes from discovery service...")
         non_validated_nodes = validator.list_non_validated_nodes()
-        
-        # Print summary
-        print_node_summary(non_validated_nodes)
+        for node in non_validated_nodes:
+            print(node.id)
+            if node.is_validated is False:
+                print(f"Validating node {node.id}...")
+                validator.validate_node(node.id, node.provider_address)
+                print(f"Node {node.id} validated")
+            else:
+                print(f"Node {node.id} is already validated")
 
         # You can also get all nodes as dictionaries for more flexibility
         print("\n\nFetching all nodes as dictionaries...")
         all_nodes = validator.list_all_nodes_dict()
+        print(all_nodes)
 
         # Count validated vs non-validated
         validated_count = sum(1 for node in all_nodes if node['is_validated'])

crates/prime-protocol-py/src/validator/mod.rs

@@ -1,12 +1,14 @@
 use crate::p2p_handler::auth::AuthenticationManager;
 use crate::p2p_handler::message_processor::{MessageProcessor, MessageProcessorConfig};
 use crate::p2p_handler::{Message, MessageType, Service as P2PService};
+use alloy::primitives::Address;
 use p2p::{Keypair, PeerId};
 use pyo3::prelude::*;
 use pythonize::pythonize;
 use shared::models::node::DiscoveryNode;
 use shared::security::request_signer::sign_request_with_nonce;
-use shared::web3::wallet::Wallet;
+use shared::web3::contracts::core::builder::{ContractBuilder, Contracts};
+use shared::web3::wallet::{Wallet, WalletProvider};
 use std::sync::Arc;
 use std::time::Duration;
 use tokio::sync::mpsc::{Receiver, Sender};
@@ -94,6 +96,7 @@ pub(crate) struct ValidatorClient {
     user_message_rx: Option<Arc<Mutex<Receiver<Message>>>>,
     message_processor_handle: Option<JoinHandle<()>>,
     peer_id: Option<PeerId>,
+    contracts: Option<Arc<Contracts<WalletProvider>>>,
 }
 
 #[pymethods]
@@ -128,6 +131,7 @@ impl ValidatorClient {
             user_message_rx: None,
             message_processor_handle: None,
             peer_id: None,
+            contracts: None,
         })
     }
 
@@ -188,7 +192,40 @@ impl ValidatorClient {
     /// Initialize the validator client with optional P2P support
     #[pyo3(signature = (p2p_port=None))]
     pub fn start(&mut self, py: Python, p2p_port: Option<u16>) -> PyResult<()> {
-        let rt = self.get_or_create_runtime()?;
+        // Initialize contracts if not already done
+        if self.contracts.is_none() {
+            let wallet = self.wallet.as_ref().ok_or_else(|| {
+                PyErr::new::<pyo3::exceptions::PyRuntimeError, _>("Wallet not initialized")
+            })?;
+
+            let wallet_provider = wallet.provider();
+
+            // Get runtime reference and use it before mutating self
+            let rt = self.runtime.as_ref().ok_or_else(|| {
+                PyErr::new::<pyo3::exceptions::PyRuntimeError, _>("Runtime not initialized")
+            })?;
+
+            let contracts = py.allow_threads(|| {
+                rt.block_on(async {
+                    // Build all contracts (required due to known bug)
+                    ContractBuilder::new(wallet_provider)
+                        .with_compute_pool()
+                        .with_compute_registry()
+                        .with_ai_token()
+                        .with_prime_network()
+                        .with_stake_manager()
+                        .build()
+                        .map_err(|e| {
+                            PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(format!(
+                                "Failed to build contracts: {}",
+                                e
+                            ))
+                        })
+                })
+            })?;
+
+            self.contracts = Some(Arc::new(contracts));
+        }
 
         if let Some(port) = p2p_port {
             // Initialize P2P if port is provided
@@ -202,6 +239,11 @@ impl ValidatorClient {
 
             let cancellation_token = self.cancellation_token.clone();
 
+            // Get runtime reference for P2P initialization
+            let rt = self.runtime.as_ref().ok_or_else(|| {
+                PyErr::new::<pyo3::exceptions::PyRuntimeError, _>("Runtime not initialized")
+            })?;
+
             // Create the P2P components
             let (auth_manager, peer_id, outbound_tx, user_message_rx, message_processor_handle) =
                 py.allow_threads(|| {
@@ -296,6 +338,124 @@ impl ValidatorClient {
         }
     }
 
+    /// Validate a node on the Prime Network contract
+    ///
+    /// Args:
+    ///     node_address: The node address to validate
+    ///     provider_address: The provider's address
+    ///
+    /// Returns:
+    ///     Transaction hash as a string if successful
+    pub fn validate_node(
+        &self,
+        py: Python,
+        node_address: String,
+        provider_address: String,
+    ) -> PyResult<String> {
+        let rt = self.get_or_create_runtime()?;
+
+        let contracts = self.contracts.as_ref().ok_or_else(|| {
+            PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(
+                "Contracts not initialized. Call start() first.",
+            )
+        })?;
+
+        let contracts_clone = contracts.clone();
+
+        // Release the GIL while performing async operations
+        py.allow_threads(|| {
+            rt.block_on(async {
+                // Parse addresses
+                let provider_addr =
+                    Address::parse_checksummed(&provider_address, None).map_err(|e| {
+                        PyErr::new::<pyo3::exceptions::PyValueError, _>(format!(
+                            "Invalid provider address: {}",
+                            e
+                        ))
+                    })?;
+
+                let node_addr = Address::parse_checksummed(&node_address, None).map_err(|e| {
+                    PyErr::new::<pyo3::exceptions::PyValueError, _>(format!(
+                        "Invalid node address: {}",
+                        e
+                    ))
+                })?;
+
+                let tx_hash = contracts_clone
+                    .prime_network
+                    .validate_node(provider_addr, node_addr)
+                    .await
+                    .map_err(|e| {
+                        PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(format!(
+                            "Failed to validate node: {}",
+                            e
+                        ))
+                    })?;
+
+                Ok(format!("0x{}", hex::encode(tx_hash)))
+            })
+        })
+    }
+
+    /// Validate a node on the Prime Network contract with explicit addresses
+    ///
+    /// Args:
+    ///     provider_address: The provider's address
+    ///     node_address: The node's address  
+    ///
+    /// Returns:
+    ///     Transaction hash as a string if successful
+    pub fn validate_node_with_addresses(
+        &self,
+        py: Python,
+        provider_address: String,
+        node_address: String,
+    ) -> PyResult<String> {
+        let rt = self.get_or_create_runtime()?;
+
+        let contracts = self.contracts.as_ref().ok_or_else(|| {
+            PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(
+                "Contracts not initialized. Call start() first.",
+            )
+        })?;
+
+        let contracts_clone = contracts.clone();
+
+        // Release the GIL while performing async operations
+        py.allow_threads(|| {
+            rt.block_on(async {
+                // Parse addresses
+                let provider_addr =
+                    Address::parse_checksummed(&provider_address, None).map_err(|e| {
+                        PyErr::new::<pyo3::exceptions::PyValueError, _>(format!(
+                            "Invalid provider address: {}",
+                            e
+                        ))
+                    })?;
+
+                let node_addr = Address::parse_checksummed(&node_address, None).map_err(|e| {
+                    PyErr::new::<pyo3::exceptions::PyValueError, _>(format!(
+                        "Invalid node address: {}",
+                        e
+                    ))
+                })?;
+
+                let tx_hash = contracts_clone
+                    .prime_network
+                    .validate_node(provider_addr, node_addr)
+                    .await
+                    .map_err(|e| {
+                        PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(format!(
+                            "Failed to validate node: {}",
+                            e
+                        ))
+                    })?;
+
+                Ok(format!("0x{}", hex::encode(tx_hash)))
+            })
+        })
+    }
+
     /// Get the validator's peer ID
     pub fn get_peer_id(&self) -> PyResult<Option<String>> {
         Ok(self.peer_id.map(|id| id.to_string()))