tinyminiscript 0.0.7

A lightweight, no_std-compatible miniscript parser and validator 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
129
130
131
132
133
134
135
136
137
138
139
140

use crate::context::Context;
use crate::parser::{Fragment, Position};

/// Script descriptor
#[derive(Clone, PartialEq)]
#[repr(u8)]
pub enum Descriptor {
    /// A raw scriptpubkey (including pay-to-pubkey) under Legacy context
    Bare,

    /// Pay-to-PubKey-Hash
    Pkh,
    /// Pay-to-ScriptHash(includes nested wsh/wpkh/sorted multi)
    Sh,

    /// Pay-to-Witness-PubKey-Hash
    Wpkh,
    /// Pay-to-Witness-ScriptHash with Segwitv0 context
    Wsh,

    /// Pay-to-Taproot
    Tr,

    /// Raw public key
    Pk,
}

impl Default for Descriptor {
    #[inline]
    fn default() -> Self {
        Descriptor::Bare
    }
}

impl Descriptor {
    pub fn is_witness(&self) -> bool {
        matches!(self, Descriptor::Wsh | Descriptor::Wpkh)
    }
}

pub struct InvalidDescriptor;

impl<'a> TryFrom<&'a str> for Descriptor {
    type Error = InvalidDescriptor;
    fn try_from(value: &'a str) -> Result<Self, Self::Error> {
        match value {
            "pkh" => Ok(Descriptor::Pkh),
            "sh" => Ok(Descriptor::Sh),
            "wpkh" => Ok(Descriptor::Wpkh),
            "wsh" => Ok(Descriptor::Wsh),
            "tr" => Ok(Descriptor::Tr),
            "pk" => Ok(Descriptor::Pk),
            _ => Err(InvalidDescriptor),
        }
    }
}

#[cfg(feature = "debug")]
impl core::fmt::Debug for Descriptor {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            Descriptor::Bare => write!(f, "bare"),
            Descriptor::Pkh => write!(f, "pkh"),
            Descriptor::Sh => write!(f, "sh"),
            Descriptor::Wpkh => write!(f, "wpkh"),
            Descriptor::Wsh => write!(f, "wsh"),
            Descriptor::Tr => write!(f, "tr"),
            Descriptor::Pk => write!(f, "pk"),
        }
    }
}

pub struct DescriptorValidator {}

impl DescriptorValidator {
    #[inline]
    pub const fn new() -> Self {
        Self {}
    }

    /// Validate the descriptor structure
    /// Not using a Visitor pattern because it's not needed for the current use case.
    pub fn validate(&self, ctx: &Context) -> Result<(), DescriptorVisitorError> {
        let descriptor = ctx.descriptor();
        for ele in ctx.get_nodes() {
            match &ele.fragment {
                Fragment::PkK { key } | Fragment::PkH { key } => {
                    if descriptor.is_witness() && !key.is_compressed() {
                        return Err(DescriptorVisitorError::PublicKeyNotCompressed {
                            position: ele.position,
                        });
                    }
                }
                Fragment::Multi { keys, .. } => {
                    // (P2WSH only)
                    if descriptor != Descriptor::Wsh {
                        return Err(DescriptorVisitorError::InvalidFragmentForDescriptor {
                            position: ele.position,
                            expected: Descriptor::Wsh,
                            found: descriptor,
                        });
                    }
                }
                Fragment::MultiA { keys, .. } => {
                    // Tapscript only
                    if descriptor != Descriptor::Tr {
                        return Err(DescriptorVisitorError::InvalidFragmentForDescriptor {
                            position: ele.position,
                            expected: Descriptor::Tr,
                            found: descriptor,
                        });
                    }
                }
                Fragment::RawPkH { key } => {
                    if descriptor == Descriptor::Wpkh && !key.is_compressed() {
                        return Err(DescriptorVisitorError::PublicKeyNotCompressed {
                            position: ele.position,
                        });
                    }
                }
                _ => {
                    continue;
                }
            }
        }
        Ok(())
    }
}

#[cfg_attr(feature = "debug", derive(Debug))]
pub enum DescriptorVisitorError {
    InvalidFragmentForDescriptor {
        position: Position,
        expected: Descriptor,
        found: Descriptor,
    },
    PublicKeyNotCompressed {
        position: Position,
    },
}