working example for mycelium

Cargo.toml

@@ -47,6 +47,9 @@ tokio-postgres = "0.7.8" # Async PostgreSQL client
 tokio-test = "0.4.4"
 uuid = { version = "1.16.0", features = ["v4"] }
 zinit-client = { git = "https://github.com/threefoldtech/zinit", branch = "json_rpc",  package = "zinit-client" }
+reqwest = { version = "0.12.15", features = ["json"] }
+urlencoding = "2.1.3"
+
 # Optional features for specific OS functionality
 [target.'cfg(unix)'.dependencies]
 nix = "0.30.1" # Unix-specific functionality

examples/mycelium/mycelium_basic.rhai

@@ -0,0 +1,133 @@
+// Basic example of using the Mycelium client in Rhai
+
+// API URL for Mycelium
+let api_url = "http://localhost:8989";
+
+// Get node information
+print("Getting node information:");
+try {
+    let node_info = mycelium_get_node_info(api_url);
+    print(`Node subnet: ${node_info.nodeSubnet}`);
+    print(`Node public key: ${node_info.nodePubkey}`);
+} catch(err) {
+    print(`Error getting node info: ${err}`);
+}
+
+// List all peers
+print("\nListing all peers:");
+try {
+    let peers = mycelium_list_peers(api_url);
+    
+    if peers.is_empty() {
+        print("No peers connected.");
+    } else {
+        for peer in peers {
+            print(`Peer Endpoint: ${peer.endpoint.proto}://${peer.endpoint.socketAddr}`);
+            print(`  Type: ${peer.type}`);
+            print(`  Connection State: ${peer.connectionState}`);
+            print(`  Bytes sent: ${peer.txBytes}`);
+            print(`  Bytes received: ${peer.rxBytes}`);
+        }
+    }
+} catch(err) {
+    print(`Error listing peers: ${err}`);
+}
+
+// Add a new peer
+print("\nAdding a new peer:");
+let new_peer_address = "tcp://65.21.231.58:9651";
+try {
+    let result = mycelium_add_peer(api_url, new_peer_address);
+    print(`Peer added: ${result.success}`);
+} catch(err) {
+    print(`Error adding peer: ${err}`);
+}
+
+// List selected routes
+print("\nListing selected routes:");
+try {
+    let routes = mycelium_list_selected_routes(api_url);
+    
+    if routes.is_empty() {
+        print("No selected routes.");
+    } else {
+        for route in routes {
+            print(`Subnet: ${route.subnet}`);
+            print(`  Next hop: ${route.nextHop}`);
+            print(`  Metric: ${route.metric}`);
+        }
+    }
+} catch(err) {
+    print(`Error listing routes: ${err}`);
+}
+
+// List fallback routes
+print("\nListing fallback routes:");
+try {
+    let routes = mycelium_list_fallback_routes(api_url);
+    
+    if routes.is_empty() {
+        print("No fallback routes.");
+    } else {
+        for route in routes {
+            print(`Subnet: ${route.subnet}`);
+            print(`  Next hop: ${route.nextHop}`);
+            print(`  Metric: ${route.metric}`);
+        }
+    }
+} catch(err) {
+    print(`Error listing fallback routes: ${err}`);
+}
+
+// Send a message
+// TO SEND A MESSAGE FILL IN THE DESTINATION IP ADDRESS
+// -----------------------------------------------------//
+// print("\nSending a message:");
+// let destination = < FILL IN CORRECT DEST IP >
+// let topic = "test";
+// let message = "Hello from Rhai!";
+// let deadline_secs = 60;
+
+// try {
+//     let result = mycelium_send_message(api_url, destination, topic, message, deadline_secs);
+//     print(`Message sent: ${result.success}`);
+//     if result.id {
+//         print(`Message ID: ${result.id}`);
+//     }
+// } catch(err) {
+//     print(`Error sending message: ${err}`);
+// }
+
+// Receive messages
+// RECEIVING MESSAGES SHOULD BE DONE ON THE DESTINATION NODE FROM THE CALL ABOVE
+// -----------------------------------------------------------------------------//
+// print("\nReceiving messages:");
+// let receive_topic = "test";
+// let count = 5;
+
+// try {
+//     let messages = mycelium_receive_messages(api_url, receive_topic, count);
+    
+//     if messages.is_empty() {
+//         print("No messages received.");
+//     } else {
+//         for msg in messages {
+//             print(`Message from: ${msg.source}`);
+//             print(`  Topic: ${msg.topic}`);
+//             print(`  Content: ${msg.content}`);
+//             print(`  Timestamp: ${msg.timestamp}`);
+//         }
+//     }
+// } catch(err) {
+//     print(`Error receiving messages: ${err}`);
+// }
+
+// Remove a peer
+print("\nRemoving a peer:");
+let peer_id = "tcp://65.21.231.58:9651"; // This is the peer we added earlier
+try {
+    let result = mycelium_remove_peer(api_url, peer_id);
+    print(`Peer removed: ${result.success}`);
+} catch(err) {
+    print(`Error removing peer: ${err}`);
+}

src/lib.rs

@@ -48,6 +48,7 @@ pub mod text;
 pub mod virt;
 pub mod vault;
 pub mod zinit_client;
+pub mod mycelium;
 
 // Version information
 /// Returns the version of the SAL library

src/mycelium/mod.rs

@@ -0,0 +1,300 @@
+use base64::{
+    alphabet,
+    engine::{self, general_purpose},
+    Engine as _,
+};
+use reqwest::Client;
+use serde_json::Value;
+use std::time::Duration;
+
+/// Get information about the Mycelium node
+///
+/// # Arguments
+///
+/// * `api_url` - The URL of the Mycelium API
+///
+/// # Returns
+///
+/// * `Result<Value, String>` - The node information as a JSON value, or an error message
+pub async fn get_node_info(api_url: &str) -> Result<Value, String> {
+    let client = Client::new();
+    let url = format!("{}/api/v1/admin", api_url);
+
+    let response = client
+        .get(&url)
+        .send()
+        .await
+        .map_err(|e| format!("Failed to send request: {}", e))?;
+
+    let status = response.status();
+    if !status.is_success() {
+        return Err(format!("Request failed with status: {}", status));
+    }
+
+    let result: Value = response
+        .json()
+        .await
+        .map_err(|e| format!("Failed to parse response: {}", e))?;
+
+    Ok(result)
+}
+
+/// List all peers connected to the Mycelium node
+///
+/// # Arguments
+///
+/// * `api_url` - The URL of the Mycelium API
+///
+/// # Returns
+///
+/// * `Result<Value, String>` - The list of peers as a JSON value, or an error message
+pub async fn list_peers(api_url: &str) -> Result<Value, String> {
+    let client = Client::new();
+    let url = format!("{}/api/v1/admin/peers", api_url);
+
+    let response = client
+        .get(&url)
+        .send()
+        .await
+        .map_err(|e| format!("Failed to send request: {}", e))?;
+
+    let status = response.status();
+    if !status.is_success() {
+        return Err(format!("Request failed with status: {}", status));
+    }
+
+    let result: Value = response
+        .json()
+        .await
+        .map_err(|e| format!("Failed to parse response: {}", e))?;
+
+    Ok(result)
+}
+
+/// Add a new peer to the Mycelium node
+///
+/// # Arguments
+///
+/// * `api_url` - The URL of the Mycelium API
+/// * `peer_address` - The address of the peer to add
+///
+/// # Returns
+///
+/// * `Result<Value, String>` - The result of the operation as a JSON value, or an error message
+pub async fn add_peer(api_url: &str, peer_address: &str) -> Result<Value, String> {
+    let client = Client::new();
+    let url = format!("{}/api/v1/admin/peers", api_url);
+
+    let response = client
+        .post(&url)
+        .json(&serde_json::json!({
+            "endpoint": peer_address
+        }))
+        .send()
+        .await
+        .map_err(|e| format!("Failed to send request: {}", e))?;
+
+    let status = response.status();
+    if status == reqwest::StatusCode::NO_CONTENT {
+        // Successfully added, but no content to parse
+        return Ok(serde_json::json!({"success": true}));
+    }
+    if !status.is_success() {
+        return Err(format!("Request failed with status: {}", status));
+    }
+
+    // For other success statuses that might have a body
+    let result: Value = response
+        .json()
+        .await
+        .map_err(|e| format!("Failed to parse response: {}", e))?;
+
+    Ok(result)
+}
+
+/// Remove a peer from the Mycelium node
+///
+/// # Arguments
+///
+/// * `api_url` - The URL of the Mycelium API
+/// * `peer_id` - The ID of the peer to remove
+///
+/// # Returns
+///
+/// * `Result<Value, String>` - The result of the operation as a JSON value, or an error message
+pub async fn remove_peer(api_url: &str, peer_id: &str) -> Result<Value, String> {
+    let client = Client::new();
+    let peer_id_url_encoded = urlencoding::encode(peer_id);
+    let url = format!("{}/api/v1/admin/peers/{}", api_url, peer_id_url_encoded);
+
+    let response = client
+        .delete(&url)
+        .send()
+        .await
+        .map_err(|e| format!("Failed to send request: {}", e))?;
+
+    let status = response.status();
+    if status == reqwest::StatusCode::NO_CONTENT {
+        // Successfully removed, but no content to parse
+        return Ok(serde_json::json!({"success": true}));
+    }
+    if !status.is_success() {
+        return Err(format!("Request failed with status: {}", status));
+    }
+
+    let result: Value = response
+        .json()
+        .await
+        .map_err(|e| format!("Failed to parse response: {}", e))?;
+
+    Ok(result)
+}
+
+/// List all selected routes in the Mycelium node
+///
+/// # Arguments
+///
+/// * `api_url` - The URL of the Mycelium API
+///
+/// # Returns
+///
+/// * `Result<Value, String>` - The list of selected routes as a JSON value, or an error message
+pub async fn list_selected_routes(api_url: &str) -> Result<Value, String> {
+    let client = Client::new();
+    let url = format!("{}/api/v1/admin/routes/selected", api_url);
+
+    let response = client
+        .get(&url)
+        .send()
+        .await
+        .map_err(|e| format!("Failed to send request: {}", e))?;
+
+    let status = response.status();
+    if !status.is_success() {
+        return Err(format!("Request failed with status: {}", status));
+    }
+
+    let result: Value = response
+        .json()
+        .await
+        .map_err(|e| format!("Failed to parse response: {}", e))?;
+
+    Ok(result)
+}
+
+/// List all fallback routes in the Mycelium node
+///
+/// # Arguments
+///
+/// * `api_url` - The URL of the Mycelium API
+///
+/// # Returns
+///
+/// * `Result<Value, String>` - The list of fallback routes as a JSON value, or an error message
+pub async fn list_fallback_routes(api_url: &str) -> Result<Value, String> {
+    let client = Client::new();
+    let url = format!("{}/api/v1/admin/routes/fallback", api_url);
+
+    let response = client
+        .get(&url)
+        .send()
+        .await
+        .map_err(|e| format!("Failed to send request: {}", e))?;
+
+    let status = response.status();
+    if !status.is_success() {
+        return Err(format!("Request failed with status: {}", status));
+    }
+
+    let result: Value = response
+        .json()
+        .await
+        .map_err(|e| format!("Failed to parse response: {}", e))?;
+
+    Ok(result)
+}
+
+/// Send a message to a destination via the Mycelium node
+///
+/// # Arguments
+///
+/// * `api_url` - The URL of the Mycelium API
+/// * `destination` - The destination address
+/// * `topic` - The message topic
+/// * `message` - The message content
+/// * `deadline_secs` - The deadline in seconds
+///
+/// # Returns
+///
+/// * `Result<Value, String>` - The result of the operation as a JSON value, or an error message
+pub async fn send_message(
+    api_url: &str,
+    destination: &str,
+    topic: &str,
+    message: &str,
+    deadline_secs: u64,
+) -> Result<Value, String> {
+    let client = Client::new();
+    let url = format!("{}/api/v1/messages", api_url);
+
+    // Convert deadline to seconds
+    let deadline = Duration::from_secs(deadline_secs).as_secs();
+
+    let response = client
+        .post(&url)
+        .json(&serde_json::json!({
+            "dst": { "ip": destination },
+            "topic": general_purpose::STANDARD.encode(topic),
+            "payload": general_purpose::STANDARD.encode(message)
+        }))
+        .send()
+        .await
+        .map_err(|e| format!("Failed to send request: {}", e))?;
+
+    let status = response.status();
+    if !status.is_success() {
+        return Err(format!("Request failed with status: {}", status));
+    }
+
+    let result: Value = response
+        .json()
+        .await
+        .map_err(|e| format!("Failed to parse response: {}", e))?;
+
+    Ok(result)
+}
+
+/// Receive messages from a topic via the Mycelium node
+///
+/// # Arguments
+///
+/// * `api_url` - The URL of the Mycelium API
+/// * `topic` - The message topic
+/// * `count` - The maximum number of messages to receive
+///
+/// # Returns
+///
+/// * `Result<Value, String>` - The received messages as a JSON value, or an error message
+pub async fn receive_messages(api_url: &str, topic: &str, count: u32) -> Result<Value, String> {
+    let client = Client::new();
+    let url = format!("{}/api/v1/messages", api_url);
+
+    let response = client
+        .get(&url)
+        .query(&[("topic", general_purpose::STANDARD.encode(topic))])
+        .send()
+        .await
+        .map_err(|e| format!("Failed to send request: {}", e))?;
+
+    let status = response.status();
+    if !status.is_success() {
+        return Err(format!("Request failed with status: {}", status));
+    }
+
+    let result: Value = response
+        .json()
+        .await
+        .map_err(|e| format!("Failed to parse response: {}", e))?;
+
+    Ok(result)
+}

src/redisclient/redisclient.rs

@@ -206,7 +206,7 @@ impl RedisClientWrapper {
         }
 
         // Select the database
-        let _ = redis::cmd("SELECT").arg(self.db).exec(&mut conn);
+        redis::cmd("SELECT").arg(self.db).execute(&mut conn);
 
         self.initialized.store(true, Ordering::Relaxed);
 

src/rhai/mod.rs

@@ -15,6 +15,7 @@ mod rfs;
 mod vault;
 mod text;
 mod zinit;
+mod mycelium;
 
 #[cfg(test)]
 mod tests;
@@ -95,6 +96,9 @@ pub use git::register_git_module;
 // Re-export zinit module
 pub use zinit::register_zinit_module;
 
+// Re-export mycelium module
+pub use mycelium::register_mycelium_module;
+
 // Re-export text module
 pub use text::register_text_module;
 // Re-export text functions directly from text module
@@ -155,6 +159,9 @@ pub fn register(engine: &mut Engine) -> Result<(), Box<rhai::EvalAltResult>> {
     // Register Zinit module functions
     zinit::register_zinit_module(engine)?;
     
+    // Register Mycelium module functions
+    mycelium::register_mycelium_module(engine)?;
+    
     // Register Text module functions
     text::register_text_module(engine)?;
 

src/rhai/mycelium.rs

@@ -0,0 +1,235 @@
+//! Rhai wrappers for Mycelium client module functions
+//!
+//! This module provides Rhai wrappers for the functions in the Mycelium client module.
+
+use rhai::{Engine, EvalAltResult, Array, Dynamic, Map};
+use crate::mycelium as client;
+use tokio::runtime::Runtime;
+use serde_json::Value;
+use crate::rhai::error::ToRhaiError;
+
+/// Register Mycelium module functions with the Rhai engine
+///
+/// # Arguments
+///
+/// * `engine` - The Rhai engine to register the functions with
+///
+/// # Returns
+///
+/// * `Result<(), Box<EvalAltResult>>` - Ok if registration was successful, Err otherwise
+pub fn register_mycelium_module(engine: &mut Engine) -> Result<(), Box<EvalAltResult>> {
+    // Register Mycelium client functions
+    engine.register_fn("mycelium_get_node_info", mycelium_get_node_info);
+    engine.register_fn("mycelium_list_peers", mycelium_list_peers);
+    engine.register_fn("mycelium_add_peer", mycelium_add_peer);
+    engine.register_fn("mycelium_remove_peer", mycelium_remove_peer);
+    engine.register_fn("mycelium_list_selected_routes", mycelium_list_selected_routes);
+    engine.register_fn("mycelium_list_fallback_routes", mycelium_list_fallback_routes);
+    engine.register_fn("mycelium_send_message", mycelium_send_message);
+    engine.register_fn("mycelium_receive_messages", mycelium_receive_messages);
+    
+    Ok(())
+}
+
+// Helper function to get a runtime
+fn get_runtime() -> Result<Runtime, Box<EvalAltResult>> {
+    tokio::runtime::Runtime::new().map_err(|e| {
+        Box::new(EvalAltResult::ErrorRuntime(
+            format!("Failed to create Tokio runtime: {}", e).into(),
+            rhai::Position::NONE
+        ))
+    })
+}
+
+// Helper function to convert serde_json::Value to rhai::Dynamic
+fn value_to_dynamic(value: Value) -> Dynamic {
+    match value {
+        Value::Null => Dynamic::UNIT,
+        Value::Bool(b) => Dynamic::from(b),
+        Value::Number(n) => {
+            if let Some(i) = n.as_i64() {
+                Dynamic::from(i)
+            } else if let Some(f) = n.as_f64() {
+                Dynamic::from(f)
+            } else {
+                Dynamic::from(n.to_string())
+            }
+        },
+        Value::String(s) => Dynamic::from(s),
+        Value::Array(arr) => {
+            let mut rhai_arr = Array::new();
+            for item in arr {
+                rhai_arr.push(value_to_dynamic(item));
+            }
+            Dynamic::from(rhai_arr)
+        },
+        Value::Object(map) => {
+            let mut rhai_map = Map::new();
+            for (k, v) in map {
+                rhai_map.insert(k.into(), value_to_dynamic(v));
+            }
+            Dynamic::from_map(rhai_map)
+        }
+    }
+}
+
+// Helper trait to convert String errors to Rhai errors
+impl<T> ToRhaiError<T> for Result<T, String> {
+    fn to_rhai_error(self) -> Result<T, Box<EvalAltResult>> {
+        self.map_err(|e| {
+            Box::new(EvalAltResult::ErrorRuntime(
+                format!("Mycelium error: {}", e).into(),
+                rhai::Position::NONE
+            ))
+        })
+    }
+}
+
+//
+// Mycelium Client Function Wrappers
+//
+
+/// Wrapper for mycelium::get_node_info
+///
+/// Gets information about the Mycelium node.
+pub fn mycelium_get_node_info(api_url: &str) -> Result<Dynamic, Box<EvalAltResult>> {
+    let rt = get_runtime()?;
+    
+    let result = rt.block_on(async {
+        client::get_node_info(api_url).await
+    });
+    
+    let node_info = result.to_rhai_error()?;
+    
+    Ok(value_to_dynamic(node_info))
+}
+
+/// Wrapper for mycelium::list_peers
+///
+/// Lists all peers connected to the Mycelium node.
+pub fn mycelium_list_peers(api_url: &str) -> Result<Dynamic, Box<EvalAltResult>> {
+    let rt = get_runtime()?;
+    
+    let result = rt.block_on(async {
+        client::list_peers(api_url).await
+    });
+    
+    let peers = result.to_rhai_error()?;
+    
+    Ok(value_to_dynamic(peers))
+}
+
+/// Wrapper for mycelium::add_peer
+///
+/// Adds a new peer to the Mycelium node.
+pub fn mycelium_add_peer(api_url: &str, peer_address: &str) -> Result<Dynamic, Box<EvalAltResult>> {
+    let rt = get_runtime()?;
+    
+    let result = rt.block_on(async {
+        client::add_peer(api_url, peer_address).await
+    });
+    
+    let response = result.to_rhai_error()?;
+    
+    Ok(value_to_dynamic(response))
+}
+
+/// Wrapper for mycelium::remove_peer
+///
+/// Removes a peer from the Mycelium node.
+pub fn mycelium_remove_peer(api_url: &str, peer_id: &str) -> Result<Dynamic, Box<EvalAltResult>> {
+    let rt = get_runtime()?;
+    
+    let result = rt.block_on(async {
+        client::remove_peer(api_url, peer_id).await
+    });
+    
+    let response = result.to_rhai_error()?;
+    
+    Ok(value_to_dynamic(response))
+}
+
+/// Wrapper for mycelium::list_selected_routes
+///
+/// Lists all selected routes in the Mycelium node.
+pub fn mycelium_list_selected_routes(api_url: &str) -> Result<Dynamic, Box<EvalAltResult>> {
+    let rt = get_runtime()?;
+    
+    let result = rt.block_on(async {
+        client::list_selected_routes(api_url).await
+    });
+    
+    let routes = result.to_rhai_error()?;
+    
+    Ok(value_to_dynamic(routes))
+}
+
+/// Wrapper for mycelium::list_fallback_routes
+///
+/// Lists all fallback routes in the Mycelium node.
+pub fn mycelium_list_fallback_routes(api_url: &str) -> Result<Dynamic, Box<EvalAltResult>> {
+    let rt = get_runtime()?;
+    
+    let result = rt.block_on(async {
+        client::list_fallback_routes(api_url).await
+    });
+    
+    let routes = result.to_rhai_error()?;
+    
+    Ok(value_to_dynamic(routes))
+}
+
+/// Wrapper for mycelium::send_message
+///
+/// Sends a message to a destination via the Mycelium node.
+pub fn mycelium_send_message(api_url: &str, destination: &str, topic: &str, message: &str, deadline_secs: i64) -> Result<Dynamic, Box<EvalAltResult>> {
+    let rt = get_runtime()?;
+    
+    // Convert deadline to u64
+    let deadline = if deadline_secs < 0 {
+        return Err(Box::new(EvalAltResult::ErrorRuntime(
+            "Deadline cannot be negative".into(),
+            rhai::Position::NONE
+        )));
+    } else {
+        deadline_secs as u64
+    };
+    
+    let result = rt.block_on(async {
+        client::send_message(api_url, destination, topic, message, deadline).await
+    });
+    
+    let response = result.to_rhai_error()?;
+    
+    Ok(value_to_dynamic(response))
+}
+
+/// Wrapper for mycelium::receive_messages
+///
+/// Receives messages from a topic via the Mycelium node.
+pub fn mycelium_receive_messages(api_url: &str, topic: &str, count: i64) -> Result<Dynamic, Box<EvalAltResult>> {
+    let rt = get_runtime()?;
+    
+    // Convert count to u32
+    let count = if count < 0 {
+        return Err(Box::new(EvalAltResult::ErrorRuntime(
+            "Count cannot be negative".into(),
+            rhai::Position::NONE
+        )));
+    } else if count > u32::MAX as i64 {
+        return Err(Box::new(EvalAltResult::ErrorRuntime(
+            format!("Count too large, maximum is {}", u32::MAX).into(),
+            rhai::Position::NONE
+        )));
+    } else {
+        count as u32
+    };
+    
+    let result = rt.block_on(async {
+        client::receive_messages(api_url, topic, count).await
+    });
+    
+    let messages = result.to_rhai_error()?;
+    
+    Ok(value_to_dynamic(messages))
+}

src/rhai/vault.rs

@@ -11,8 +11,8 @@ use std::str::FromStr;
 use std::sync::Mutex;
 use tokio::runtime::Runtime;
 
-use crate::vault::ethereum;
+use crate::vault::ethereum::contract_utils::{convert_token_to_rhai, prepare_function_arguments};
-use crate::vault::keyspace::session_manager as keypair;
+use crate::vault::{ethereum, keypair};
 
 use crate::vault::symmetric::implementation as symmetric_impl;
 // Global Tokio runtime for blocking async operations
@@ -83,7 +83,7 @@ fn load_key_space(name: &str, password: &str) -> bool {
 }
 
 fn create_key_space(name: &str, password: &str) -> bool {
-    match keypair::create_space(name) {
+    match keypair::session_manager::create_space(name) {
         Ok(_) => {
             // Get the current space
             match keypair::get_current_space() {
@@ -763,7 +763,7 @@ fn call_contract_read(contract_json: &str, function_name: &str, args: rhai::Arra
     };
 
     // Prepare the arguments
-    let tokens = match ethereum::prepare_function_arguments(&contract.abi, function_name, &args) {
+    let tokens = match prepare_function_arguments(&contract.abi, function_name, &args) {
         Ok(tokens) => tokens,
         Err(e) => {
             log::error!("Error preparing arguments: {}", e);
@@ -793,7 +793,7 @@ fn call_contract_read(contract_json: &str, function_name: &str, args: rhai::Arra
     match rt.block_on(async {
         ethereum::call_read_function(&contract, &provider, function_name, tokens).await
     }) {
-        Ok(result) => ethereum::convert_token_to_rhai(&result),
+        Ok(result) => convert_token_to_rhai(&result),
         Err(e) => {
             log::error!("Failed to call contract function: {}", e);
             Dynamic::UNIT
@@ -818,7 +818,7 @@ fn call_contract_write(contract_json: &str, function_name: &str, args: rhai::Arr
     };
 
     // Prepare the arguments
-    let tokens = match ethereum::prepare_function_arguments(&contract.abi, function_name, &args) {
+    let tokens = match prepare_function_arguments(&contract.abi, function_name, &args) {
         Ok(tokens) => tokens,
         Err(e) => {
             log::error!("Error preparing arguments: {}", e);

src/vault/ethereum/wallet.rs

@@ -4,12 +4,12 @@ use ethers::prelude::*;
 use ethers::signers::{LocalWallet, Signer, Wallet};
 use ethers::utils::hex;
 use k256::ecdsa::SigningKey;
-use sha2::{Digest, Sha256};
 use std::str::FromStr;
+use sha2::{Sha256, Digest};
 
-use super::networks::NetworkConfig;
-use crate::vault;
 use crate::vault::error::CryptoError;
+use crate::vault::keypair::KeyPair;
+use super::networks::NetworkConfig;
 
 /// An Ethereum wallet derived from a keypair.
 #[derive(Debug, Clone)]
@@ -21,103 +21,91 @@ pub struct EthereumWallet {
 
 impl EthereumWallet {
     /// Creates a new Ethereum wallet from a keypair for a specific network.
-    pub fn from_keypair(
+    pub fn from_keypair(keypair: &KeyPair, network: NetworkConfig) -> Result<Self, CryptoError> {
-        keypair: &vault::keyspace::keypair_types::KeyPair,
-        network: NetworkConfig,
-    ) -> Result<Self, CryptoError> {
         // Get the private key bytes from the keypair
         let private_key_bytes = keypair.signing_key.to_bytes();
-
+        
         // Convert to a hex string (without 0x prefix)
         let private_key_hex = hex::encode(private_key_bytes);
-
+        
         // Create an Ethereum wallet from the private key
         let wallet = LocalWallet::from_str(&private_key_hex)
             .map_err(|_e| CryptoError::InvalidKeyLength)?
             .with_chain_id(network.chain_id);
-
+        
         // Get the Ethereum address
         let address = wallet.address();
-
+        
         Ok(EthereumWallet {
             address,
             wallet,
             network,
         })
     }
-
+    
     /// Creates a new Ethereum wallet from a name and keypair (deterministic derivation) for a specific network.
-    pub fn from_name_and_keypair(
+    pub fn from_name_and_keypair(name: &str, keypair: &KeyPair, network: NetworkConfig) -> Result<Self, CryptoError> {
-        name: &str,
-        keypair: &vault::keyspace::keypair_types::KeyPair,
-        network: NetworkConfig,
-    ) -> Result<Self, CryptoError> {
         // Get the private key bytes from the keypair
         let private_key_bytes = keypair.signing_key.to_bytes();
-
+        
         // Create a deterministic seed by combining name and private key
         let mut hasher = Sha256::default();
         hasher.update(name.as_bytes());
         hasher.update(&private_key_bytes);
         let seed = hasher.finalize();
-
+        
         // Use the seed as a private key
         let private_key_hex = hex::encode(seed);
-
+        
         // Create an Ethereum wallet from the derived private key
         let wallet = LocalWallet::from_str(&private_key_hex)
             .map_err(|_e| CryptoError::InvalidKeyLength)?
             .with_chain_id(network.chain_id);
-
+        
         // Get the Ethereum address
         let address = wallet.address();
-
+        
         Ok(EthereumWallet {
             address,
             wallet,
             network,
         })
     }
-
+    
     /// Creates a new Ethereum wallet from a private key for a specific network.
-    pub fn from_private_key(
+    pub fn from_private_key(private_key: &str, network: NetworkConfig) -> Result<Self, CryptoError> {
-        private_key: &str,
-        network: NetworkConfig,
-    ) -> Result<Self, CryptoError> {
         // Remove 0x prefix if present
         let private_key_clean = private_key.trim_start_matches("0x");
-
+        
         // Create an Ethereum wallet from the private key
         let wallet = LocalWallet::from_str(private_key_clean)
             .map_err(|_e| CryptoError::InvalidKeyLength)?
             .with_chain_id(network.chain_id);
-
+        
         // Get the Ethereum address
         let address = wallet.address();
-
+        
         Ok(EthereumWallet {
             address,
             wallet,
             network,
         })
     }
-
+    
     /// Gets the Ethereum address as a string.
     pub fn address_string(&self) -> String {
         format!("{:?}", self.address)
     }
-
+    
     /// Signs a message with the Ethereum wallet.
     pub async fn sign_message(&self, message: &[u8]) -> Result<String, CryptoError> {
-        let signature = self
+        let signature = self.wallet.sign_message(message)
-            .wallet
-            .sign_message(message)
             .await
             .map_err(|e| CryptoError::SignatureFormatError(e.to_string()))?;
-
+        
         Ok(signature.to_string())
     }
-
+    
     /// Gets the private key as a hex string.
     pub fn private_key_hex(&self) -> String {
         let bytes = self.wallet.signer().to_bytes();

src/vault/keyspace/keypair_types.rs

@@ -1,15 +1,14 @@
 /// Implementation of keypair functionality.
-use k256::ecdsa::{
-    signature::{Signer, Verifier},
-    Signature, SigningKey, VerifyingKey,
-};
-use rand::rngs::OsRng;
-use serde::{Deserialize, Serialize};
-use sha2::{Digest, Sha256};
-use std::collections::HashMap;
 
-use crate::vault::error::CryptoError;
+use k256::ecdsa::{SigningKey, VerifyingKey, signature::{Signer, Verifier}, Signature};
+use k256::ecdh::EphemeralSecret;
+use rand::rngs::OsRng;
+use serde::{Serialize, Deserialize};
+use std::collections::HashMap;
+use sha2::{Sha256, Digest};
+
 use crate::vault::symmetric::implementation;
+use crate::vault::error::CryptoError;
 
 /// A keypair for signing and verifying messages.
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -24,8 +23,8 @@ pub struct KeyPair {
 // Serialization helpers for VerifyingKey
 mod verifying_key_serde {
     use super::*;
+    use serde::{Serializer, Deserializer};
     use serde::de::{self, Visitor};
-    use serde::{Deserializer, Serializer};
     use std::fmt;
 
     pub fn serialize<S>(key: &VerifyingKey, serializer: S) -> Result<S::Ok, S::Error>
@@ -65,7 +64,7 @@ mod verifying_key_serde {
             while let Some(byte) = seq.next_element()? {
                 bytes.push(byte);
             }
-
+            
             VerifyingKey::from_sec1_bytes(&bytes).map_err(|e| {
                 log::error!("Error deserializing verifying key from seq: {:?}", e);
                 de::Error::custom(format!("invalid verifying key from seq: {:?}", e))
@@ -85,8 +84,8 @@ mod verifying_key_serde {
 // Serialization helpers for SigningKey
 mod signing_key_serde {
     use super::*;
+    use serde::{Serializer, Deserializer};
     use serde::de::{self, Visitor};
-    use serde::{Deserializer, Serializer};
     use std::fmt;
 
     pub fn serialize<S>(key: &SigningKey, serializer: S) -> Result<S::Ok, S::Error>
@@ -126,7 +125,7 @@ mod signing_key_serde {
             while let Some(byte) = seq.next_element()? {
                 bytes.push(byte);
             }
-
+            
             SigningKey::from_bytes(bytes.as_slice().into()).map_err(|e| {
                 log::error!("Error deserializing signing key from seq: {:?}", e);
                 de::Error::custom(format!("invalid signing key from seq: {:?}", e))
@@ -148,7 +147,7 @@ impl KeyPair {
     pub fn new(name: &str) -> Self {
         let signing_key = SigningKey::random(&mut OsRng);
         let verifying_key = VerifyingKey::from(&signing_key);
-
+        
         KeyPair {
             name: name.to_string(),
             verifying_key,
@@ -160,7 +159,7 @@ impl KeyPair {
     pub fn pub_key(&self) -> Vec<u8> {
         self.verifying_key.to_sec1_bytes().to_vec()
     }
-
+    
     /// Derives a public key from a private key.
     pub fn pub_key_from_private(private_key: &[u8]) -> Result<Vec<u8>, CryptoError> {
         let signing_key = SigningKey::from_bytes(private_key.into())
@@ -179,121 +178,97 @@ impl KeyPair {
     pub fn verify(&self, message: &[u8], signature_bytes: &[u8]) -> Result<bool, CryptoError> {
         let signature = Signature::from_bytes(signature_bytes.into())
             .map_err(|e| CryptoError::SignatureFormatError(e.to_string()))?;
-
+            
         match self.verifying_key.verify(message, &signature) {
             Ok(_) => Ok(true),
             Err(_) => Ok(false), // Verification failed, but operation was successful
         }
     }
-
+    
     /// Verifies a message signature using only a public key.
-    pub fn verify_with_public_key(
+    pub fn verify_with_public_key(public_key: &[u8], message: &[u8], signature_bytes: &[u8]) -> Result<bool, CryptoError> {
-        public_key: &[u8],
+        let verifying_key = VerifyingKey::from_sec1_bytes(public_key)
-        message: &[u8],
+            .map_err(|_| CryptoError::InvalidKeyLength)?;
-        signature_bytes: &[u8],
+        
-    ) -> Result<bool, CryptoError> {
-        let verifying_key =
-            VerifyingKey::from_sec1_bytes(public_key).map_err(|_| CryptoError::InvalidKeyLength)?;
-
         let signature = Signature::from_bytes(signature_bytes.into())
             .map_err(|e| CryptoError::SignatureFormatError(e.to_string()))?;
-
+            
         match verifying_key.verify(message, &signature) {
             Ok(_) => Ok(true),
             Err(_) => Ok(false), // Verification failed, but operation was successful
         }
     }
-
+    
     /// Encrypts a message using the recipient's public key.
-    /// This implements a simplified version of ECIES (Elliptic Curve Integrated Encryption Scheme):
+    /// This implements ECIES (Elliptic Curve Integrated Encryption Scheme):
-    /// 1. Generate a random symmetric key
+    /// 1. Generate an ephemeral keypair
-    /// 2. Encrypt the message with the symmetric key
+    /// 2. Derive a shared secret using ECDH
-    /// 3. Encrypt the symmetric key with the recipient's public key
+    /// 3. Derive encryption key from the shared secret
-    /// 4. Return the encrypted key and the ciphertext
+    /// 4. Encrypt the message using symmetric encryption
-    pub fn encrypt_asymmetric(
+    /// 5. Return the ephemeral public key and the ciphertext
-        &self,
+    pub fn encrypt_asymmetric(&self, recipient_public_key: &[u8], message: &[u8]) -> Result<Vec<u8>, CryptoError> {
-        recipient_public_key: &[u8],
+        // Parse recipient's public key
-        message: &[u8],
+        let recipient_key = VerifyingKey::from_sec1_bytes(recipient_public_key)
-    ) -> Result<Vec<u8>, CryptoError> {
-        // Validate recipient's public key format
-        VerifyingKey::from_sec1_bytes(recipient_public_key)
             .map_err(|_| CryptoError::InvalidKeyLength)?;
-
+        
-        // Generate a random symmetric key
+        // Generate ephemeral keypair
-        let symmetric_key = implementation::generate_symmetric_key();
+        let ephemeral_signing_key = SigningKey::random(&mut OsRng);
-
+        let ephemeral_public_key = VerifyingKey::from(&ephemeral_signing_key);
-        // Encrypt the message with the symmetric key
+        
-        let encrypted_message = implementation::encrypt_with_key(&symmetric_key, message)
+        // Derive shared secret using ECDH
-            .map_err(|e| CryptoError::EncryptionFailed(e.to_string()))?;
+        let ephemeral_secret = EphemeralSecret::random(&mut OsRng);
-
+        let shared_secret = ephemeral_secret.diffie_hellman(&recipient_key.to_public_key());
-        // Encrypt the symmetric key with the recipient's public key
+        
-        // For simplicity, we'll just use the recipient's public key to derive an encryption key
+        // Derive encryption key from the shared secret (e.g., using HKDF or hashing)
-        // This is not secure for production use, but works for our test
+        // For simplicity, we'll hash the shared secret here
-        let key_encryption_key = {
+        let encryption_key = {
             let mut hasher = Sha256::default();
-            hasher.update(recipient_public_key);
+            hasher.update(shared_secret.raw_secret_bytes());
-            // Use a fixed salt for testing purposes
-            hasher.update(b"fixed_salt_for_testing");
             hasher.finalize().to_vec()
         };
-
+        
-        // Encrypt the symmetric key
+        // Encrypt the message using the derived key
-        let encrypted_key = implementation::encrypt_with_key(&key_encryption_key, &symmetric_key)
+        let ciphertext = implementation::encrypt_with_key(&encryption_key, message)
             .map_err(|e| CryptoError::EncryptionFailed(e.to_string()))?;
-
+        
-        // Format: encrypted_key_length (4 bytes) || encrypted_key || encrypted_message
+        // Format: ephemeral_public_key || ciphertext
-        let mut result = Vec::new();
+        let mut result = ephemeral_public_key.to_encoded_point(false).as_bytes().to_vec();
-        let key_len = encrypted_key.len() as u32;
+        result.extend_from_slice(&ciphertext);
-        result.extend_from_slice(&key_len.to_be_bytes());
+        
-        result.extend_from_slice(&encrypted_key);
-        result.extend_from_slice(&encrypted_message);
-
         Ok(result)
     }
-
+    
     /// Decrypts a message using the recipient's private key.
     /// This is the counterpart to encrypt_asymmetric.
     pub fn decrypt_asymmetric(&self, ciphertext: &[u8]) -> Result<Vec<u8>, CryptoError> {
-        // The format is: encrypted_key_length (4 bytes) || encrypted_key || encrypted_message
+        // The first 33 or 65 bytes (depending on compression) are the ephemeral public key
-        if ciphertext.len() <= 4 {
+        // For simplicity, we'll assume uncompressed keys (65 bytes)
-            return Err(CryptoError::DecryptionFailed(
+        if ciphertext.len() <= 65 {
-                "Ciphertext too short".to_string(),
+            return Err(CryptoError::DecryptionFailed("Ciphertext too short".to_string()));
-            ));
         }
-
+        
-        // Extract the encrypted key length
+        // Extract ephemeral public key and actual ciphertext
-        let mut key_len_bytes = [0u8; 4];
+        let ephemeral_public_key = &ciphertext[..65];
-        key_len_bytes.copy_from_slice(&ciphertext[0..4]);
+        let actual_ciphertext = &ciphertext[65..];
-        let key_len = u32::from_be_bytes(key_len_bytes) as usize;
+        
-
+        // Parse ephemeral public key
-        // Check if the ciphertext is long enough
+        let sender_key = VerifyingKey::from_sec1_bytes(ephemeral_public_key)
-        if ciphertext.len() <= 4 + key_len {
+            .map_err(|_| CryptoError::InvalidKeyLength)?;
-            return Err(CryptoError::DecryptionFailed(
+        
-                "Ciphertext too short".to_string(),
+        // Derive shared secret using ECDH
-            ));
+        let recipient_secret = EphemeralSecret::random(&mut OsRng);
-        }
+        let shared_secret = recipient_secret.diffie_hellman(&sender_key.to_public_key());
-
+        
-        // Extract the encrypted key and the encrypted message
+        // Derive decryption key from the shared secret (using the same method as encryption)
-        let encrypted_key = &ciphertext[4..4 + key_len];
+        let decryption_key = {
-        let encrypted_message = &ciphertext[4 + key_len..];
-
-        // Decrypt the symmetric key
-        // Use the same key derivation as in encryption
-        let key_encryption_key = {
             let mut hasher = Sha256::default();
-            hasher.update(self.verifying_key.to_sec1_bytes());
+            hasher.update(shared_secret.raw_secret_bytes());
-            // Use the same fixed salt as in encryption
-            hasher.update(b"fixed_salt_for_testing");
             hasher.finalize().to_vec()
         };
-
+        
-        // Decrypt the symmetric key
+        // Decrypt the message using the derived key
-        let symmetric_key = implementation::decrypt_with_key(&key_encryption_key, encrypted_key)
+        implementation::decrypt_with_key(&decryption_key, actual_ciphertext)
-            .map_err(|e| CryptoError::DecryptionFailed(format!("Failed to decrypt key: {}", e)))?;
+            .map_err(|e| CryptoError::DecryptionFailed(e.to_string()))
-
-        // Decrypt the message with the symmetric key
-        implementation::decrypt_with_key(&symmetric_key, encrypted_message)
-            .map_err(|e| CryptoError::DecryptionFailed(format!("Failed to decrypt message: {}", e)))
     }
 }
 
@@ -318,7 +293,7 @@ impl KeySpace {
         if self.keypairs.contains_key(name) {
             return Err(CryptoError::KeypairAlreadyExists(name.to_string()));
         }
-
+        
         let keypair = KeyPair::new(name);
         self.keypairs.insert(name.to_string(), keypair);
         Ok(())
@@ -326,9 +301,7 @@ impl KeySpace {
 
     /// Gets a keypair by name.
     pub fn get_keypair(&self, name: &str) -> Result<&KeyPair, CryptoError> {
-        self.keypairs
+        self.keypairs.get(name).ok_or(CryptoError::KeypairNotFound(name.to_string()))
-            .get(name)
-            .ok_or(CryptoError::KeypairNotFound(name.to_string()))
     }
 
     /// Lists all keypair names in the space.
@@ -336,3 +309,4 @@ impl KeySpace {
         self.keypairs.keys().cloned().collect()
     }
 }
+

src/vault/keyspace/tests/keypair_types_tests.rs

@@ -1,3 +1,4 @@
+
 use crate::vault::keyspace::keypair_types::{KeyPair, KeySpace};
 
 #[cfg(test)]
@@ -19,16 +20,12 @@ mod tests {
         let signature = keypair.sign(message);
         assert!(!signature.is_empty());
 
-        let is_valid = keypair
+        let is_valid = keypair.verify(message, &signature).expect("Verification failed");
-            .verify(message, &signature)
-            .expect("Verification failed");
         assert!(is_valid);
 
         // Test with a wrong message
         let wrong_message = b"This is a different message";
-        let is_valid_wrong = keypair
+        let is_valid_wrong = keypair.verify(wrong_message, &signature).expect("Verification failed with wrong message");
-            .verify(wrong_message, &signature)
-            .expect("Verification failed with wrong message");
         assert!(!is_valid_wrong);
     }
 
@@ -39,16 +36,13 @@ mod tests {
         let signature = keypair.sign(message);
         let public_key = keypair.pub_key();
 
-        let is_valid = KeyPair::verify_with_public_key(&public_key, message, &signature)
+        let is_valid = KeyPair::verify_with_public_key(&public_key, message, &signature).expect("Verification with public key failed");
-            .expect("Verification with public key failed");
         assert!(is_valid);
 
         // Test with a wrong public key
         let wrong_keypair = KeyPair::new("wrong_keypair");
         let wrong_public_key = wrong_keypair.pub_key();
-        let is_valid_wrong_key =
+        let is_valid_wrong_key = KeyPair::verify_with_public_key(&wrong_public_key, message, &signature).expect("Verification with wrong public key failed");
-            KeyPair::verify_with_public_key(&wrong_public_key, message, &signature)
-                .expect("Verification with wrong public key failed");
         assert!(!is_valid_wrong_key);
     }
 
@@ -56,7 +50,7 @@ mod tests {
     fn test_asymmetric_encryption_decryption() {
         // Sender's keypair
         let sender_keypair = KeyPair::new("sender");
-        let _ = sender_keypair.pub_key();
+        let sender_public_key = sender_keypair.pub_key();
 
         // Recipient's keypair
         let recipient_keypair = KeyPair::new("recipient");
@@ -65,15 +59,11 @@ mod tests {
         let message = b"This is a secret message";
 
         // Sender encrypts for recipient
-        let ciphertext = sender_keypair
+        let ciphertext = sender_keypair.encrypt_asymmetric(&recipient_public_key, message).expect("Encryption failed");
-            .encrypt_asymmetric(&recipient_public_key, message)
-            .expect("Encryption failed");
         assert!(!ciphertext.is_empty());
 
         // Recipient decrypts
-        let decrypted_message = recipient_keypair
+        let decrypted_message = recipient_keypair.decrypt_asymmetric(&ciphertext).expect("Decryption failed");
-            .decrypt_asymmetric(&ciphertext)
-            .expect("Decryption failed");
         assert_eq!(decrypted_message, message);
 
         // Test decryption with wrong keypair
@@ -85,9 +75,7 @@ mod tests {
     #[test]
     fn test_keyspace_add_keypair() {
         let mut space = KeySpace::new("test_space");
-        space
+        space.add_keypair("keypair1").expect("Failed to add keypair1");
-            .add_keypair("keypair1")
-            .expect("Failed to add keypair1");
         assert_eq!(space.keypairs.len(), 1);
         assert!(space.keypairs.contains_key("keypair1"));
 
@@ -95,4 +83,4 @@ mod tests {
         let result = space.add_keypair("keypair1");
         assert!(result.is_err());
     }
-}
+}

src/vault/keyspace/tests/session_manager_tests.rs

@@ -1,8 +1,8 @@
-use crate::vault::keyspace::keypair_types::KeySpace;
 use crate::vault::keyspace::session_manager::{
     clear_session, create_keypair, create_space, get_current_space, get_selected_keypair,
-    list_keypairs, select_keypair, set_current_space,
+    list_keypairs, select_keypair, set_current_space, SESSION,
 };
+use crate::vault::keyspace::keypair_types::KeySpace;
 
 // Helper function to clear the session before each test
 fn setup_test() {
@@ -48,8 +48,7 @@ mod tests {
         assert_eq!(keypair.name, "test_keypair");
 
         select_keypair("test_keypair").expect("Failed to select keypair");
-        let selected_keypair =
+        let selected_keypair = get_selected_keypair().expect("Failed to get selected keypair after select");
-            get_selected_keypair().expect("Failed to get selected keypair after select");
         assert_eq!(selected_keypair.name, "test_keypair");
     }
 

src/vault/kvs/tests/store_tests.rs

@@ -1,4 +1,5 @@
-use crate::vault::kvs::store::{create_store, delete_store, open_store};
+use crate::vault::kvs::store::{create_store, delete_store, open_store, KvStore};
+use std::path::PathBuf;
 
 // Helper function to generate a unique store name for each test
 fn generate_test_store_name() -> String {
@@ -101,4 +102,4 @@ mod tests {
 
         cleanup_test_store(&store_name);
     }
-}
+}