qualia_client_core/wallet/
derivation.rs1use 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 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 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" => {
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]; 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 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 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}