sal-vault 0.1.0

SAL Vault - Cryptographic functionality including key management, digital signatures, symmetric encryption, Ethereum wallets, and encrypted key-value store
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

//! Tests for Ethereum wallet functionality.

use crate::vault::ethereum::*;
use crate::vault::keypair::implementation::KeyPair;
use ethers::utils::hex;

#[test]
fn test_ethereum_wallet_from_keypair() {
    let keypair = KeyPair::new("test_keypair");
    let network = networks::gnosis();
    
    let wallet = EthereumWallet::from_keypair(&keypair, network.clone()).unwrap();
    
    assert_eq!(wallet.network.name, "Gnosis");
    assert_eq!(wallet.network.chain_id, 100);
    
    // The address should be a valid Ethereum address
    assert!(wallet.address_string().starts_with("0x"));
}

#[test]
fn test_ethereum_wallet_from_name_and_keypair() {
    let keypair = KeyPair::new("test_keypair2");
    let network = networks::gnosis();
    
    let wallet = EthereumWallet::from_name_and_keypair("test", &keypair, network.clone()).unwrap();
    
    assert_eq!(wallet.network.name, "Gnosis");
    assert_eq!(wallet.network.chain_id, 100);
    
    // The address should be a valid Ethereum address
    assert!(wallet.address_string().starts_with("0x"));
    
    // Creating another wallet with the same name and keypair should yield the same address
    let wallet2 = EthereumWallet::from_name_and_keypair("test", &keypair, network.clone()).unwrap();
    assert_eq!(wallet.address, wallet2.address);
    
    // Creating a wallet with a different name should yield a different address
    let wallet3 = EthereumWallet::from_name_and_keypair("test2", &keypair, network.clone()).unwrap();
    assert_ne!(wallet.address, wallet3.address);
}

#[test]
fn test_ethereum_wallet_from_private_key() {
    let private_key = "0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
    let network = networks::gnosis();
    
    let wallet = EthereumWallet::from_private_key(private_key, network.clone()).unwrap();
    
    assert_eq!(wallet.network.name, "Gnosis");
    assert_eq!(wallet.network.chain_id, 100);
    
    // The address should be a valid Ethereum address
    assert!(wallet.address_string().starts_with("0x"));
    
    // The address should be deterministic based on the private key
    let wallet2 = EthereumWallet::from_private_key(private_key, network.clone()).unwrap();
    assert_eq!(wallet.address, wallet2.address);
}

#[test]
fn test_wallet_management() {
    // Clear any existing wallets
    clear_ethereum_wallets();
    
    // Create a key space and keypair
    crate::vault::keypair::session_manager::create_space("test_space").unwrap();
    crate::vault::keypair::create_keypair("test_keypair3").unwrap();
    
    // Create wallets for different networks
    let gnosis_wallet = create_ethereum_wallet_for_network(networks::gnosis()).unwrap();
    let peaq_wallet = create_ethereum_wallet_for_network(networks::peaq()).unwrap();
    let agung_wallet = create_ethereum_wallet_for_network(networks::agung()).unwrap();
    
    // Get the current wallets
    let current_gnosis = get_current_ethereum_wallet_for_network("Gnosis").unwrap();
    let current_peaq = get_current_ethereum_wallet_for_network("Peaq").unwrap();
    let current_agung = get_current_ethereum_wallet_for_network("Agung").unwrap();
    
    // Check that they match
    assert_eq!(gnosis_wallet.address, current_gnosis.address);
    assert_eq!(peaq_wallet.address, current_peaq.address);
    assert_eq!(agung_wallet.address, current_agung.address);
    
    // Clear wallets for a specific network
    clear_ethereum_wallets_for_network("Gnosis");
    
    // Check that the wallet is gone
    let result = get_current_ethereum_wallet_for_network("Gnosis");
    assert!(result.is_err());
    
    // But the others should still be there
    let current_peaq = get_current_ethereum_wallet_for_network("Peaq").unwrap();
    let current_agung = get_current_ethereum_wallet_for_network("Agung").unwrap();
    assert_eq!(peaq_wallet.address, current_peaq.address);
    assert_eq!(agung_wallet.address, current_agung.address);
    
    // Clear all wallets
    clear_ethereum_wallets();
    
    // Check that all wallets are gone
    let result1 = get_current_ethereum_wallet_for_network("Gnosis");
    let result2 = get_current_ethereum_wallet_for_network("Peaq");
    let result3 = get_current_ethereum_wallet_for_network("Agung");
    assert!(result1.is_err());
    assert!(result2.is_err());
    assert!(result3.is_err());
}

#[test]
fn test_sign_message() {
    let keypair = KeyPair::new("test_keypair4");
    let network = networks::gnosis();
    
    let wallet = EthereumWallet::from_keypair(&keypair, network.clone()).unwrap();
    
    // Create a tokio runtime for the async test
    let rt = tokio::runtime::Runtime::new().unwrap();
    
    // Sign a message
    let message = b"Hello, world!";
    let signature = rt.block_on(wallet.sign_message(message)).unwrap();
    
    // The signature should be a non-empty string
    assert!(!signature.is_empty());
}

#[test]
fn test_private_key_hex() {
    let keypair = KeyPair::new("test_keypair5");
    let network = networks::gnosis();
    
    let wallet = EthereumWallet::from_keypair(&keypair, network.clone()).unwrap();
    
    // Get the private key as hex
    let private_key_hex = wallet.private_key_hex();
    
    // The private key should be a 64-character hex string (32 bytes)
    assert_eq!(private_key_hex.len(), 64);
    
    // It should be possible to parse it as hex
    let _bytes = hex::decode(private_key_hex).unwrap();
}