psbt 0.10.2

Partially signed bitcoin transaction v0-2 library (bip174, bip370, bip371)
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
141
142
143
144
145
146
147
148
149
150
151
152
153

// Wallet-level libraries for bitcoin protocol by LNP/BP Association
//
// Written in 2020-2022 by
//     Dr. Maxim Orlovsky <orlovsky@lnp-bp.org>
//
// This software is distributed without any warranty.
//
// You should have received a copy of the Apache-2.0 License
// along with this software.
// If not, see <https://opensource.org/licenses/Apache-2.0>.

use std::collections::BTreeMap;

use bitcoin::psbt::TapTree;
use bitcoin::util::bip32::KeySource;
use bitcoin::util::taproot::TapLeafHash;
use bitcoin::{secp256k1, TxOut, XOnlyPublicKey};
use bitcoin_scripts::{PubkeyScript, RedeemScript, WitnessScript};
#[cfg(feature = "serde")]
use serde_with::{hex::Hex, As, Same};

use crate::raw;
use crate::v0::OutputV0;

// TODO: Do manual serde implementation to check the deserialized values
#[derive(Clone, Eq, PartialEq, Debug, Default)]
#[derive(StrictEncode, StrictDecode)]
#[cfg_attr(
    feature = "serde",
    derive(Serialize, Deserialize),
    serde(crate = "serde_crate")
)]
pub struct Output {
    /// The index of this output. Used in error reporting.
    pub(crate) index: usize,

    /// The output's amount in satoshis.
    pub amount: u64,

    /// The script for this output, also known as the scriptPubKey.
    pub script: PubkeyScript,

    /// The redeem script for this output.
    pub redeem_script: Option<RedeemScript>,

    /// The witness script for this output.
    pub witness_script: Option<WitnessScript>,

    /// A map from public keys needed to spend this output to their
    /// corresponding master key fingerprints and derivation paths.
    #[cfg_attr(feature = "serde", serde(with = "As::<BTreeMap<Same, Same>>"))]
    pub bip32_derivation: BTreeMap<secp256k1::PublicKey, KeySource>,

    /// The internal pubkey.
    pub tap_internal_key: Option<XOnlyPublicKey>,

    /// Taproot Output tree.
    pub tap_tree: Option<TapTree>,

    /// Map of tap root x only keys to origin info and leaf hashes contained in
    /// it.
    #[cfg_attr(
        feature = "serde",
        serde(with = "As::<BTreeMap<Same, (Vec<Same>, Same)>>")
    )]
    pub tap_key_origins: BTreeMap<XOnlyPublicKey, (Vec<TapLeafHash>, KeySource)>,

    /// Proprietary key-value pairs for this output.
    #[cfg_attr(feature = "serde", serde(with = "As::<BTreeMap<Same, Hex>>"))]
    pub proprietary: BTreeMap<raw::ProprietaryKey, Vec<u8>>,

    /// Unknown key-value pairs for this output.
    #[cfg_attr(feature = "serde", serde(with = "As::<BTreeMap<Same, Hex>>"))]
    pub unknown: BTreeMap<raw::Key, Vec<u8>>,
}

impl Output {
    pub fn new(index: usize, txout: TxOut) -> Self {
        Output {
            index,
            amount: txout.value,
            script: txout.script_pubkey.into(),
            ..Output::default()
        }
    }

    pub fn with(index: usize, v0: OutputV0, txout: TxOut) -> Self {
        Output {
            index,
            amount: txout.value,
            script: txout.script_pubkey.into(),
            redeem_script: v0.redeem_script.map(Into::into),
            witness_script: v0.witness_script.map(Into::into),
            bip32_derivation: v0.bip32_derivation,
            tap_internal_key: v0.tap_internal_key,
            tap_tree: v0.tap_tree,
            tap_key_origins: v0.tap_key_origins,
            proprietary: v0.proprietary,
            unknown: v0.unknown,
        }
    }

    #[inline]
    pub fn index(&self) -> usize { self.index }

    pub fn to_txout(&self) -> TxOut {
        TxOut {
            value: self.amount,
            script_pubkey: self.script.clone().into(),
        }
    }

    pub fn into_txout(self) -> TxOut {
        TxOut {
            value: self.amount,
            script_pubkey: self.script.into(),
        }
    }

    pub fn split(self) -> (OutputV0, TxOut) {
        (
            OutputV0 {
                redeem_script: self.redeem_script.map(Into::into),
                witness_script: self.witness_script.map(Into::into),
                bip32_derivation: self.bip32_derivation,
                tap_internal_key: self.tap_internal_key,
                tap_tree: self.tap_tree,
                tap_key_origins: self.tap_key_origins,
                proprietary: self.proprietary,
                unknown: self.unknown,
            },
            TxOut {
                value: self.amount,
                script_pubkey: self.script.into(),
            },
        )
    }
}

impl From<Output> for OutputV0 {
    fn from(output: Output) -> Self {
        OutputV0 {
            redeem_script: output.redeem_script.map(Into::into),
            witness_script: output.witness_script.map(Into::into),
            bip32_derivation: output.bip32_derivation,
            tap_internal_key: output.tap_internal_key,
            tap_tree: output.tap_tree,
            tap_key_origins: output.tap_key_origins,
            proprietary: output.proprietary,
            unknown: output.unknown,
        }
    }
}