bdk_tx 0.1.0

Bitcoin transaction building 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

use bitcoin::{Amount, ScriptBuf, TxOut};
use miniscript::bitcoin;

use crate::DefiniteDescriptor;

/// Source of the output script pubkey
#[derive(Debug, Clone)]
pub enum ScriptSource {
    /// bitcoin script
    Script(ScriptBuf),
    /// definite descriptor
    Descriptor(DefiniteDescriptor),
}

impl From<ScriptBuf> for ScriptSource {
    fn from(script: ScriptBuf) -> Self {
        Self::from_script(script)
    }
}

impl From<DefiniteDescriptor> for ScriptSource {
    fn from(descriptor: DefiniteDescriptor) -> Self {
        Self::from_descriptor(descriptor)
    }
}

impl ScriptSource {
    /// From script
    pub fn from_script(script: ScriptBuf) -> Self {
        Self::Script(script)
    }

    /// From descriptor
    pub fn from_descriptor(descriptor: DefiniteDescriptor) -> Self {
        Self::Descriptor(descriptor)
    }

    /// To ScriptBuf
    pub fn script(&self) -> ScriptBuf {
        match self {
            ScriptSource::Script(spk) => spk.clone(),
            ScriptSource::Descriptor(descriptor) => descriptor.script_pubkey(),
        }
    }

    /// Get descriptor (if any).
    pub fn descriptor(&self) -> Option<&DefiniteDescriptor> {
        match self {
            ScriptSource::Script(_) => None,
            ScriptSource::Descriptor(descriptor) => Some(descriptor),
        }
    }
}

/// Builder output
#[derive(Debug, Clone)]
pub struct Output {
    /// Value
    pub value: Amount,
    /// Spk source
    pub script_pubkey_source: ScriptSource,
}

impl From<(ScriptBuf, Amount)> for Output {
    fn from((script, value): (ScriptBuf, Amount)) -> Self {
        Self::with_script(script, value)
    }
}

impl From<(DefiniteDescriptor, Amount)> for Output {
    fn from((descriptor, value): (DefiniteDescriptor, Amount)) -> Self {
        Self::with_descriptor(descriptor, value)
    }
}

impl Output {
    /// From script
    pub fn with_script(script: ScriptBuf, value: Amount) -> Self {
        Self {
            value,
            script_pubkey_source: script.into(),
        }
    }

    /// From descriptor
    pub fn with_descriptor(descriptor: DefiniteDescriptor, value: Amount) -> Self {
        Self {
            value,
            script_pubkey_source: descriptor.into(),
        }
    }

    /// Script pubkey
    pub fn script_pubkey(&self) -> ScriptBuf {
        self.script_pubkey_source.script()
    }

    /// Descriptor
    pub fn descriptor(&self) -> Option<&DefiniteDescriptor> {
        self.script_pubkey_source.descriptor()
    }

    /// Create txout.
    pub fn txout(&self) -> TxOut {
        TxOut {
            value: self.value,
            script_pubkey: self.script_pubkey_source.script(),
        }
    }
}