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

//! Ethereum wallet implementation.

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 super::networks::NetworkConfig;
use crate::error::CryptoError;
use crate::keyspace::KeyPair;

/// An Ethereum wallet derived from a keypair.
#[derive(Debug, Clone)]
pub struct EthereumWallet {
    pub address: Address,
    pub wallet: Wallet<SigningKey>,
    pub network: NetworkConfig,
}

impl EthereumWallet {
    /// Creates a new Ethereum wallet from a keypair for a specific network.
    pub fn from_keypair(
        keypair: &crate::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(
        name: &str,
        keypair: &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(
        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
            .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();
        hex::encode(bytes)
    }
}