merge and fix tests

src/rhai/vault.rs

@@ -1,6 +1,7 @@
 //! Rhai bindings for SAL crypto functionality
 
 use base64::{engine::general_purpose::STANDARD as BASE64, Engine as _};
+use crate::vault::CryptoError;
 use ethers::types::{Address, U256};
 use once_cell::sync::Lazy;
 use rhai::{Dynamic, Engine, EvalAltResult};
@@ -9,9 +10,9 @@ use std::fs;
 use std::path::PathBuf;
 use std::str::FromStr;
 use std::sync::Mutex;
+use hex;
 use tokio::runtime::Runtime;
 
-use crate::vault::ethereum::contract_utils::{convert_token_to_rhai, prepare_function_arguments};
 use crate::vault::{ethereum, keyspace};
 
 use crate::vault::symmetric::implementation as symmetric_impl;
@@ -267,30 +268,103 @@ fn create_keyspace(name: &str, password: &str) -> bool {
 }
 
 fn select_keyspace(name: &str) -> bool {
-    match keyspace::select_keypair(name) {
+    let session = crate::vault::keyspace::session_manager::SESSION.lock().unwrap();
+    if let Some(ref current_space_obj) = session.current_space {
+        if current_space_obj.name == name {
+            log::debug!("Keyspace '{}' is already selected.", name);
+            return true;
+        }
+    }
+    log::warn!("Attempted to select keyspace '{}' which is not currently active. Use 'load_key_space(name, password)' to load and select a keyspace.", name);
+    false
+}
+
+fn rhai_list_keyspaces_actual() -> Vec<String> {
+    let home_dir = dirs::home_dir().unwrap_or_else(|| PathBuf::from("."));
+    let key_spaces_dir = home_dir.join(".hero-vault").join("key-spaces");
+
+    if !key_spaces_dir.exists() {
+        log::debug!("Key spaces directory does not exist: {}", key_spaces_dir.display());
+        return Vec::new();
+    }
+
+    let mut spaces = Vec::new();
+    match std::fs::read_dir(key_spaces_dir) {
+        Ok(entries) => {
+            for entry in entries {
+                if let Ok(entry) = entry {
+                    let path = entry.path();
+                    if path.is_file() {
+                        if let Some(ext) = path.extension() {
+                            if ext == "json" {
+                                if let Some(stem) = path.file_stem() {
+                                    if let Some(name) = stem.to_str() {
+                                        spaces.push(name.to_string());
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        Err(e) => {
+            log::error!("Error reading key spaces directory: {}", e);
+        }
+    }
+    spaces
+}
+
+fn rhai_list_keypairs() -> Vec<String> {
+    match keyspace::session_manager::list_keypairs() {
+        Ok(keypairs) => keypairs,
+        Err(e) => {
+            log::error!("Error listing keypairs: {}", e);
+            Vec::new()
+        }
+    }
+}
+
+fn rhai_select_keypair(name: &str) -> bool {
+    match keyspace::session_manager::select_keypair(name) {
         Ok(_) => true,
         Err(e) => {
-            log::error!("Error selecting keyspace: {}", e);
+            log::error!("Error selecting keypair '{}': {}", name, e);
             false
         }
     }
 }
 
-fn list_keyspaces() -> Vec<String> {
-    match keyspace::list_keypairs() {
-        Ok(keyspaces) => keyspaces,
+fn rhai_clear_session() {
+    keyspace::session_manager::clear_session();
+}
+
+fn rhai_create_keypair(name: &str) -> bool {
+    match keyspace::session_manager::create_keypair(name) {
+        Ok(_) => true,
         Err(e) => {
-            log::error!("Error listing keyspaces: {}", e);
-            Vec::new()
+            log::error!("Error creating keypair '{}': {}", name, e);
+            false
         }
     }
 }
 
+// Rhai wrapper for getting the public key of the selected keypair
+fn rhai_keypair_pub_key() -> Result<String, Box<EvalAltResult>> {
+    match keyspace::session_manager::get_selected_keypair() {
+        Ok(keypair) => Ok(hex::encode(keypair.pub_key())),
+        Err(e) => Err(Box::new(EvalAltResult::ErrorSystem(
+            "Failed to get public key".to_string(),
+            Box::new(e),
+        ))),
+    }
+}
+
 // Cryptographic operations
 fn sign(message: &str) -> String {
     let message_bytes = message.as_bytes();
-    match keyspace::keypair_sign(message_bytes) {
-        Ok(signature) => BASE64.encode(signature),
+    match keyspace::session_manager::keypair_sign(message_bytes) {
+        Ok(signature_bytes) => BASE64.encode(signature_bytes),
         Err(e) => {
             log::error!("Error signing message: {}", e);
             String::new()
@@ -884,7 +958,12 @@ pub fn register_crypto_module(engine: &mut Engine) -> Result<(), Box<EvalAltResu
     // Register keyspace functions
     engine.register_fn("create_keyspace", create_keyspace);
     engine.register_fn("select_keyspace", select_keyspace);
-    engine.register_fn("list_keyspaces", list_keyspaces);
+    engine.register_fn("list_keyspaces", rhai_list_keyspaces_actual);
+    engine.register_fn("list_keypairs", rhai_list_keypairs);
+    engine.register_fn("select_keypair", rhai_select_keypair);
+    engine.register_fn("clear_session", rhai_clear_session);
+    engine.register_fn("create_keypair", rhai_create_keypair);
+    engine.register_fn("keypair_pub_key", rhai_keypair_pub_key);
 
     // Register signing/verification functions
     engine.register_fn("sign", sign);

src/vault/ethereum/wallet.rs

@@ -22,7 +22,7 @@ pub struct EthereumWallet {
 impl EthereumWallet {
     /// Creates a new Ethereum wallet from a keypair for a specific network.
     pub fn from_keypair(
-        keypair: &vault::keyspace::keypair_types::KeyPair,
+        keypair: &crate::vault::keyspace::keypair_types::KeyPair,
         network: NetworkConfig,
     ) -> Result<Self, CryptoError> {
         // Get the private key bytes from the keypair

src/vault/keyspace/keypair_types.rs

@@ -227,7 +227,7 @@ impl KeyPair {
 
         // Derive shared secret using ECDH
         let ephemeral_secret = EphemeralSecret::random(&mut OsRng);
-        let shared_secret = ephemeral_secret.diffie_hellman(&recipient_key.into());
+        let _shared_secret = ephemeral_secret.diffie_hellman(&recipient_key.into());
 
         // Derive encryption key from the shared secret (e.g., using HKDF or hashing)
         // For simplicity, we'll hash the shared secret here
@@ -274,7 +274,7 @@ impl KeyPair {
 
         // Derive shared secret using ECDH
         let recipient_secret = EphemeralSecret::random(&mut OsRng);
-        let shared_secret = recipient_secret.diffie_hellman(&sender_key.into());
+        let _shared_secret = recipient_secret.diffie_hellman(&sender_key.into());
 
         // Derive decryption key from the shared secret (using the same method as encryption)
         let decryption_key = {