Skip to main content

qualia_client_core/wallet/
derivation.rs

1use bip32::{DerivationPath as Bip32Path, XPrv, XPub};
2use bs58;
3use ripemd::Ripemd160;
4use sha2::Sha256;
5use sha3::Keccak256;
6use std::str::FromStr;
7
8#[derive(Debug, Clone)]
9pub struct DerivationPath(pub String);
10
11#[derive(Debug, Clone)]
12pub struct AddressPayload {
13    pub network: String,
14    pub address: String,
15    pub path: String,
16    pub pubkey_hash: String,
17}
18
19pub struct HdWallet {
20    master_key: XPrv,
21}
22
23impl HdWallet {
24    /// Constructs from seed.
25    pub fn from_seed(seed_bytes: &[u8]) -> Result<Self, String> {
26        let master_key = XPrv::new(seed_bytes).map_err(|e| e.to_string())?;
27        Ok(Self { master_key })
28    }
29
30    /// Derives an address.
31    pub fn derive_address(&self, network: &str, path: &str) -> Result<AddressPayload, String> {
32        let derivation_path = Bip32Path::from_str(path).map_err(|e| e.to_string())?;
33        let mut child_xprv = self.master_key.clone();
34        for child in derivation_path.iter() {
35            child_xprv = child_xprv.derive_child(child).map_err(|e| e.to_string())?;
36        }
37        let public_key = child_xprv.public_key();
38
39        let address = match network {
40            "BTC" => Self::derive_btc_address(&public_key),
41            "XEC" => Self::derive_xec_address(&public_key),
42            "ETH" => Self::derive_eth_address(&public_key),
43            // Nym: never emit fabricated n1… locators (Planned until real bind).
44            "NYM" => {
45                return Err(
46                    "Nym locator not derived — Planned until claim+bind (no fabricated n1…)".into(),
47                );
48            }
49            _ => return Err(format!("Unsupported network: {}", network)),
50        };
51
52        let pubkey_bytes = public_key.to_bytes();
53        let sha256_hash = <Sha256 as sha2::Digest>::digest(&pubkey_bytes);
54        let ripemd160_hash = <Ripemd160 as ripemd::Digest>::digest(&sha256_hash);
55        let pubkey_hash = hex::encode(&ripemd160_hash);
56
57        Ok(AddressPayload {
58            network: network.to_string(),
59            address,
60            path: path.to_string(),
61            pubkey_hash,
62        })
63    }
64
65    fn derive_btc_address(pubkey: &XPub) -> String {
66        let pubkey_bytes = pubkey.to_bytes();
67        let sha256_hash = <Sha256 as sha2::Digest>::digest(&pubkey_bytes);
68        let ripemd160_hash = <Ripemd160 as ripemd::Digest>::digest(&sha256_hash);
69
70        let mut payload = vec![0x00]; // Mainnet pubkey hash version byte
71        payload.extend_from_slice(&ripemd160_hash);
72
73        let checksum_hash1 = <Sha256 as sha2::Digest>::digest(&payload);
74        let checksum_hash2 = <Sha256 as sha2::Digest>::digest(&checksum_hash1);
75
76        payload.extend_from_slice(&checksum_hash2[0..4]);
77
78        bs58::encode(payload).into_string()
79    }
80
81    fn derive_xec_address(pubkey: &XPub) -> String {
82        // We will output a base58 legacy address format with an ecash prefix
83        let btc_addr = Self::derive_btc_address(pubkey);
84        format!("ecash:{}", btc_addr)
85    }
86
87    fn derive_eth_address(pubkey: &XPub) -> String {
88        let pk = pubkey.public_key();
89        let uncompressed = pk.to_encoded_point(false);
90        let pub_bytes = &uncompressed.as_bytes()[1..];
91
92        let keccak_hash = <Keccak256 as sha3::Digest>::digest(pub_bytes);
93        let addr_bytes = &keccak_hash[12..];
94
95        format!("0x{}", hex::encode(addr_bytes))
96    }
97}
98
99#[cfg(test)]
100mod tests {
101    use super::*;
102
103    #[test]
104    fn test_address_derivation() {
105        // A known seed for deterministic testing
106        let seed = [0u8; 64];
107        let wallet = HdWallet::from_seed(&seed).unwrap();
108
109        let btc = wallet.derive_address("BTC", "m/44'/0'/0'/0/0").unwrap();
110        assert_eq!(btc.network, "BTC");
111        assert!(!btc.address.is_empty());
112
113        let eth = wallet.derive_address("ETH", "m/44'/60'/0'/0/0").unwrap();
114        assert_eq!(eth.network, "ETH");
115        assert!(eth.address.starts_with("0x"));
116
117        let xec = wallet.derive_address("XEC", "m/44'/899'/0'/0/0").unwrap();
118        assert_eq!(xec.network, "XEC");
119        assert!(xec.address.starts_with("ecash:"));
120
121        let nym_err = wallet.derive_address("NYM", "m/44'/118'/0'/0/0");
122        assert!(nym_err.is_err(), "NYM must not fabricate n1… locators");
123        let msg = nym_err.unwrap_err();
124        assert!(
125            msg.contains("n1") || msg.contains("Planned"),
126            "honest Planned error: {msg}"
127        );
128    }
129}