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

//! Ethereum wallet storage functionality.

use once_cell::sync::Lazy;
use std::collections::HashMap;
use std::sync::Mutex;

use super::networks::{self, NetworkConfig};
use super::wallet::EthereumWallet;
use crate::error::CryptoError;

/// Global storage for Ethereum wallets.
static ETH_WALLETS: Lazy<Mutex<HashMap<String, Vec<EthereumWallet>>>> =
    Lazy::new(|| Mutex::new(HashMap::new()));

/// Creates an Ethereum wallet from the currently selected keypair for a specific network.
pub fn create_ethereum_wallet_for_network(
    network: NetworkConfig,
) -> Result<EthereumWallet, CryptoError> {
    // Get the currently selected keypair
    let keypair = crate::keyspace::get_selected_keypair()?;

    // Create an Ethereum wallet from the keypair
    let wallet = EthereumWallet::from_keypair(&keypair, network)?;

    // Store the wallet
    let mut wallets = ETH_WALLETS.lock().unwrap();
    let network_wallets = wallets
        .entry(wallet.network.name.clone())
        .or_insert_with(Vec::new);
    network_wallets.push(wallet.clone());

    Ok(wallet)
}

/// Creates an Ethereum wallet from the currently selected keypair for the Peaq network.
pub fn create_peaq_wallet() -> Result<EthereumWallet, CryptoError> {
    create_ethereum_wallet_for_network(networks::peaq())
}

/// Creates an Ethereum wallet from the currently selected keypair for the Agung testnet.
pub fn create_agung_wallet() -> Result<EthereumWallet, CryptoError> {
    create_ethereum_wallet_for_network(networks::agung())
}

/// Gets the current Ethereum wallet for a specific network.
pub fn get_current_ethereum_wallet_for_network(
    network_name: &str,
) -> Result<EthereumWallet, CryptoError> {
    let wallets = ETH_WALLETS.lock().unwrap();

    let network_wallets = wallets
        .get(network_name)
        .ok_or(CryptoError::NoKeypairSelected)?;

    if network_wallets.is_empty() {
        return Err(CryptoError::NoKeypairSelected);
    }

    Ok(network_wallets.last().unwrap().clone())
}

/// Gets the current Ethereum wallet for the Peaq network.
pub fn get_current_peaq_wallet() -> Result<EthereumWallet, CryptoError> {
    get_current_ethereum_wallet_for_network("Peaq")
}

/// Gets the current Ethereum wallet for the Agung testnet.
pub fn get_current_agung_wallet() -> Result<EthereumWallet, CryptoError> {
    get_current_ethereum_wallet_for_network("Agung")
}

/// Clears all Ethereum wallets.
pub fn clear_ethereum_wallets() {
    let mut wallets = ETH_WALLETS.lock().unwrap();
    wallets.clear();
}

/// Clears Ethereum wallets for a specific network.
pub fn clear_ethereum_wallets_for_network(network_name: &str) {
    let mut wallets = ETH_WALLETS.lock().unwrap();
    wallets.remove(network_name);
}

/// Creates an Ethereum wallet from a name and the currently selected keypair for a specific network.
pub fn create_ethereum_wallet_from_name_for_network(
    name: &str,
    network: NetworkConfig,
) -> Result<EthereumWallet, CryptoError> {
    // Get the currently selected keypair
    let keypair = crate::keyspace::get_selected_keypair()?;

    // Create an Ethereum wallet from the name and keypair
    let wallet = EthereumWallet::from_name_and_keypair(name, &keypair, network)?;

    // Store the wallet
    let mut wallets = ETH_WALLETS.lock().unwrap();
    let network_wallets = wallets
        .entry(wallet.network.name.clone())
        .or_insert_with(Vec::new);
    network_wallets.push(wallet.clone());

    Ok(wallet)
}

/// Creates an Ethereum wallet from a name and the currently selected keypair for the Gnosis network.
pub fn create_ethereum_wallet_from_name(name: &str) -> Result<EthereumWallet, CryptoError> {
    create_ethereum_wallet_from_name_for_network(name, networks::gnosis())
}

/// Creates an Ethereum wallet from a private key for a specific network.
pub fn create_ethereum_wallet_from_private_key_for_network(
    private_key: &str,
    network: NetworkConfig,
) -> Result<EthereumWallet, CryptoError> {
    // Create an Ethereum wallet from the private key
    let wallet = EthereumWallet::from_private_key(private_key, network)?;

    // Store the wallet
    let mut wallets = ETH_WALLETS.lock().unwrap();
    let network_wallets = wallets
        .entry(wallet.network.name.clone())
        .or_insert_with(Vec::new);
    network_wallets.push(wallet.clone());

    Ok(wallet)
}

/// Creates an Ethereum wallet from a private key for the Gnosis network.
pub fn create_ethereum_wallet_from_private_key(
    private_key: &str,
) -> Result<EthereumWallet, CryptoError> {
    create_ethereum_wallet_from_private_key_for_network(private_key, networks::gnosis())
}