walletd_bitcoin 0.2.0

Bitcoin walletd library
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 crate::{AddressType, BitcoinWalletBuilder, Error, HDKey, Network, Seed};
use std::str::FromStr;
use walletd_coin_core::CryptoWalletBuilder;
use walletd_hd_key::HDNetworkType;

#[test]
fn test_default() -> Result<(), Error> {
    let builder = BitcoinWalletBuilder::default();
    assert_eq!(builder.address_format, AddressType::P2wpkh);
    assert_eq!(builder.account_discovery, true);
    assert!(builder.gap_limit_specified.is_some());
    assert_eq!(
        builder
            .gap_limit_specified
            .expect("should be some due to previous check"),
        20
    );
    assert!(builder.master_hd_key.is_none());
    assert!(builder.mnemonic_seed.is_none());
    assert_eq!(builder.network_type, Network::Bitcoin);
    Ok(())
}

#[test]
fn test_new() -> Result<(), Error> {
    let builder = BitcoinWalletBuilder::new();
    let default = BitcoinWalletBuilder::default();
    assert_eq!(builder.address_format, default.address_format);
    assert_eq!(builder.account_discovery, default.account_discovery);
    assert!(builder.gap_limit_specified.is_some());
    assert!(default.gap_limit_specified.is_some());
    assert_eq!(
        builder
            .gap_limit_specified
            .expect("should be some due to previous check"),
        default
            .gap_limit_specified
            .expect("should be some due to previous check")
    );
    assert!(builder.master_hd_key.is_none());
    assert!(builder.mnemonic_seed.is_none());
    assert_eq!(builder.network_type, default.network_type);
    assert_eq!(builder.hd_path_builder, default.hd_path_builder);
    Ok(())
}

#[test]
fn test_with_mnemonic_seed() -> Result<(), Error> {
    let seed_hex = "a2fd9c0522d84d52ee4c8533dc02d4b69b4df9b6255e1af20c9f1d4d691689f2a38637eb1ec778972bf845c32d5ae83c7536999b5666397ac32021b21e0accee";
    let seed = Seed::from_str(seed_hex).unwrap();
    let mut builder = BitcoinWalletBuilder::default();
    builder.mnemonic_seed(seed.clone());
    assert!(builder.mnemonic_seed.is_some());
    assert_eq!(
        builder
            .mnemonic_seed
            .expect("should be some due to previous check"),
        seed
    );
    Ok(())
}

#[test]
fn test_with_master_hd_key() -> Result<(), Error> {
    let seed_hex = "a2fd9c0522d84d52ee4c8533dc02d4b69b4df9b6255e1af20c9f1d4d691689f2a38637eb1ec778972bf845c32d5ae83c7536999b5666397ac32021b21e0accee";
    let seed = Seed::from_str(seed_hex).unwrap();
    let master_hd_key = HDKey::new_master(seed, HDNetworkType::TestNet)?;
    let mut builder = BitcoinWalletBuilder::default();
    builder.master_hd_key(master_hd_key.clone());
    assert!(builder.master_hd_key.is_some());
    assert_eq!(
        builder
            .master_hd_key
            .expect("should be some due to previous check"),
        master_hd_key
    );
    Ok(())
}

#[test]
fn test_with_address_format() -> Result<(), Error> {
    let mut builder = BitcoinWalletBuilder::default();
    builder.address_format(AddressType::P2pkh);
    assert_eq!(builder.address_format, AddressType::P2pkh);
    Ok(())
}

#[test]
fn test_with_network_type() -> Result<(), Error> {
    let mut builder = BitcoinWalletBuilder::default();
    builder.network_type(Network::Testnet);
    assert_eq!(builder.network_type, Network::Testnet);
    Ok(())
}

#[test]
fn test_with_hd_path_builder() -> Result<(), Error> {
    let mut builder = BitcoinWalletBuilder::default();
    assert!(builder.hd_path_builder.purpose.is_some());
    assert!(builder.hd_purpose.is_some());
    assert_eq!(
        builder.hd_path_builder.purpose.expect("checked is some"),
        builder
            .hd_purpose
            .expect("checked is some")
            .to_shortform_num()
    );
    let mut hd_path_builder = builder.hd_path_builder.clone();
    hd_path_builder.coin_type_index(0).address_index(1);
    builder.hd_path_builder(hd_path_builder);
    assert!(builder.hd_path_builder.coin_type.is_some());
    assert!(builder.hd_path_builder.address_index.is_some());
    assert_eq!(
        builder.hd_path_builder.coin_type.expect("checked is some"),
        0
    );
    assert_eq!(
        builder
            .hd_path_builder
            .address_index
            .expect("checked is some"),
        1
    );

    Ok(())
}