webylib 0.2.6

Webcash HD wallet library — bearer e-cash with BIP32-style key derivation, SQLite storage, AES-256-GCM encryption, and full C FFI for cross-platform SDKs
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

use webylib::hd::{ChainCode, HDWallet};

#[test]
fn test_hd_wallet_creation() {
    let wallet = HDWallet::new().unwrap();
    assert_eq!(wallet.master_secret().len(), 32);
}

#[test]
fn test_chain_code_values() {
    assert_eq!(ChainCode::Receive.as_u64(), 0);
    assert_eq!(ChainCode::Pay.as_u64(), 1);
    assert_eq!(ChainCode::Change.as_u64(), 2);
    assert_eq!(ChainCode::Mining.as_u64(), 3);
}

#[test]
fn test_chain_code_from_u64() {
    assert_eq!(ChainCode::from_u64(0), Some(ChainCode::Receive));
    assert_eq!(ChainCode::from_u64(1), Some(ChainCode::Pay));
    assert_eq!(ChainCode::from_u64(2), Some(ChainCode::Change));
    assert_eq!(ChainCode::from_u64(3), Some(ChainCode::Mining));
    assert_eq!(ChainCode::from_u64(4), None);
}

#[test]
fn test_chain_code_as_str() {
    assert_eq!(ChainCode::Receive.as_str(), "RECEIVE");
    assert_eq!(ChainCode::Pay.as_str(), "PAY");
    assert_eq!(ChainCode::Change.as_str(), "CHANGE");
    assert_eq!(ChainCode::Mining.as_str(), "MINING");
}

#[test]
fn test_secret_derivation_deterministic() {
    let master_secret = [1u8; 32];
    let wallet = HDWallet::from_master_secret(master_secret);

    let secret1 = wallet.derive_secret(ChainCode::Receive, 0).unwrap();
    let secret2 = wallet.derive_secret(ChainCode::Receive, 0).unwrap();
    assert_eq!(secret1, secret2);

    let secret3 = wallet.derive_secret(ChainCode::Pay, 0).unwrap();
    assert_ne!(secret1, secret3);

    let secret4 = wallet.derive_secret(ChainCode::Receive, 1).unwrap();
    assert_ne!(secret1, secret4);
}

#[test]
fn test_secret_derivation_format() {
    let wallet = HDWallet::from_master_secret([42u8; 32]);
    let secret = wallet.derive_secret(ChainCode::Receive, 0).unwrap();

    assert!(hex::decode(&secret).is_ok());
    assert_eq!(secret.len(), 64);
}

#[test]
fn test_derive_receive_secret() {
    let wallet = HDWallet::from_master_secret([1u8; 32]);
    let secret = wallet.derive_secret(ChainCode::Receive, 0).unwrap();
    assert!(hex::decode(&secret).is_ok());
    assert_eq!(secret.len(), 64);
}

#[test]
fn test_derive_pay_secret() {
    let wallet = HDWallet::from_master_secret([2u8; 32]);
    let secret = wallet.derive_secret(ChainCode::Pay, 1).unwrap();
    assert!(hex::decode(&secret).is_ok());
    assert_eq!(secret.len(), 64);
}

#[test]
fn test_derive_change_secret() {
    let wallet = HDWallet::from_master_secret([3u8; 32]);
    let secret = wallet.derive_secret(ChainCode::Change, 2).unwrap();
    assert!(hex::decode(&secret).is_ok());
    assert_eq!(secret.len(), 64);
}

#[test]
fn test_derive_mining_secret() {
    let wallet = HDWallet::from_master_secret([4u8; 32]);
    let secret = wallet.derive_secret(ChainCode::Mining, 3).unwrap();
    assert!(hex::decode(&secret).is_ok());
    assert_eq!(secret.len(), 64);
}

#[test]
fn test_master_secret_hex() {
    let master_secret = [
        0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0, 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE,
        0xF0, 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0, 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC,
        0xDE, 0xF0,
    ];
    let wallet = HDWallet::from_master_secret(master_secret);
    let hex_string = wallet.master_secret_hex();
    assert_eq!(
        hex_string,
        "123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0"
    );
    assert_eq!(hex_string.len(), 64);
}

#[test]
fn test_domain_separation() {
    let wallet = HDWallet::from_master_secret([5u8; 32]);

    let receive = wallet.derive_secret(ChainCode::Receive, 0).unwrap();
    let pay = wallet.derive_secret(ChainCode::Pay, 0).unwrap();
    let change = wallet.derive_secret(ChainCode::Change, 0).unwrap();
    let mining = wallet.derive_secret(ChainCode::Mining, 0).unwrap();

    let secrets = [receive, pay, change, mining];
    for i in 0..secrets.len() {
        for j in (i + 1)..secrets.len() {
            assert_ne!(
                secrets[i], secrets[j],
                "Secrets {} and {} should be different",
                i, j
            );
        }
    }
}