Add SVM network management infrastructure and multi-network support

Co-authored-by: larp0 <[email protected]>

Author: Copilot

Cargo.toml

@@ -20,3 +20,4 @@ spl-token = "4.0"
 base64 = "0.21"
 bs58 = "0.5"
 bincode = "1.3"
+reqwest = { version = "0.11", features = ["json"] }

src/config.rs

@@ -1,13 +1,22 @@
 use anyhow::{Result, Context};
-use serde::Deserialize;
-use std::{env, fs};
+use serde::{Deserialize, Serialize};
+use std::{env, fs, collections::HashMap};
 use crate::protocol::LATEST_PROTOCOL_VERSION;
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct SvmNetwork {
+    pub name: String,
+    pub rpc_url: String,
+    pub enabled: bool,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct Config {
     pub rpc_url: String,
     pub commitment: String,
     pub protocol_version: String,
+    #[serde(default)]
+    pub svm_networks: HashMap<String, SvmNetwork>,
 }
 
 impl Config {
@@ -33,6 +42,15 @@ impl Config {
             rpc_url,
             commitment,
             protocol_version,
+            svm_networks: HashMap::new(),
         })
     }
+
+    pub fn save(&self) -> Result<()> {
+        let content = serde_json::to_string_pretty(self)
+            .context("Failed to serialize config")?;
+        fs::write("config.json", content)
+            .context("Failed to write config.json")?;
+        Ok(())
+    }
 }

src/lib.rs

@@ -5,6 +5,6 @@ pub mod server;
 pub mod tools;
 pub mod transport;
 
-pub use config::Config;
+pub use config::{Config, SvmNetwork};
 pub use server::start_server;
 pub use transport::CustomStdioTransport;

src/server/mod.rs

@@ -2,18 +2,21 @@ use anyhow::Result;
 use solana_client::nonblocking::rpc_client::RpcClient;
 use solana_sdk::commitment_config::CommitmentConfig;
 use std::sync::Arc;
+use std::collections::HashMap;
 use tokio::sync::RwLock;
 use crate::transport::{Transport, JsonRpcMessage, JsonRpcNotification, JsonRpcVersion};
 use crate::{Config, CustomStdioTransport};
 
 pub struct ServerState {
     pub rpc_client: RpcClient,
+    pub svm_clients: HashMap<String, RpcClient>,
+    pub config: Config,
     pub initialized: bool,
     pub protocol_version: String,
 }
 
 impl ServerState {
-    pub fn new(config: &Config) -> Self {
+    pub fn new(config: Config) -> Self {
         let commitment = match config.commitment.as_str() {
             "processed" => CommitmentConfig::processed(),
             "confirmed" => CommitmentConfig::confirmed(),
@@ -23,15 +26,68 @@ impl ServerState {
 
         let rpc_client = RpcClient::new_with_commitment(
             config.rpc_url.clone(),
-            commitment,
+            commitment.clone(),
         );
 
+        // Create RPC clients for enabled SVM networks
+        let mut svm_clients = HashMap::new();
+        for (network_id, network) in &config.svm_networks {
+            if network.enabled {
+                let client = RpcClient::new_with_commitment(
+                    network.rpc_url.clone(),
+                    commitment.clone(),
+                );
+                svm_clients.insert(network_id.clone(), client);
+            }
+        }
+
         Self { 
             rpc_client,
+            svm_clients,
+            protocol_version: config.protocol_version.clone(),
+            config,
             initialized: false,
-            protocol_version: config.protocol_version.clone()
         }
     }
+
+    pub fn update_config(&mut self, new_config: Config) {
+        let commitment = match new_config.commitment.as_str() {
+            "processed" => CommitmentConfig::processed(),
+            "confirmed" => CommitmentConfig::confirmed(),
+            "finalized" => CommitmentConfig::finalized(),
+            _ => CommitmentConfig::default(),
+        };
+
+        // Update main RPC client if URL changed
+        if self.config.rpc_url != new_config.rpc_url {
+            self.rpc_client = RpcClient::new_with_commitment(
+                new_config.rpc_url.clone(),
+                commitment.clone(),
+            );
+        }
+
+        // Update SVM clients
+        self.svm_clients.clear();
+        for (network_id, network) in &new_config.svm_networks {
+            if network.enabled {
+                let client = RpcClient::new_with_commitment(
+                    network.rpc_url.clone(),
+                    commitment.clone(),
+                );
+                self.svm_clients.insert(network_id.clone(), client);
+            }
+        }
+
+        self.config = new_config;
+    }
+
+    pub fn get_enabled_networks(&self) -> Vec<&str> {
+        self.config.svm_networks
+            .iter()
+            .filter(|(_, network)| network.enabled)
+            .map(|(id, _)| id.as_str())
+            .collect()
+    }
 }
 
 pub async fn start_server() -> Result<()> {
@@ -40,7 +96,7 @@ pub async fn start_server() -> Result<()> {
     let config = Config::load()?;
     log::info!("Loaded config: RPC URL: {}, Protocol Version: {}", config.rpc_url, config.protocol_version);
 
-    let state = Arc::new(RwLock::new(ServerState::new(&config)));
+    let state = Arc::new(RwLock::new(ServerState::new(config.clone())));
 
     let transport = CustomStdioTransport::new();
     transport.open()?;