diff --git a/Cargo.toml b/Cargo.toml
index 50801a4..df479a8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,6 +14,7 @@ readme = "README.md"
 members = [".", "vault"]
 
 [dependencies]
+hex = "0.4"
 anyhow = "1.0.98"
 base64 = "0.22.1" # Base64 encoding/decoding
 cfg-if = "1.0"
diff --git a/rhai_tests/keypair/03_session_management.rhai b/rhai_tests/keypair/03_session_management.rhai
index a3a5cc1..0a61908 100644
--- a/rhai_tests/keypair/03_session_management.rhai
+++ b/rhai_tests/keypair/03_session_management.rhai
@@ -25,7 +25,7 @@ if create_key_space(space_name1, password) {
     print("Testing creating keypairs in current space...");
     let keypair1_name = "session_keypair1";
     
-    if create_keypair(keypair1_name, password) {
+    if create_keypair(keypair1_name) {
         print(`✓ Keypair "${keypair1_name}" created successfully in space "${space_name1}"`);
     } else {
         print(`✗ Failed to create keypair "${keypair1_name}" in space "${space_name1}"`);
@@ -60,7 +60,7 @@ if create_key_space(space_name1, password) {
         
         // Create a keypair in the second space
         let keypair2_name = "session_keypair2";
-        if create_keypair(keypair2_name, password) {
+        if create_keypair(keypair2_name) {
             print(`✓ Keypair "${keypair2_name}" created successfully in space "${space_name2}"`);
         } else {
             print(`✗ Failed to create keypair "${keypair2_name}" in space "${space_name2}"`);
@@ -109,7 +109,7 @@ if create_key_space(space_name1, password) {
     // Attempt to create a keypair
     let create_success = false;
     try {
-        create_success = create_keypair("no_space_keypair", password);
+        create_success = create_keypair("test_keypair_2");
     } catch(err) {
         print(`✓ Caught expected error for creating keypair without active space: ${err}`);
     }
diff --git a/rhai_tests/keypair/04_encryption_decryption.rhai b/rhai_tests/keypair/04_encryption_decryption.rhai
index 839c19a..5f6fbd2 100644
--- a/rhai_tests/keypair/04_encryption_decryption.rhai
+++ b/rhai_tests/keypair/04_encryption_decryption.rhai
@@ -22,7 +22,7 @@ if create_key_space(space_name, password) {
     print(`✓ Key space "${space_name}" created successfully`);
     
     // Create sender keypair
-    if create_keypair(sender_name, password) {
+    if create_keypair(sender_name) {
         print(`✓ Sender keypair "${sender_name}" created successfully`);
     } else {
         print(`✗ Failed to create sender keypair "${sender_name}"`);
@@ -30,7 +30,7 @@ if create_key_space(space_name, password) {
     }
     
     // Create recipient keypair
-    if create_keypair(recipient_name, password) {
+    if create_keypair(recipient_name) {
         print(`✓ Recipient keypair "${recipient_name}" created successfully`);
     } else {
         print(`✗ Failed to create recipient keypair "${recipient_name}"`);
diff --git a/rhai_tests/keypair/run_all_tests.rhai b/rhai_tests/keypair/run_all_tests.rhai
index d1f863f..b49612b 100644
--- a/rhai_tests/keypair/run_all_tests.rhai
+++ b/rhai_tests/keypair/run_all_tests.rhai
@@ -28,7 +28,7 @@ try {
     if create_key_space("test_space", "password") {
         print("✓ Key space created successfully");
         
-        if create_keypair(keypair_name, "password") {
+        if create_keypair(keypair_name) {
             print("✓ Keypair created successfully");
             
             // Test getting the public key
@@ -82,11 +82,11 @@ try {
         let keypair1_name = "keypair1";
         let keypair2_name = "keypair2";
         
-        if create_keypair(keypair1_name, password) {
+        if create_keypair(keypair1_name) {
             print(`✓ Keypair "${keypair1_name}" created successfully`);
         }
         
-        if create_keypair(keypair2_name, password) {
+        if create_keypair(keypair2_name) {
             print(`✓ Keypair "${keypair2_name}" created successfully`);
         }
         
@@ -128,7 +128,7 @@ try {
         print("Testing creating keypairs in current space...");
         let keypair1_name = "session_keypair1";
         
-        if create_keypair(keypair1_name, password) {
+        if create_keypair(keypair1_name) {
             print(`✓ Keypair "${keypair1_name}" created successfully in space "${space_name1}"`);
         }
         
@@ -165,12 +165,12 @@ try {
         print(`✓ Key space "${space_name}" created successfully`);
         
         // Create sender keypair
-        if create_keypair(sender_name, password) {
+        if create_keypair(sender_name) {
             print(`✓ Sender keypair "${sender_name}" created successfully`);
         }
         
         // Create recipient keypair
-        if create_keypair(recipient_name, password) {
+        if create_keypair(recipient_name) {
             print(`✓ Recipient keypair "${recipient_name}" created successfully`);
         }
         
diff --git a/rhai_tests/run_all_tests.sh b/rhai_tests/run_all_tests.sh
index 70f9bab..9ad31fa 100755
--- a/rhai_tests/run_all_tests.sh
+++ b/rhai_tests/run_all_tests.sh
@@ -7,7 +7,7 @@
 BASE_DIR="."
 
 # Path to herodo executable (assuming debug build)
-HERODO_CMD="../target/debug/herodo"
+HERODO_CMD="$HOME/hero/bin/herodo"
 
 # Define colors for output
 GREEN='\033[0;32m'
diff --git a/src/rhai/vault.rs b/src/rhai/vault.rs
index 5dfbdac..e46e2d3 100644
--- a/src/rhai/vault.rs
+++ b/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);
diff --git a/src/vault/ethereum/wallet.rs b/src/vault/ethereum/wallet.rs
index 8b83271..58d060f 100644
--- a/src/vault/ethereum/wallet.rs
+++ b/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
diff --git a/src/vault/keyspace/keypair_types.rs b/src/vault/keyspace/keypair_types.rs
index 4d4b9ca..a91d8cd 100644
--- a/src/vault/keyspace/keypair_types.rs
+++ b/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 = {