Merge pull request #45 from kanari-network/kari-server

Kari server

Author: jamesatomc

Cargo.toml

@@ -78,7 +78,7 @@ categories = ["development-tools"]
 keywords = ["blockchain", "sdk", "move", "monaOS", "monaVM", "rust", "ifps", "storage", "wallet", "framework"]     # Keywords for crates.io search.
 homepage = "https://kanari.network"                                                                                # Project homepage.
 documentation = "https://docs.kanari.network"                                                                      # Link to project documentation.
-version = "0.1.2"                                                                                                  # Current version of the SDK.
+version = "0.1.3"                                                                                                  # Current version of the SDK.
 authors = ["Kanari Network"]                                                                                       # Authors of the SDK.
 license = "Apache-2.0"                                                                                             # License information.
 repository = "https://github.com/kanari-network/kanari-sdk"                                                        # Link to the code repository.
@@ -117,7 +117,7 @@ jsonrpc-core = "18.0"
 jsonrpc-http-server = "18.0"
 tokio = { version = "1", features = ["full"] }
 url = "2.5.4"
-reqwest = { version = "0.12.15"}
+reqwest = { version = "0.12.18"}
 base64 = "0.22.1"
 # Error Handling & Diagnostics
 anyhow = "1.0.98"

crates/command/src/network_cli/mod.rs crates/command/src/env_cli/mod.rscrates/command/src/network_cli/mod.rs renamed to crates/command/src/env_cli/mod.rs

@@ -3,47 +3,47 @@ use std::io::{self};
 use serde_yaml::{Value, Mapping};
 use common::{load_kanari_config, save_kanari_config};
 
-pub fn handle_network_command() -> io::Result<()> {
+pub fn handle_env_command() -> io::Result<()> {
     let args: Vec<String> = std::env::args().collect();
 
     if args.len() < 3 {
-        display_network_help();
+        display_env_help();
         return Ok(());
     }
 
     match args[2].as_str() {
-        "list" => list_networks()?,
-        "switch" if args.len() >= 4 => switch_network(&args[3])?,
-        "add" if args.len() >= 4 => add_network(&args[3], args.get(4).map(|s| s.as_str()).unwrap_or("http://127.0.0.1:30030"))?,
-        "remove" if args.len() >= 4 => remove_network(&args[3])?,
-        _ => display_network_help(),
+        "list" => list_envs()?,
+        "switch" if args.len() >= 4 => switch_env(&args[3])?,
+        "add" if args.len() >= 4 => add_env(&args[3], args.get(4).map(|s| s.as_str()).unwrap_or("http://127.0.0.1:30030"))?,
+        "remove" if args.len() >= 4 => remove_env(&args[3])?,
+        _ => display_env_help(),
     }
 
     Ok(())
 }
 
-fn display_network_help() {
-    println!("\n{}", "KARI NETWORK MANAGEMENT".bright_yellow().bold());
+fn display_env_help() {
+    println!("\n{}", "KARI ENVIRONMENT MANAGEMENT".bright_yellow().bold());
     println!("{}", "Available commands:".bright_white());
-    println!("  {:<20} {}", "list".green(), "List all available networks");
-    println!("  {:<20} {}", "switch <name>".green(), "Switch to the specified network");
-    println!("  {:<20} {}", "add <name> [url]".green(), "Add a new network with optional URL");
-    println!("  {:<20} {}", "remove <name>".green(), "Remove a network configuration");
+    println!("  {:<20} {}", "list".green(), "List all available environments");
+    println!("  {:<20} {}", "switch <name>".green(), "Switch to the specified environment");
+    println!("  {:<20} {}", "add <name> [url]".green(), "Add a new environment with optional URL");
+    println!("  {:<20} {}", "remove <name>".green(), "Remove an environment configuration");
     println!("\n{}", "Examples:".bright_yellow());
-    println!("  kari network list");
-    println!("  kari network switch dev");
-    println!("  kari network add local_test http://127.0.0.1:30035");
-    println!("  kari network remove local_test");
+    println!("  kari env list");
+    println!("  kari env switch dev");
+    println!("  kari env add local_test http://127.0.0.1:30035");
+    println!("  kari env remove local_test");
 }
 
-fn list_networks() -> io::Result<()> {
+fn list_envs() -> io::Result<()> {
     let kanari_config = load_kanari_config()?;
 
     let active_env = kanari_config.get("active_env")
                      .and_then(|v| v.as_str())
                      .unwrap_or("local");
 
-    println!("\n{}", "AVAILABLE NETWORKS".bright_yellow().bold());
+    println!("\n{}", "AVAILABLE ENVIRONMENTS".bright_yellow().bold());
     println!("{:<15} {:<40} {}", "NAME".bright_white(), "RPC URL".bright_white(), "STATUS".bright_white());
 
     if let Some(envs) = kanari_config.get("envs").and_then(|v| v.as_sequence()) {
@@ -65,24 +65,24 @@ fn list_networks() -> io::Result<()> {
     Ok(())
 }
 
-fn switch_network(name: &str) -> io::Result<()> {
+fn switch_env(name: &str) -> io::Result<()> {
     let mut kanari_config = load_kanari_config()?;
 
-    // Verify the network exists
-    let mut network_exists = false;
+    // Verify the environment exists
+    let mut env_exists = false;
     if let Some(envs) = kanari_config.get("envs").and_then(|v| v.as_sequence()) {
         for env in envs {
             if let Some(alias) = env.get("alias").and_then(|v| v.as_str()) {
                 if alias == name {
-                    network_exists = true;
+                    env_exists = true;
                     break;
                 }
             }
         }
     }
-    
-    if !network_exists {
-        println!("{}", format!("Network '{}' not found.", name).red());
+
+    if !env_exists {
+        println!("{}", format!("Environment '{}' not found.", name).red());
         return Ok(());
     }
 
@@ -106,28 +106,28 @@ fn switch_network(name: &str) -> io::Result<()> {
     Ok(())
 }
 
-fn add_network(name: &str, rpc_url: &str) -> io::Result<()> {
+fn add_env(name: &str, rpc_url: &str) -> io::Result<()> {
     let mut kanari_config = load_kanari_config()?;
 
-    // Check if network already exists
-    let mut network_exists = false;
+    // Check if environment already exists
+    let mut env_exists = false;
     if let Some(envs) = kanari_config.get("envs").and_then(|v| v.as_sequence()) {
         for env in envs {
             if let Some(alias) = env.get("alias").and_then(|v| v.as_str()) {
                 if alias == name {
-                    network_exists = true;
+                    env_exists = true;
                     break;
                 }
             }
         }
     }
-    
-    if network_exists {
-        println!("{}", format!("Network '{}' already exists. Use a different name.", name).red());
+
+    if env_exists {
+        println!("{}", format!("Environment '{}' already exists. Use a different name.", name).red());
         return Ok(());
     }
-    
-    // Create new network entry
+
+    // Create new environment entry
     let mut new_env = Mapping::new();
     new_env.insert(Value::String("alias".to_string()), Value::String(name.to_string()));
     new_env.insert(Value::String("rpc".to_string()), Value::String(rpc_url.to_string()));
@@ -163,10 +163,10 @@ fn add_network(name: &str, rpc_url: &str) -> io::Result<()> {
     Ok(())
 }
 
-fn remove_network(name: &str) -> io::Result<()> {
-    // Don't allow removing primary networks
+fn remove_env(name: &str) -> io::Result<()> {
+    // Don't allow removing primary environments
     if name == "local" || name == "dev" || name == "test" || name == "main" {
-        println!("{}", format!("Cannot remove built-in network '{}'.", name).red());
+        println!("{}", format!("Cannot remove built-in environment '{}'.", name).red());
         return Ok(());
     }
 
@@ -175,24 +175,24 @@ fn remove_network(name: &str) -> io::Result<()> {
     let active_env = kanari_config.get("active_env")
                      .and_then(|v| v.as_str())
                      .unwrap_or("local");
-                     
-    // Check if trying to remove active network
+
+    // Check if trying to remove active environment
     if active_env == name {
-        println!("{}", "Cannot remove currently active network.".red());
-        println!("Switch to another network first with: kari network switch <name>");
+        println!("{}", "Cannot remove currently active environment.".red());
+        println!("Switch to another environment first with: kari env switch <name>");
         return Ok(());
     }
-    
-    // Remove the network
-    let mut network_found = false;
+
+    // Remove the environment
+    let mut env_found = false;
     if let Some(mapping) = kanari_config.as_mapping_mut() {
         if let Some(envs) = mapping.get_mut("envs").and_then(|v| v.as_sequence_mut()) {
             let mut index_to_remove = None;
             for (i, env) in envs.iter().enumerate() {
                 if let Some(alias) = env.get("alias").and_then(|v| v.as_str()) {
                     if alias == name {
                         index_to_remove = Some(i);
-                        network_found = true;
+                        env_found = true;
                         break;
                     }
                 }
@@ -203,16 +203,16 @@ fn remove_network(name: &str) -> io::Result<()> {
             }
         }
     }
-    
-    if !network_found {
-        println!("{}", format!("Network '{}' not found.", name).red());
+
+    if !env_found {
+        println!("{}", format!("Environment '{}' not found.", name).red());
         return Ok(());
     }
 
     // Save updated config
     save_kanari_config(&kanari_config)?;
-    
-    println!("{}", format!("Removed network: {}", name).green());
-    
+
+    println!("{}", format!("Removed environment: {}", name).green());
+
     Ok(())
 }

crates/command/src/keytool_cli/mod.rs

@@ -15,6 +15,7 @@ use std::process::Command;
 // Add the required import for CurveType and key-related functions
 use key::keys::{import_from_private_key, import_from_seed_phrase, generate_karix_address};
 use key::keys::CurveType;
+use common::{load_config, load_kanari_config};
 
 struct CommandInfo {
     name: &'static str,
@@ -235,6 +236,9 @@ pub fn handle_keytool_command() -> Option<String> {
                 // Load blockchain first
                 match load_blockchain_with_retry() {
                     Ok(_) => {
+                        // Get RPC endpoint from configuration
+                        let rpc_endpoint = get_rpc_endpoint();
+                        
                         // Get sender address (current wallet)
                         let wallets = match list_wallet_files() {
                             Ok(w) => w,
@@ -378,9 +382,6 @@ pub fn handle_keytool_command() -> Option<String> {
 
                         println!("Sending transaction...");
 
-                        // Use a simple command-line tool for making HTTP requests
-                        // Instead of using reqwest blocking client
-                        
                         // Create the JSON payload
                         let json_payload = json!({
                             "jsonrpc": "2.0",
@@ -404,12 +405,12 @@ pub fn handle_keytool_command() -> Option<String> {
                                 "curl"
                             };
 
-                            // Execute curl command to send the request
+                            // Execute curl command to send the request with dynamic endpoint
                             let output = Command::new(curl_cmd)
                                 .arg("-s")
                                 .arg("-X")
                                 .arg("POST")
-                                .arg("http://127.0.0.1:30031")
+                                .arg(&rpc_endpoint)  // Use dynamic endpoint instead of hardcoded
                                 .arg("-H")
                                 .arg("Content-Type: application/json")
                                 .arg("-d")
@@ -448,14 +449,14 @@ pub fn handle_keytool_command() -> Option<String> {
                                             }
                                         }
                                     } else {
-                                        println!("{}", "HTTP request failed".red());
+                                        println!("{}", format!("HTTP request failed to {}", rpc_endpoint).red());
                                         println!("Error: {}", String::from_utf8_lossy(&output.stderr));
                                         return None;
                                     }
                                 },
                                 Err(e) => {
-                                    println!("{}", format!("Failed to execute HTTP request: {}", e).red());
-                                    println!("Make sure curl is installed on your system");
+                                    println!("{}", format!("Failed to execute HTTP request to {}: {}", rpc_endpoint, e).red());
+                                    println!("Make sure curl is installed and the node is running at {}", rpc_endpoint);
                                     return None;
                                 }
                             }
@@ -1165,4 +1166,40 @@ fn prompt_password(confirm: bool) -> String {
         }
     }
     password
+}
+
+// Add helper function to get RPC endpoint from configuration
+fn get_rpc_endpoint() -> String {
+    // Try to get RPC endpoint from kanari config first
+    if let Ok(kanari_config) = load_kanari_config() {
+        if let Some(active_env) = kanari_config.get("active_env").and_then(|v| v.as_str()) {
+            if let Some(envs) = kanari_config.get("envs").and_then(|v| v.as_sequence()) {
+                for env in envs {
+                    if let Some(alias) = env.get("alias").and_then(|v| v.as_str()) {
+                        if alias == active_env {
+                            if let Some(rpc_url) = env.get("rpc").and_then(|v| v.as_str()) {
+                                println!("Using RPC endpoint from kanari config: {}", rpc_url.green());
+                                return rpc_url.to_string();
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    
+    // Fallback to load_config (legacy support)
+    if let Ok(config) = load_config() {
+        if let Some(port) = config.get("rpc_port").and_then(|v| v.as_u64()) {
+            let endpoint = format!("http://127.0.0.1:{}", port);
+            println!("Using RPC endpoint from config: {}", endpoint.green());
+            return endpoint;
+        }
+    }
+    
+    // Final fallback to default
+    let default_endpoint = "http://127.0.0.1:30030".to_string();
+    println!("{}", format!("Warning: Could not determine RPC endpoint from config, using default: {}", default_endpoint).yellow());
+    println!("Make sure your node is running on the default port or check your configuration.");
+    default_endpoint
 }

crates/command/src/lib.rs

@@ -4,6 +4,6 @@ pub mod move_cli;
 
 pub mod public_cli;
 
-pub mod network_cli;
+pub mod env_cli;
 
 pub mod server_cli;

crates/command/src/server_cli/init_server.rs

@@ -1,23 +1,7 @@
-use common::{get_kanari_config_path, save_kanari_config, get_kari_dir};
-use serde_yaml::{Value, Mapping};
+use common::{init_default_config, get_kanari_config_path};
 use std::io;
 use colored::Colorize;
 
-fn default_keystore_path() -> String {
-    let mut path = get_kari_dir();
-    path.push("kanari_config");
-    path.push("kanari.keystore");
-    path.to_string_lossy().into_owned()
-}
-
-fn create_env_config(alias: &str, rpc: &str, ws: &str) -> Value {
-    let mut env_map = Mapping::new();
-    env_map.insert(Value::String("alias".to_string()), Value::String(alias.to_string()));
-    env_map.insert(Value::String("rpc".to_string()), Value::String(rpc.to_string()));
-    env_map.insert(Value::String("ws".to_string()), Value::String(ws.to_string()));
-    Value::Mapping(env_map)
-}
-
 pub fn init_server_config() -> io::Result<()> {
     let config_path = get_kanari_config_path();
 
@@ -26,28 +10,8 @@ pub fn init_server_config() -> io::Result<()> {
         return Ok(());
     }
 
-    let mut config = Mapping::new();
-    config.insert(
-        Value::String("keystore_path".to_string()),
-        Value::String(default_keystore_path()),
-    );
-    config.insert(
-        Value::String("active_address".to_string()),
-        Value::Null,
-    );
-
-    let envs = vec![
-        create_env_config("local", "http://127.0.0.1:30030", "ws://127.0.0.1:30031"),
-        create_env_config("dev", "https://dev-seed.kanari.site", "wss://dev-seed.kanari.site/websocket"),
-        create_env_config("test", "https://test-seed.kanari.site", "wss://test-seed.kanari.site/websocket"),
-        create_env_config("main", "https://main-seed.kanari.site", "wss://main-seed.kanari.site/websocket"),
-    ];
-
-    config.insert(Value::String("envs".to_string()), Value::Sequence(envs));
-    config.insert(Value::String("active_env".to_string()), Value::String("local".to_string()));
-
-    let yaml_value = Value::Mapping(config);
-    save_kanari_config(&yaml_value)?;
+    // Use the centralized initialization function
+    init_default_config()?;
 
     println!("{} {}", "Default kanari.yaml created at:".green(), config_path.display().to_string().bright_white());
     Ok(())