Fix deploy command network parsing logic for "all" networks

Co-authored-by: 0xrinegade <[email protected]>

Author: Copilot

src/main.rs

@@ -927,26 +927,14 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 .map(|s| s.as_str())
                 .unwrap_or("all");
 
-            // Parse network type
-            let network_type = match network_str.to_lowercase().as_str() {
-                "mainnet" => ssh_deploy::NetworkType::Mainnet,
-                "testnet" => ssh_deploy::NetworkType::Testnet,
-                "devnet" => ssh_deploy::NetworkType::Devnet,
-                "all" => ssh_deploy::NetworkType::Mainnet, // Default value, will deploy to all
-                _ => {
-                    eprintln!("Invalid network: {}", network_str);
-                    exit(1);
-                }
-            };
-            
             // Create deployment configuration
             let deploy_config = ebpf_deploy::DeployConfig {
                 binary_path: binary_path.to_string(),
                 program_id_path: program_id_path.to_string(),
                 owner_path: owner_path.to_string(),
                 fee_payer_path: fee_payer_path.to_string(),
                 publish_idl,
-                network_type,
+                network_filter: network_str.to_string(), // Pass the original network string
             };
 
             println!("Deploying eBPF binary to SVM networks...");

src/utils/ebpf_deploy.rs

@@ -30,7 +30,7 @@ use {
 ///     owner_path: "owner_keypair.json".to_string(),
 ///     fee_payer_path: "fee_payer.json".to_string(),
 ///     publish_idl: true,
-///     network_type: NetworkType::Mainnet,
+///     network_filter: "all".to_string(),
 /// };
 /// 
 /// let results = deploy_to_all_networks(config, CommitmentConfig::confirmed()).await;
@@ -86,8 +86,8 @@ pub struct DeployConfig {
     pub fee_payer_path: String,
     /// Whether to publish IDL
     pub publish_idl: bool,
-    /// Network to deploy on
-    pub network_type: NetworkType,
+    /// Network filter (mainnet, testnet, devnet, or all)
+    pub network_filter: String,
 }
 
 /// Result of a deployment operation
@@ -149,11 +149,7 @@ pub async fn deploy_to_network(
     let program_data = load_program(&config.binary_path)?;
 
     // Get network name for result
-    let network_name = match config.network_type {
-        NetworkType::Mainnet => "mainnet".to_string(),
-        NetworkType::Testnet => "testnet".to_string(),
-        NetworkType::Devnet => "devnet".to_string(),
-    };
+    let network_name = config.network_filter.clone();
 
     println!("Deploying to {} network...", network_name);
     println!("  Program ID: {}", program_id);
@@ -244,21 +240,23 @@ pub async fn deploy_to_all_networks(
 ) -> Vec<Result<DeploymentResult, EbpfDeployError>> {
     let mut results = Vec::new();
 
-    // List of networks to deploy to
-    // In a real implementation, this would query available networks dynamically
-    let networks = match config.network_type {
-        NetworkType::Mainnet => vec![NetworkType::Mainnet],
-        NetworkType::Testnet => vec![NetworkType::Testnet],
-        NetworkType::Devnet => vec![NetworkType::Devnet],
-        // Handle the case when "all" networks are specified
-        // In reality NetworkType doesn't have a variant for "all", but we handle it here for completeness
-        #[allow(unreachable_patterns)]
-        _ => vec![NetworkType::Mainnet, NetworkType::Testnet, NetworkType::Devnet],
+    // Determine which networks to deploy to based on the filter
+    let networks = match config.network_filter.to_lowercase().as_str() {
+        "mainnet" => vec![NetworkType::Mainnet],
+        "testnet" => vec![NetworkType::Testnet],
+        "devnet" => vec![NetworkType::Devnet],
+        "all" => vec![NetworkType::Mainnet, NetworkType::Testnet, NetworkType::Devnet],
+        _ => {
+            // Invalid network filter, return error
+            let error = EbpfDeployError::NetworkNotAvailable(
+                format!("Invalid network filter: {}", config.network_filter)
+            );
+            return vec![Err(error)];
+        }
     };
 
     for network in networks {
         // Create client for the specific network
-        // In a real implementation, this would use the appropriate RPC URL for each network
         let client_url = match network {
             NetworkType::Mainnet => "https://api.mainnet-beta.solana.com",
             NetworkType::Testnet => "https://api.testnet.solana.com",
@@ -269,7 +267,11 @@ pub async fn deploy_to_all_networks(
 
         // Create network-specific config
         let network_config = DeployConfig {
-            network_type: network,
+            network_filter: match network {
+                NetworkType::Mainnet => "mainnet".to_string(),
+                NetworkType::Testnet => "testnet".to_string(),
+                NetworkType::Devnet => "devnet".to_string(),
+            },
             ..config.clone()
         };
 

tests/ebpf_deploy_tests.rs

@@ -1,8 +1,7 @@
-use osvm::utils::ebpf_deploy::{DeployConfig, load_program_id, load_keypair, load_program};
-use osvm::utils::ssh_deploy::NetworkType;
-use std::fs::{self, File};
+use osvm::utils::ebpf_deploy::{DeployConfig, load_program_id, load_program, deploy_to_all_networks};
+use solana_sdk::commitment_config::CommitmentConfig;
+use std::fs::File;
 use std::io::Write;
-use std::path::Path;
 use tempfile::tempdir;
 
 #[test]
@@ -47,7 +46,7 @@ fn test_create_deploy_config() {
         owner_path: "path/to/owner.json".to_string(),
         fee_payer_path: "path/to/fee_payer.json".to_string(),
         publish_idl: true,
-        network_type: NetworkType::Devnet,
+        network_filter: "devnet".to_string(),
     };
 
     // Verify config fields
@@ -56,8 +55,87 @@ fn test_create_deploy_config() {
     assert_eq!(config.owner_path, "path/to/owner.json");
     assert_eq!(config.fee_payer_path, "path/to/fee_payer.json");
     assert!(config.publish_idl);
+    assert_eq!(config.network_filter, "devnet");
 
     // Clone the config and verify the clone
     let config_clone = config.clone();
     assert_eq!(config_clone.binary_path, config.binary_path);
+}
+
+#[tokio::test]
+async fn test_network_filter_logic() {
+    // This test only validates the network filtering logic without actually making network calls
+    let dir = tempdir().unwrap();
+    
+    // Create test files
+    let program_file = dir.path().join("program.so");
+    let mut file = File::create(&program_file).unwrap();
+    file.write_all(b"dummy program").unwrap();
+    
+    let program_id_file = dir.path().join("program_id.json");
+    let mut file = File::create(&program_id_file).unwrap();
+    file.write_all(br#"{"programId": "HN4tEEGheziD9dqcWg4xZd29htcerjXKGoGiQXM5hxiS"}"#).unwrap();
+    
+    let owner_file = dir.path().join("owner.json");
+    let mut file = File::create(&owner_file).unwrap();
+    // Valid Ed25519 keypair (64 bytes)
+    let keypair = [
+        74, 97, 123, 217, 156, 17, 153, 238, 153, 193, 31, 227, 15, 68, 138, 151,
+        87, 14, 66, 179, 187, 149, 171, 224, 24, 176, 206, 49, 225, 173, 85, 69,
+        35, 85, 76, 4, 41, 56, 193, 80, 141, 162, 202, 35, 90, 29, 138, 14,
+        176, 85, 191, 245, 106, 196, 149, 53, 180, 252, 241, 119, 54, 11, 141, 223
+    ];
+    file.write_all(format!("{:?}", keypair.to_vec()).as_bytes()).unwrap();
+    
+    let fee_payer_file = dir.path().join("fee_payer.json");
+    let mut file = File::create(&fee_payer_file).unwrap();
+    file.write_all(format!("{:?}", keypair.to_vec()).as_bytes()).unwrap();
+    
+    // Test "all" network filter
+    let config_all = DeployConfig {
+        binary_path: program_file.to_string_lossy().to_string(),
+        program_id_path: program_id_file.to_string_lossy().to_string(),
+        owner_path: owner_file.to_string_lossy().to_string(),
+        fee_payer_path: fee_payer_file.to_string_lossy().to_string(),
+        publish_idl: false,
+        network_filter: "all".to_string(),
+    };
+    
+    // This would attempt network calls in a real scenario, but we're just testing the logic
+    // The function should handle "all" and try to deploy to 3 networks (mainnet, testnet, devnet)
+    let results = deploy_to_all_networks(config_all, CommitmentConfig::confirmed()).await;
+    
+    // Should return 3 results (one for each network)
+    assert_eq!(results.len(), 3);
+    
+    // Test single network filter
+    let config_single = DeployConfig {
+        binary_path: program_file.to_string_lossy().to_string(),
+        program_id_path: program_id_file.to_string_lossy().to_string(),
+        owner_path: owner_file.to_string_lossy().to_string(),
+        fee_payer_path: fee_payer_file.to_string_lossy().to_string(),
+        publish_idl: false,
+        network_filter: "devnet".to_string(),
+    };
+    
+    let results = deploy_to_all_networks(config_single, CommitmentConfig::confirmed()).await;
+    
+    // Should return 1 result (devnet only)
+    assert_eq!(results.len(), 1);
+    
+    // Test invalid network filter
+    let config_invalid = DeployConfig {
+        binary_path: program_file.to_string_lossy().to_string(),
+        program_id_path: program_id_file.to_string_lossy().to_string(),
+        owner_path: owner_file.to_string_lossy().to_string(),
+        fee_payer_path: fee_payer_file.to_string_lossy().to_string(),
+        publish_idl: false,
+        network_filter: "invalid".to_string(),
+    };
+    
+    let results = deploy_to_all_networks(config_invalid, CommitmentConfig::confirmed()).await;
+    
+    // Should return 1 error result
+    assert_eq!(results.len(), 1);
+    assert!(results[0].is_err());
 }