slip10 0.4.3

SLIP-0010 : Universal private key derivation from master private key
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

use core::str::FromStr;

use slip10::BIP32Path;

const HARDEND: u32 = 1 << 31;

#[test]
fn test_parse_path() {
    let smaples = vec![
        ("", BIP32Path::from(Vec::new())),
        ("m", BIP32Path::from(Vec::new())),
        ("m/0H", BIP32Path::from(vec![HARDEND + 0])),
        ("m/0H/1", BIP32Path::from(vec![HARDEND + 0, 1])),
        (
            "m/0H/1/2H",
            BIP32Path::from(vec![HARDEND + 0, 1, HARDEND + 2]),
        ),
        (
            "m/0H/1/2H/2",
            BIP32Path::from(vec![HARDEND + 0, 1, HARDEND + 2, 2]),
        ),
        (
            "m/0H/1/2H/2/1000000000",
            BIP32Path::from(vec![HARDEND + 0, 1, HARDEND + 2, 2, 1000000000]),
        ),
        ("0H", BIP32Path::from(vec![HARDEND + 0])),
        ("0H/1", BIP32Path::from(vec![HARDEND + 0, 1])),
        (
            "0H/1/2H",
            BIP32Path::from(vec![HARDEND + 0, 1, HARDEND + 2]),
        ),
        (
            "0H/1/2H/2",
            BIP32Path::from(vec![HARDEND + 0, 1, HARDEND + 2, 2]),
        ),
        (
            "0H/1/2H/2/1000000000",
            BIP32Path::from(vec![HARDEND + 0, 1, HARDEND + 2, 2, 1000000000]),
        ),
        ("m/0'", BIP32Path::from(vec![HARDEND + 0])),
        ("m/0'/1", BIP32Path::from(vec![HARDEND + 0, 1])),
        (
            "m/0'/1/2'",
            BIP32Path::from(vec![HARDEND + 0, 1, HARDEND + 2]),
        ),
        (
            "m/0'/1/2'/2",
            BIP32Path::from(vec![HARDEND + 0, 1, HARDEND + 2, 2]),
        ),
        (
            "m/0'/1/2'/2/1000000000",
            BIP32Path::from(vec![HARDEND + 0, 1, HARDEND + 2, 2, 1000000000]),
        ),
        ("0'", BIP32Path::from(vec![HARDEND + 0])),
        ("0'/1", BIP32Path::from(vec![HARDEND + 0, 1])),
        (
            "0'/1/2'",
            BIP32Path::from(vec![HARDEND + 0, 1, HARDEND + 2]),
        ),
        (
            "0'/1/2'/2",
            BIP32Path::from(vec![HARDEND + 0, 1, HARDEND + 2, 2]),
        ),
        (
            "0'/1/2'/2/1000000000",
            BIP32Path::from(vec![HARDEND + 0, 1, HARDEND + 2, 2, 1000000000]),
        ),
        (
            "0/2147483647'/1/2147483646'/2",
            BIP32Path::from(vec![0, HARDEND + 2147483647, 1, HARDEND + 2147483646, 2]),
        ),
        (
            "0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0",
            BIP32Path::from(vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
        ),
    ];

    for (bip32_path_str, expected_bip32_path) in smaples {
        let parsed_bip32_path = BIP32Path::from_str(bip32_path_str).unwrap();
        assert_eq!(parsed_bip32_path, expected_bip32_path);

        let bip32_path_normalized_str = bip32_path_str.replace('H', "'");
        let bip32_path_normalized_str = if !bip32_path_normalized_str.starts_with("m/") {
            if bip32_path_str == "m" {
                format!("m/")
            } else {
                format!("m/{}", bip32_path_normalized_str)
            }
        } else {
            bip32_path_normalized_str
        };
        assert_eq!(parsed_bip32_path.to_string(), bip32_path_normalized_str);
    }

    let errors = vec![
        "44'/2147483648",
        "44'/2147483648'",
        "44'/-1",
        "44'//0",
        "/0'/1/2'",
        "44'/'",
        "44'/'0",
        "44'/0h",
        "44'/0''",
        "44'/0H'",
        "wrong",
    ];

    for i in errors {
        assert!(BIP32Path::from_str(i).is_err());
    }
}