fix: Replace hardcoded solana_ prefix with BlockChainType lookup

This commit addresses issue #409 by replacing the fragile string-based
detection of Solana networks with proper blockchain type lookup.

Changes:
- Added validate_with_networks() method to Monitor ConfigLoader impl
- Updated validate_monitor_references() to use proper type detection
- Maintained backward compatibility with fallback to heuristic approach
- Added comprehensive test coverage for network type detection

Benefits:
- Works with custom Solana network names (not just solana_*)
- Prevents false positives from misleading network names
- Type-safe validation using BlockChainType enum
- No breaking changes to existing code

This builds on the Solana support added in #408 by making the network
type detection more robust and flexible.

Fixes #409

Co-Authored-By: Claude Sonnet 4.5 <[email protected]>

Author: ritik4ever

src/models/config/monitor_config.rs

@@ -4,7 +4,7 @@
 //! allowing monitors to be loaded from JSON files.
 
 use crate::{
-	models::{config::error::ConfigError, ConfigLoader, Monitor, SecretValue},
+	models::{config::error::ConfigError, BlockChainType, ConfigLoader, Monitor, Network, SecretValue},
 	services::trigger::validate_script_config,
 	utils::normalize_string,
 };
@@ -154,6 +154,20 @@ impl ConfigLoader for Monitor {
 
 	/// Validate the monitor configuration
 	fn validate(&self) -> Result<(), ConfigError> {
+		self.validate_with_networks(None)
+	}
+
+	/// Validate the monitor configuration with network context
+	///
+	/// # Arguments
+	/// * `networks` - Optional HashMap of network configurations to validate blockchain type
+	///
+	/// This is a public method exposed through an inherent impl on Monitor to allow
+	/// proper blockchain type detection in repository-level validation
+	pub fn validate_with_networks(
+		&self,
+		networks: Option<&HashMap<String, Network>>,
+	) -> Result<(), ConfigError> {
 		// Validate monitor name
 		if self.name.is_empty() {
 			return Err(ConfigError::validation_error(
@@ -172,9 +186,20 @@ impl ConfigLoader for Monitor {
 			));
 		}
 
-		// Check if this is a Solana monitor based on network slugs
-		// Note: Assumes Solana network slugs follow the "solana_*" naming convention
-		let is_solana_monitor = self.networks.iter().any(|slug| slug.starts_with("solana_"));
+		// Determine if this is a Solana monitor by checking actual network types
+		let is_solana_monitor = if let Some(network_configs) = networks {
+			// Look up actual blockchain type from network configurations
+			self.networks.iter().any(|slug| {
+				network_configs
+					.get(slug)
+					.map(|network| matches!(network.network_type, BlockChainType::Solana))
+					.unwrap_or(false)
+			})
+		} else {
+			// Fallback to heuristic-based approach when network configs aren't available
+			// This maintains backward compatibility for direct validate() calls
+			self.networks.iter().any(|slug| slug.starts_with("solana_"))
+		};
 
 		// Validate function signatures
 		for func in &self.match_conditions.functions {

src/repositories/monitor.rs

@@ -100,6 +100,19 @@ impl<
 				}
 			}
 
+		// Validate monitor configuration with network context
+		// This allows proper blockchain type detection instead of relying on naming conventions
+		if let Err(e) = monitor.validate_with_networks(Some(networks)) {
+			validation_errors.push(format!(
+				"Monitor '{}' configuration validation failed: {}",
+				monitor_name, e
+			));
+			metadata.insert(
+				format!("monitor_{}_validation_error", monitor_name),
+				e.to_string(),
+			);
+		}
+
 			// Validate custom trigger conditions
 			for condition in &monitor.trigger_conditions {
 				let script_path = Path::new(&condition.script_path);
@@ -626,4 +639,86 @@ mod tests {
 			_ => panic!("Expected RepositoryError::LoadError"),
 		}
 	}
+
+	#[test]
+	fn test_validate_solana_network_type_detection() {
+		use crate::models::BlockChainType;
+
+		// Test Case 1: Custom-named Solana network (not following solana_* convention)
+		let mut networks = HashMap::new();
+		let solana_network = NetworkBuilder::new()
+			.name("my-custom-solana")
+			.network_type(BlockChainType::Solana)
+			.build();
+		networks.insert("my-custom-solana".to_string(), solana_network);
+
+		let mut monitors = HashMap::new();
+		let monitor = MonitorBuilder::new()
+			.name("test_solana_monitor")
+			.networks(vec!["my-custom-solana".to_string()])
+			// Solana monitors allow function signatures without parentheses
+			.function_signatures(vec!["transfer".to_string()])
+			.build();
+		monitors.insert("test_solana_monitor".to_string(), monitor);
+
+		let triggers = HashMap::new();
+
+		// Should pass because we properly detect Solana network type
+		let result =
+			MonitorRepository::<NetworkRepository, TriggerRepository>::validate_monitor_references(
+				&monitors, &triggers, &networks,
+			);
+		assert!(result.is_ok());
+
+		// Test Case 2: Misleading network name (contains "solana_" but is EVM)
+		let mut networks2 = HashMap::new();
+		let evm_network = NetworkBuilder::new()
+			.name("solana_like_evm")
+			.network_type(BlockChainType::EVM)
+			.build();
+		networks2.insert("solana_like_evm".to_string(), evm_network);
+
+		let mut monitors2 = HashMap::new();
+		let monitor2 = MonitorBuilder::new()
+			.name("test_evm_monitor")
+			.networks(vec!["solana_like_evm".to_string()])
+			// EVM monitors require parentheses in signatures
+			.function_signatures(vec!["transfer".to_string()])
+			.build();
+		monitors2.insert("test_evm_monitor".to_string(), monitor2);
+
+		// Should fail because it's actually an EVM network requiring proper signature format
+		let result2 =
+			MonitorRepository::<NetworkRepository, TriggerRepository>::validate_monitor_references(
+				&monitors2, &triggers, &networks2,
+			);
+		assert!(result2.is_err());
+		assert!(result2
+			.unwrap_err()
+			.to_string()
+			.contains("Invalid function signature format"));
+
+		// Test Case 3: Actual Solana network with conventional name
+		let mut networks3 = HashMap::new();
+		let solana_network3 = NetworkBuilder::new()
+			.name("solana_mainnet")
+			.network_type(BlockChainType::Solana)
+			.build();
+		networks3.insert("solana_mainnet".to_string(), solana_network3);
+
+		let mut monitors3 = HashMap::new();
+		let monitor3 = MonitorBuilder::new()
+			.name("test_conventional_solana")
+			.networks(vec!["solana_mainnet".to_string()])
+			.function_signatures(vec!["transfer".to_string()])
+			.build();
+		monitors3.insert("test_conventional_solana".to_string(), monitor3);
+
+		// Should pass with conventional name too
+		let result3 =
+			MonitorRepository::<NetworkRepository, TriggerRepository>::validate_monitor_references(
+				&monitors3, &triggers, &networks3,
+			);
+		assert!(result3.is_ok());
+	}
 }