bwt 0.2.4

a lightweight hd wallet tracker and query engine for Bitcoin
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
127
128

use std::str::FromStr;

use bitcoin::secp256k1::{self, Secp256k1};
use bitcoin::{Address, Network};
use miniscript::descriptor::{Descriptor, DescriptorPublicKey, DescriptorTrait, Wildcard};
use miniscript::{ForEachKey, TranslatePk2};

use crate::error::{Error, OptionExt, Result};
use crate::util::xpub::{xpub_matches_network, Bip32Origin};

pub type ExtendedDescriptor = Descriptor<DescriptorPublicKey>;

#[derive(Debug, Clone, Hash, Eq, PartialEq)]
pub struct Checksum(String);

impl_string_serializer!(Checksum, c, c.0);

/// Derive the address at `index`
pub fn derive_address(desc: &ExtendedDescriptor, index: u32, network: Network) -> Option<Address> {
    lazy_static! {
        pub static ref EC: Secp256k1<secp256k1::VerifyOnly> = Secp256k1::verification_only();
    }
    desc.derive(index)
        .translate_pk2(|xpk| xpk.derive_public_key(&EC))
        .ok()?
        .address(network)
        .ok()
}

#[derive(Debug, Clone)]
pub struct DescKeyInfo {
    pub bip32_origin: Bip32Origin,
    pub is_wildcard: bool,
}

const CHECKSUM_CHARSET: &str = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";

impl FromStr for Checksum {
    type Err = Error;

    fn from_str(inp: &str) -> Result<Self> {
        ensure!(inp.len() == 8, "Invalid descriptor checksum length");
        for ch in inp.chars() {
            CHECKSUM_CHARSET
                .find(ch)
                .or_err("Invalid descriptor checksum character")?;
        }
        Ok(Checksum(inp.into()))
    }
}

impl DescKeyInfo {
    pub fn extract(desc: &ExtendedDescriptor, network: Network) -> Result<Vec<DescKeyInfo>> {
        let mut keys_info = vec![];

        let is_valid = desc.for_each_key(|fe| {
            match fe.as_key() {
                DescriptorPublicKey::XPub(desc_xpub) => {
                    // Get key origin information from the descriptor, fallback to extracting from the
                    // xpub itself.
                    let bip32_origin = desc_xpub
                        .origin
                        .as_ref()
                        .map_or_else(|| (&desc_xpub.xkey).into(), Into::<Bip32Origin>::into)
                        .extend(&desc_xpub.derivation_path);

                    keys_info.push(DescKeyInfo {
                        bip32_origin,
                        is_wildcard: desc_xpub.wildcard != Wildcard::None,
                    });

                    xpub_matches_network(&desc_xpub.xkey, network)
                }
                DescriptorPublicKey::SinglePub(desc_single) => {
                    if let Some(bip32_origin) = &desc_single.origin {
                        keys_info.push(DescKeyInfo {
                            bip32_origin: bip32_origin.into(),
                            is_wildcard: false,
                        });
                    }
                    true
                }
            }
        });

        ensure!(
            is_valid,
            "xpubs do not match the configured network {}",
            network
        );

        Ok(keys_info)
    }
}

pub trait DescriptorExt: Sized {
    /// Encode to string without the `#checksum` suffix
    fn to_string_no_checksum(&self) -> String;
    /// Get just the checksum
    fn checksum(&self) -> Checksum;
    /// Parse a descriptor, ensuring that it uses canonical encoding if the checksum is explicit
    fn parse_canonical(s: &str) -> Result<Self>;
}

impl DescriptorExt for ExtendedDescriptor {
    fn to_string_no_checksum(&self) -> String {
        self.to_string().splitn(2, '#').next().unwrap().into()
    }

    fn checksum(&self) -> Checksum {
        let desc_str = self.to_string();
        let checksum = desc_str.splitn(2, '#').nth(1).unwrap();
        Checksum(checksum.into())
    }

    fn parse_canonical(desc_str: &str) -> Result<ExtendedDescriptor> {
        let provided_desc_str = desc_str.splitn(2, '#').next().unwrap();
        let desc: ExtendedDescriptor = desc_str.parse()?;

        ensure!(
            desc.to_string_no_checksum() == provided_desc_str,
            "Descriptors with explicit checksums must use canonical encoding. `{}` is expected to be encoded as `{}`",
            provided_desc_str,
            desc.to_string_no_checksum()
        );
        Ok(desc)
    }
}