Branch data Line data Source code
1 : : // Copyright (c) 2009-present The Bitcoin Core developers
2 : : // Distributed under the MIT software license, see the accompanying
3 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 : :
5 : : #include <psbt.h>
6 : :
7 : : #include <common/types.h>
8 : : #include <node/types.h>
9 : : #include <policy/policy.h>
10 : : #include <script/signingprovider.h>
11 : : #include <util/check.h>
12 : : #include <util/strencodings.h>
13 : :
14 : : using common::PSBTError;
15 : :
16 [ - + ]: 6216 : PartiallySignedTransaction::PartiallySignedTransaction(const CMutableTransaction& tx) : tx(tx)
17 : : {
18 [ - + + - ]: 6216 : inputs.resize(tx.vin.size());
19 [ - + + - ]: 6216 : outputs.resize(tx.vout.size());
20 [ - - ]: 6216 : }
21 : :
22 : 5180 : bool PartiallySignedTransaction::IsNull() const
23 : : {
24 [ - + - - : 5180 : return !tx && inputs.empty() && outputs.empty() && unknown.empty();
- - - - ]
25 : : }
26 : :
27 : 16369 : bool PartiallySignedTransaction::Merge(const PartiallySignedTransaction& psbt)
28 : : {
29 : : // Prohibited to merge two PSBTs over different transactions
30 [ + + ]: 16369 : if (tx->GetHash() != psbt.tx->GetHash()) {
31 : : return false;
32 : : }
33 : :
34 [ - + + + ]: 47465 : for (unsigned int i = 0; i < inputs.size(); ++i) {
35 : 31714 : inputs[i].Merge(psbt.inputs[i]);
36 : : }
37 [ - + + + ]: 58967 : for (unsigned int i = 0; i < outputs.size(); ++i) {
38 : 43216 : outputs[i].Merge(psbt.outputs[i]);
39 : : }
40 [ + + ]: 22529 : for (auto& xpub_pair : psbt.m_xpubs) {
41 [ + + ]: 6778 : if (m_xpubs.count(xpub_pair.first) == 0) {
42 : 1187 : m_xpubs[xpub_pair.first] = xpub_pair.second;
43 : : } else {
44 : 5591 : m_xpubs[xpub_pair.first].insert(xpub_pair.second.begin(), xpub_pair.second.end());
45 : : }
46 : : }
47 : 15751 : unknown.insert(psbt.unknown.begin(), psbt.unknown.end());
48 : :
49 : 15751 : return true;
50 : : }
51 : :
52 : 13928 : bool PartiallySignedTransaction::AddInput(const CTxIn& txin, PSBTInput& psbtin)
53 : : {
54 [ + + ]: 13928 : if (std::find(tx->vin.begin(), tx->vin.end(), txin) != tx->vin.end()) {
55 : : return false;
56 : : }
57 : 3191 : tx->vin.push_back(txin);
58 : 3191 : psbtin.partial_sigs.clear();
59 : 3191 : psbtin.final_script_sig.clear();
60 : 3191 : psbtin.final_script_witness.SetNull();
61 : 3191 : inputs.push_back(psbtin);
62 : 3191 : return true;
63 : : }
64 : :
65 : 44509 : bool PartiallySignedTransaction::AddOutput(const CTxOut& txout, const PSBTOutput& psbtout)
66 : : {
67 : 44509 : tx->vout.push_back(txout);
68 : 44509 : outputs.push_back(psbtout);
69 : 44509 : return true;
70 : : }
71 : :
72 : 65393 : bool PartiallySignedTransaction::GetInputUTXO(CTxOut& utxo, int input_index) const
73 : : {
74 [ + + ]: 65393 : const PSBTInput& input = inputs[input_index];
75 [ + + ]: 65393 : uint32_t prevout_index = tx->vin[input_index].prevout.n;
76 [ + + ]: 65393 : if (input.non_witness_utxo) {
77 [ - + + - ]: 1121 : if (prevout_index >= input.non_witness_utxo->vout.size()) {
78 : : return false;
79 : : }
80 [ + - ]: 1121 : if (input.non_witness_utxo->GetHash() != tx->vin[input_index].prevout.hash) {
81 : : return false;
82 : : }
83 : 1121 : utxo = input.non_witness_utxo->vout[prevout_index];
84 [ + + ]: 64272 : } else if (!input.witness_utxo.IsNull()) {
85 : 33978 : utxo = input.witness_utxo;
86 : : } else {
87 : : return false;
88 : : }
89 : : return true;
90 : : }
91 : :
92 : 10869 : bool PSBTInput::IsNull() const
93 : : {
94 [ + + + + : 10904 : return !non_witness_utxo && witness_utxo.IsNull() && partial_sigs.empty() && unknown.empty() && hd_keypaths.empty() && redeem_script.empty() && witness_script.empty();
+ + + + +
+ + + + +
+ + + + ]
95 : : }
96 : :
97 : 37752 : void PSBTInput::FillSignatureData(SignatureData& sigdata) const
98 : : {
99 [ + + + + ]: 43575 : if (!final_script_sig.empty()) {
100 : 6523 : sigdata.scriptSig = final_script_sig;
101 : 6523 : sigdata.complete = true;
102 : : }
103 [ + + ]: 37752 : if (!final_script_witness.IsNull()) {
104 : 605 : sigdata.scriptWitness = final_script_witness;
105 : 605 : sigdata.complete = true;
106 : : }
107 [ + + ]: 37752 : if (sigdata.complete) {
108 : : return;
109 : : }
110 : :
111 : 30631 : sigdata.signatures.insert(partial_sigs.begin(), partial_sigs.end());
112 [ + + + + ]: 30985 : if (!redeem_script.empty()) {
113 : 919 : sigdata.redeem_script = redeem_script;
114 : : }
115 [ + + + + ]: 31163 : if (!witness_script.empty()) {
116 : 1376 : sigdata.witness_script = witness_script;
117 : : }
118 [ + + ]: 34408 : for (const auto& key_pair : hd_keypaths) {
119 : 3777 : sigdata.misc_pubkeys.emplace(key_pair.first.GetID(), key_pair);
120 : : }
121 [ + + ]: 30631 : if (!m_tap_key_sig.empty()) {
122 : 687 : sigdata.taproot_key_path_sig = m_tap_key_sig;
123 : : }
124 [ + + ]: 35203 : for (const auto& [pubkey_leaf, sig] : m_tap_script_sigs) {
125 : 4572 : sigdata.taproot_script_sigs.emplace(pubkey_leaf, sig);
126 : : }
127 [ + + ]: 61262 : if (!m_tap_internal_key.IsNull()) {
128 : 308 : sigdata.tr_spenddata.internal_key = m_tap_internal_key;
129 : : }
130 [ + + ]: 61262 : if (!m_tap_merkle_root.IsNull()) {
131 : 245 : sigdata.tr_spenddata.merkle_root = m_tap_merkle_root;
132 : : }
133 [ + + ]: 48003 : for (const auto& [leaf_script, control_block] : m_tap_scripts) {
134 : 17372 : sigdata.tr_spenddata.scripts.emplace(leaf_script, control_block);
135 : : }
136 [ + + ]: 33441 : for (const auto& [pubkey, leaf_origin] : m_tap_bip32_paths) {
137 : 2810 : sigdata.taproot_misc_pubkeys.emplace(pubkey, leaf_origin);
138 : 2810 : sigdata.tap_pubkeys.emplace(Hash160(pubkey), pubkey);
139 : : }
140 [ + + ]: 32725 : for (const auto& [hash, preimage] : ripemd160_preimages) {
141 [ + - ]: 4188 : sigdata.ripemd160_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage);
142 : : }
143 [ + + ]: 41041 : for (const auto& [hash, preimage] : sha256_preimages) {
144 [ + - ]: 20820 : sigdata.sha256_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage);
145 : : }
146 [ + + ]: 35874 : for (const auto& [hash, preimage] : hash160_preimages) {
147 [ + - ]: 10486 : sigdata.hash160_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage);
148 : : }
149 [ + + ]: 33905 : for (const auto& [hash, preimage] : hash256_preimages) {
150 [ + - ]: 6548 : sigdata.hash256_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage);
151 : : }
152 : 30631 : sigdata.musig2_pubkeys.insert(m_musig2_participants.begin(), m_musig2_participants.end());
153 [ + + ]: 32030 : for (const auto& [agg_key_lh, pubnonces] : m_musig2_pubnonces) {
154 : 1399 : sigdata.musig2_pubnonces[agg_key_lh].insert(pubnonces.begin(), pubnonces.end());
155 : : }
156 [ + + ]: 32480 : for (const auto& [agg_key_lh, psigs] : m_musig2_partial_sigs) {
157 : 1849 : sigdata.musig2_partial_sigs[agg_key_lh].insert(psigs.begin(), psigs.end());
158 : : }
159 : : }
160 : :
161 : 7287 : void PSBTInput::FromSignatureData(const SignatureData& sigdata)
162 : : {
163 [ + + ]: 7287 : if (sigdata.complete) {
164 : 763 : partial_sigs.clear();
165 : 763 : hd_keypaths.clear();
166 : 763 : redeem_script.clear();
167 : 763 : witness_script.clear();
168 : :
169 [ + + + + ]: 1025 : if (!sigdata.scriptSig.empty()) {
170 : 377 : final_script_sig = sigdata.scriptSig;
171 : : }
172 [ + + ]: 763 : if (!sigdata.scriptWitness.IsNull()) {
173 : 419 : final_script_witness = sigdata.scriptWitness;
174 : : }
175 : 763 : return;
176 : : }
177 : :
178 : 6524 : partial_sigs.insert(sigdata.signatures.begin(), sigdata.signatures.end());
179 [ + + + + : 6695 : if (redeem_script.empty() && !sigdata.redeem_script.empty()) {
+ + + + ]
180 : 11 : redeem_script = sigdata.redeem_script;
181 : : }
182 [ + + + + : 6667 : if (witness_script.empty() && !sigdata.witness_script.empty()) {
- + + + ]
183 : 2 : witness_script = sigdata.witness_script;
184 : : }
185 [ + + ]: 9212 : for (const auto& entry : sigdata.misc_pubkeys) {
186 : 2688 : hd_keypaths.emplace(entry.second);
187 : : }
188 [ + + ]: 6524 : if (!sigdata.taproot_key_path_sig.empty()) {
189 : 337 : m_tap_key_sig = sigdata.taproot_key_path_sig;
190 : : }
191 [ + + ]: 6783 : for (const auto& [pubkey_leaf, sig] : sigdata.taproot_script_sigs) {
192 : 259 : m_tap_script_sigs.emplace(pubkey_leaf, sig);
193 : : }
194 [ + + ]: 13048 : if (!sigdata.tr_spenddata.internal_key.IsNull()) {
195 : 25 : m_tap_internal_key = sigdata.tr_spenddata.internal_key;
196 : : }
197 [ + + ]: 13048 : if (!sigdata.tr_spenddata.merkle_root.IsNull()) {
198 : 104 : m_tap_merkle_root = sigdata.tr_spenddata.merkle_root;
199 : : }
200 [ + + ]: 10678 : for (const auto& [leaf_script, control_block] : sigdata.tr_spenddata.scripts) {
201 : 4154 : m_tap_scripts.emplace(leaf_script, control_block);
202 : : }
203 [ + + ]: 7160 : for (const auto& [pubkey, leaf_origin] : sigdata.taproot_misc_pubkeys) {
204 : 636 : m_tap_bip32_paths.emplace(pubkey, leaf_origin);
205 : : }
206 : 6524 : m_musig2_participants.insert(sigdata.musig2_pubkeys.begin(), sigdata.musig2_pubkeys.end());
207 [ + + ]: 6605 : for (const auto& [agg_key_lh, pubnonces] : sigdata.musig2_pubnonces) {
208 : 81 : m_musig2_pubnonces[agg_key_lh].insert(pubnonces.begin(), pubnonces.end());
209 : : }
210 [ + + ]: 6526 : for (const auto& [agg_key_lh, psigs] : sigdata.musig2_partial_sigs) {
211 : 2 : m_musig2_partial_sigs[agg_key_lh].insert(psigs.begin(), psigs.end());
212 : : }
213 : : }
214 : :
215 : 31714 : void PSBTInput::Merge(const PSBTInput& input)
216 : : {
217 [ + + + + ]: 31714 : if (!non_witness_utxo && input.non_witness_utxo) non_witness_utxo = input.non_witness_utxo;
218 [ + + + + ]: 31714 : if (witness_utxo.IsNull() && !input.witness_utxo.IsNull()) {
219 : 125 : witness_utxo = input.witness_utxo;
220 : : }
221 : :
222 : 31714 : partial_sigs.insert(input.partial_sigs.begin(), input.partial_sigs.end());
223 : 31714 : ripemd160_preimages.insert(input.ripemd160_preimages.begin(), input.ripemd160_preimages.end());
224 : 31714 : sha256_preimages.insert(input.sha256_preimages.begin(), input.sha256_preimages.end());
225 : 31714 : hash160_preimages.insert(input.hash160_preimages.begin(), input.hash160_preimages.end());
226 : 31714 : hash256_preimages.insert(input.hash256_preimages.begin(), input.hash256_preimages.end());
227 : 31714 : hd_keypaths.insert(input.hd_keypaths.begin(), input.hd_keypaths.end());
228 : 31714 : unknown.insert(input.unknown.begin(), input.unknown.end());
229 : 31714 : m_tap_script_sigs.insert(input.m_tap_script_sigs.begin(), input.m_tap_script_sigs.end());
230 : 31714 : m_tap_scripts.insert(input.m_tap_scripts.begin(), input.m_tap_scripts.end());
231 : 31714 : m_tap_bip32_paths.insert(input.m_tap_bip32_paths.begin(), input.m_tap_bip32_paths.end());
232 : :
233 [ + + + + : 32083 : if (redeem_script.empty() && !input.redeem_script.empty()) redeem_script = input.redeem_script;
+ + + + ]
234 [ + + + + : 32124 : if (witness_script.empty() && !input.witness_script.empty()) witness_script = input.witness_script;
+ + + + ]
235 [ + + + + : 35108 : if (final_script_sig.empty() && !input.final_script_sig.empty()) final_script_sig = input.final_script_sig;
+ + + + ]
236 [ + + + + ]: 31714 : if (final_script_witness.IsNull() && !input.final_script_witness.IsNull()) final_script_witness = input.final_script_witness;
237 [ + + + + ]: 31714 : if (m_tap_key_sig.empty() && !input.m_tap_key_sig.empty()) m_tap_key_sig = input.m_tap_key_sig;
238 [ + + + + ]: 92664 : if (m_tap_internal_key.IsNull() && !input.m_tap_internal_key.IsNull()) m_tap_internal_key = input.m_tap_internal_key;
239 [ + + + + ]: 93983 : if (m_tap_merkle_root.IsNull() && !input.m_tap_merkle_root.IsNull()) m_tap_merkle_root = input.m_tap_merkle_root;
240 : 31714 : m_musig2_participants.insert(input.m_musig2_participants.begin(), input.m_musig2_participants.end());
241 [ + + ]: 32646 : for (const auto& [agg_key_lh, pubnonces] : input.m_musig2_pubnonces) {
242 : 932 : m_musig2_pubnonces[agg_key_lh].insert(pubnonces.begin(), pubnonces.end());
243 : : }
244 [ + + ]: 32900 : for (const auto& [agg_key_lh, psigs] : input.m_musig2_partial_sigs) {
245 : 1186 : m_musig2_partial_sigs[agg_key_lh].insert(psigs.begin(), psigs.end());
246 : : }
247 : 31714 : }
248 : :
249 : 1452 : void PSBTOutput::FillSignatureData(SignatureData& sigdata) const
250 : : {
251 [ + + + + ]: 1488 : if (!redeem_script.empty()) {
252 : 89 : sigdata.redeem_script = redeem_script;
253 : : }
254 [ + + + + ]: 1489 : if (!witness_script.empty()) {
255 : 73 : sigdata.witness_script = witness_script;
256 : : }
257 [ + + ]: 1963 : for (const auto& key_pair : hd_keypaths) {
258 : 511 : sigdata.misc_pubkeys.emplace(key_pair.first.GetID(), key_pair);
259 : : }
260 [ + + + + ]: 1452 : if (!m_tap_tree.empty() && m_tap_internal_key.IsFullyValid()) {
261 : 41 : TaprootBuilder builder;
262 [ - + + + ]: 159 : for (const auto& [depth, leaf_ver, script] : m_tap_tree) {
263 [ - + + - ]: 118 : builder.Add((int)depth, script, (int)leaf_ver, /*track=*/true);
264 : : }
265 [ - + ]: 41 : assert(builder.IsComplete());
266 [ + - ]: 41 : builder.Finalize(m_tap_internal_key);
267 [ + - ]: 41 : TaprootSpendData spenddata = builder.GetSpendData();
268 : :
269 : 41 : sigdata.tr_spenddata.internal_key = m_tap_internal_key;
270 [ + - + - ]: 82 : sigdata.tr_spenddata.Merge(spenddata);
271 : 41 : }
272 [ + + ]: 1689 : for (const auto& [pubkey, leaf_origin] : m_tap_bip32_paths) {
273 : 237 : sigdata.taproot_misc_pubkeys.emplace(pubkey, leaf_origin);
274 : 237 : sigdata.tap_pubkeys.emplace(Hash160(pubkey), pubkey);
275 : : }
276 : 1452 : sigdata.musig2_pubkeys.insert(m_musig2_participants.begin(), m_musig2_participants.end());
277 : 1452 : }
278 : :
279 : 1452 : void PSBTOutput::FromSignatureData(const SignatureData& sigdata)
280 : : {
281 [ + + + + : 1488 : if (redeem_script.empty() && !sigdata.redeem_script.empty()) {
- + - + ]
282 : 0 : redeem_script = sigdata.redeem_script;
283 : : }
284 [ + + + + : 1489 : if (witness_script.empty() && !sigdata.witness_script.empty()) {
- + - + ]
285 : 0 : witness_script = sigdata.witness_script;
286 : : }
287 [ + + ]: 1965 : for (const auto& entry : sigdata.misc_pubkeys) {
288 : 513 : hd_keypaths.emplace(entry.second);
289 : : }
290 [ + + ]: 2904 : if (!sigdata.tr_spenddata.internal_key.IsNull()) {
291 : 41 : m_tap_internal_key = sigdata.tr_spenddata.internal_key;
292 : : }
293 [ - + - - ]: 1452 : if (sigdata.tr_builder.has_value() && sigdata.tr_builder->HasScripts()) {
294 : 0 : m_tap_tree = sigdata.tr_builder->GetTreeTuples();
295 : : }
296 [ + + ]: 1689 : for (const auto& [pubkey, leaf_origin] : sigdata.taproot_misc_pubkeys) {
297 : 237 : m_tap_bip32_paths.emplace(pubkey, leaf_origin);
298 : : }
299 : 1452 : m_musig2_participants.insert(sigdata.musig2_pubkeys.begin(), sigdata.musig2_pubkeys.end());
300 : 1452 : }
301 : :
302 : 14948 : bool PSBTOutput::IsNull() const
303 : : {
304 [ + + + + : 15765 : return redeem_script.empty() && witness_script.empty() && hd_keypaths.empty() && unknown.empty();
+ + + + +
+ + + ]
305 : : }
306 : :
307 : 43216 : void PSBTOutput::Merge(const PSBTOutput& output)
308 : : {
309 : 43216 : hd_keypaths.insert(output.hd_keypaths.begin(), output.hd_keypaths.end());
310 : 43216 : unknown.insert(output.unknown.begin(), output.unknown.end());
311 : 43216 : m_tap_bip32_paths.insert(output.m_tap_bip32_paths.begin(), output.m_tap_bip32_paths.end());
312 : :
313 [ + + + + : 44598 : if (redeem_script.empty() && !output.redeem_script.empty()) redeem_script = output.redeem_script;
+ + + + ]
314 [ + + + + : 45073 : if (witness_script.empty() && !output.witness_script.empty()) witness_script = output.witness_script;
+ + + + ]
315 [ + + + + ]: 128554 : if (m_tap_internal_key.IsNull() && !output.m_tap_internal_key.IsNull()) m_tap_internal_key = output.m_tap_internal_key;
316 [ + + + + ]: 43216 : if (m_tap_tree.empty() && !output.m_tap_tree.empty()) m_tap_tree = output.m_tap_tree;
317 : 43216 : m_musig2_participants.insert(output.m_musig2_participants.begin(), output.m_musig2_participants.end());
318 : 43216 : }
319 : :
320 : 27064 : bool PSBTInputSigned(const PSBTInput& input)
321 : : {
322 [ + + + + : 30154 : return !input.final_script_sig.empty() || !input.final_script_witness.IsNull();
+ + ]
323 : : }
324 : :
325 : 50988 : bool PSBTInputSignedAndVerified(const PartiallySignedTransaction psbt, unsigned int input_index, const PrecomputedTransactionData* txdata)
326 : : {
327 : 50988 : CTxOut utxo;
328 [ - + - + ]: 50988 : assert(psbt.inputs.size() >= input_index);
329 [ + + ]: 50988 : const PSBTInput& input = psbt.inputs[input_index];
330 : :
331 [ + + ]: 50988 : if (input.non_witness_utxo) {
332 : : // If we're taking our information from a non-witness UTXO, verify that it matches the prevout.
333 [ - + ]: 888 : COutPoint prevout = psbt.tx->vin[input_index].prevout;
334 [ - + + - ]: 888 : if (prevout.n >= input.non_witness_utxo->vout.size()) {
335 : : return false;
336 : : }
337 [ + - ]: 888 : if (input.non_witness_utxo->GetHash() != prevout.hash) {
338 : : return false;
339 : : }
340 : 888 : utxo = input.non_witness_utxo->vout[prevout.n];
341 [ + + ]: 50100 : } else if (!input.witness_utxo.IsNull()) {
342 : 27503 : utxo = input.witness_utxo;
343 : : } else {
344 : : return false;
345 : : }
346 : :
347 [ + + ]: 28391 : if (txdata) {
348 [ + - ]: 25709 : return VerifyScript(input.final_script_sig, utxo.scriptPubKey, &input.final_script_witness, STANDARD_SCRIPT_VERIFY_FLAGS, MutableTransactionSignatureChecker{&(*psbt.tx), input_index, utxo.nValue, *txdata, MissingDataBehavior::FAIL});
349 : : } else {
350 [ + - ]: 2682 : return VerifyScript(input.final_script_sig, utxo.scriptPubKey, &input.final_script_witness, STANDARD_SCRIPT_VERIFY_FLAGS, MutableTransactionSignatureChecker{&(*psbt.tx), input_index, utxo.nValue, MissingDataBehavior::FAIL});
351 : : }
352 : 50988 : }
353 : :
354 : 5180 : size_t CountPSBTUnsignedInputs(const PartiallySignedTransaction& psbt) {
355 : 5180 : size_t count = 0;
356 [ + + ]: 16049 : for (const auto& input : psbt.inputs) {
357 [ + + ]: 10869 : if (!PSBTInputSigned(input)) {
358 : 8961 : count++;
359 : : }
360 : : }
361 : :
362 : 5180 : return count;
363 : : }
364 : :
365 : 1452 : void UpdatePSBTOutput(const SigningProvider& provider, PartiallySignedTransaction& psbt, int index)
366 : : {
367 [ - + ]: 1452 : CMutableTransaction& tx = *Assert(psbt.tx);
368 : 1452 : const CTxOut& out = tx.vout.at(index);
369 : 1452 : PSBTOutput& psbt_out = psbt.outputs.at(index);
370 : :
371 : : // Fill a SignatureData with output info
372 : 1452 : SignatureData sigdata;
373 [ + - ]: 1452 : psbt_out.FillSignatureData(sigdata);
374 : :
375 : : // Construct a would-be spend of this output, to update sigdata with.
376 : : // Note that ProduceSignature is used to fill in metadata (not actual signatures),
377 : : // so provider does not need to provide any private keys (it can be a HidingSigningProvider).
378 [ + - ]: 1452 : MutableTransactionSignatureCreator creator(tx, /*input_idx=*/0, out.nValue, SIGHASH_ALL);
379 [ + - ]: 1452 : ProduceSignature(provider, creator, out.scriptPubKey, sigdata);
380 : :
381 : : // Put redeem_script, witness_script, key paths, into PSBTOutput.
382 [ + - ]: 1452 : psbt_out.FromSignatureData(sigdata);
383 : 1452 : }
384 : :
385 : 23589 : PrecomputedTransactionData PrecomputePSBTData(const PartiallySignedTransaction& psbt)
386 : : {
387 [ - + ]: 23589 : const CMutableTransaction& tx = *psbt.tx;
388 : 23589 : bool have_all_spent_outputs = true;
389 [ - + ]: 23589 : std::vector<CTxOut> utxos(tx.vin.size());
390 [ - + + + ]: 64256 : for (size_t idx = 0; idx < tx.vin.size(); ++idx) {
391 [ + - + + ]: 40667 : if (!psbt.GetInputUTXO(utxos[idx], idx)) have_all_spent_outputs = false;
392 : : }
393 : 23589 : PrecomputedTransactionData txdata;
394 [ + + ]: 23589 : if (have_all_spent_outputs) {
395 [ + - ]: 16562 : txdata.Init(tx, std::move(utxos), true);
396 : : } else {
397 [ + - ]: 7027 : txdata.Init(tx, {}, true);
398 : : }
399 : 23589 : return txdata;
400 : 23589 : }
401 : :
402 : 38936 : PSBTError SignPSBTInput(const SigningProvider& provider, PartiallySignedTransaction& psbt, int index, const PrecomputedTransactionData* txdata, std::optional<int> sighash, SignatureData* out_sigdata, bool finalize)
403 : : {
404 : 38936 : PSBTInput& input = psbt.inputs.at(index);
405 : 38936 : const CMutableTransaction& tx = *psbt.tx;
406 : :
407 [ + - + + ]: 38936 : if (PSBTInputSignedAndVerified(psbt, index, txdata)) {
408 : : return PSBTError::OK;
409 : : }
410 : :
411 : : // Fill SignatureData with input info
412 : 37752 : SignatureData sigdata;
413 [ + - ]: 37752 : input.FillSignatureData(sigdata);
414 : :
415 : : // Get UTXO
416 : 37752 : bool require_witness_sig = false;
417 : 37752 : CTxOut utxo;
418 : :
419 [ + + ]: 37752 : if (input.non_witness_utxo) {
420 : : // If we're taking our information from a non-witness UTXO, verify that it matches the prevout.
421 [ - + ]: 699 : COutPoint prevout = tx.vin[index].prevout;
422 [ - + + - ]: 699 : if (prevout.n >= input.non_witness_utxo->vout.size()) {
423 : : return PSBTError::MISSING_INPUTS;
424 : : }
425 [ + - ]: 699 : if (input.non_witness_utxo->GetHash() != prevout.hash) {
426 : : return PSBTError::MISSING_INPUTS;
427 : : }
428 : 699 : utxo = input.non_witness_utxo->vout[prevout.n];
429 [ + + ]: 37053 : } else if (!input.witness_utxo.IsNull()) {
430 : 20236 : utxo = input.witness_utxo;
431 : : // When we're taking our information from a witness UTXO, we can't verify it is actually data from
432 : : // the output being spent. This is safe in case a witness signature is produced (which includes this
433 : : // information directly in the hash), but not for non-witness signatures. Remember that we require
434 : : // a witness signature in this situation.
435 : 20236 : require_witness_sig = true;
436 : : } else {
437 : : return PSBTError::MISSING_INPUTS;
438 : : }
439 : :
440 : : // Get the sighash type
441 : : // If both the field and the parameter are provided, they must match
442 : : // If only the parameter is provided, use it and add it to the PSBT if it is other than SIGHASH_DEFAULT
443 : : // for all input types, and not SIGHASH_ALL for non-taproot input types.
444 : : // If neither are provided, use SIGHASH_DEFAULT if it is taproot, and SIGHASH_ALL for everything else.
445 [ + + + - : 37140 : if (!sighash) sighash = utxo.scriptPubKey.IsPayToTaproot() ? SIGHASH_DEFAULT : SIGHASH_ALL;
+ + ]
446 [ - + ]: 20935 : Assert(sighash.has_value());
447 : : // For user safety, the desired sighash must be provided if the PSBT wants something other than the default set in the previous line.
448 [ + + + - ]: 58687 : if (input.sighash_type && input.sighash_type != sighash) {
449 : : return PSBTError::SIGHASH_MISMATCH;
450 : : }
451 : : // Set the PSBT sighash field when sighash is not DEFAULT or ALL
452 : : // DEFAULT is allowed for non-taproot inputs since DEFAULT may be passed for them (e.g. the psbt being signed also has taproot inputs)
453 : : // Note that signing already aliases DEFAULT to ALL for non-taproot inputs.
454 [ + - + + : 20869 : if (utxo.scriptPubKey.IsPayToTaproot() ? sighash != SIGHASH_DEFAULT :
+ - ]
455 [ + - + - ]: 34981 : (sighash != SIGHASH_DEFAULT && sighash != SIGHASH_ALL)) {
456 : 1267 : input.sighash_type = sighash;
457 : : }
458 : :
459 : : // Check all existing signatures use the sighash type
460 [ + - ]: 20869 : if (sighash == SIGHASH_DEFAULT) {
461 [ + + - + : 3430 : if (!input.m_tap_key_sig.empty() && input.m_tap_key_sig.size() != 64) {
+ + ]
462 : : return PSBTError::SIGHASH_MISMATCH;
463 : : }
464 [ - + + + ]: 3614 : for (const auto& [_, sig] : input.m_tap_script_sigs) {
465 [ - + + + ]: 257 : if (sig.size() != 64) return PSBTError::SIGHASH_MISMATCH;
466 : : }
467 : : } else {
468 [ + + - + : 17439 : if (!input.m_tap_key_sig.empty() && (input.m_tap_key_sig.size() != 65 || input.m_tap_key_sig.back() != *sighash)) {
+ + + + ]
469 : : return PSBTError::SIGHASH_MISMATCH;
470 : : }
471 [ - + + + ]: 17423 : for (const auto& [_, sig] : input.m_tap_script_sigs) {
472 [ - + + + : 827 : if (sig.size() != 65 || sig.back() != *sighash) return PSBTError::SIGHASH_MISMATCH;
+ + ]
473 : : }
474 [ + + + + ]: 18521 : for (const auto& [_, sig] : input.partial_sigs) {
475 [ + + ]: 1948 : if (sig.second.back() != *sighash) return PSBTError::SIGHASH_MISMATCH;
476 : : }
477 : : }
478 : :
479 : 19930 : sigdata.witness = false;
480 : 19930 : bool sig_complete;
481 [ + + ]: 19930 : if (txdata == nullptr) {
482 [ + - ]: 2362 : sig_complete = ProduceSignature(provider, DUMMY_SIGNATURE_CREATOR, utxo.scriptPubKey, sigdata);
483 : : } else {
484 [ + - ]: 17568 : MutableTransactionSignatureCreator creator(tx, index, utxo.nValue, txdata, *sighash);
485 [ + - ]: 17568 : sig_complete = ProduceSignature(provider, creator, utxo.scriptPubKey, sigdata);
486 : 17568 : }
487 : : // Verify that a witness signature was produced in case one was required.
488 [ + + + + ]: 19930 : if (require_witness_sig && !sigdata.witness) return PSBTError::INCOMPLETE;
489 : :
490 : : // If we are not finalizing, set sigdata.complete to false to not set the scriptWitness
491 [ + + - + ]: 7287 : if (!finalize && sigdata.complete) sigdata.complete = false;
492 : :
493 [ + - ]: 7287 : input.FromSignatureData(sigdata);
494 : :
495 : : // If we have a witness signature, put a witness UTXO.
496 [ + + ]: 7287 : if (sigdata.witness) {
497 : 6865 : input.witness_utxo = utxo;
498 : : // We can remove the non_witness_utxo if and only if there are no non-segwit or segwit v0
499 : : // inputs in this transaction. Since this requires inspecting the entire transaction, this
500 : : // is something for the caller to deal with (i.e. FillPSBT).
501 : : }
502 : :
503 : : // Fill in the missing info
504 [ + + ]: 7287 : if (out_sigdata) {
505 [ + - ]: 2165 : out_sigdata->missing_pubkeys = sigdata.missing_pubkeys;
506 [ + - ]: 2165 : out_sigdata->missing_sigs = sigdata.missing_sigs;
507 : 2165 : out_sigdata->missing_redeem_script = sigdata.missing_redeem_script;
508 : 2165 : out_sigdata->missing_witness_script = sigdata.missing_witness_script;
509 : : }
510 : :
511 [ + + ]: 7287 : return sig_complete ? PSBTError::OK : PSBTError::INCOMPLETE;
512 : 37752 : }
513 : :
514 : 406 : void RemoveUnnecessaryTransactions(PartiallySignedTransaction& psbtx)
515 : : {
516 : : // Figure out if any non_witness_utxos should be dropped
517 : 406 : std::vector<unsigned int> to_drop;
518 [ - + + + ]: 663 : for (unsigned int i = 0; i < psbtx.inputs.size(); ++i) {
519 [ + - ]: 508 : const auto& input = psbtx.inputs.at(i);
520 : 508 : int wit_ver;
521 : 508 : std::vector<unsigned char> wit_prog;
522 [ + + + - : 508 : if (input.witness_utxo.IsNull() || !input.witness_utxo.scriptPubKey.IsWitnessProgram(wit_ver, wit_prog)) {
+ + ]
523 : : // There's a non-segwit input, so we cannot drop any non_witness_utxos
524 [ - + ]: 245 : to_drop.clear();
525 : : break;
526 : : }
527 [ + + ]: 263 : if (wit_ver == 0) {
528 : : // Segwit v0, so we cannot drop any non_witness_utxos
529 [ - + ]: 6 : to_drop.clear();
530 : : break;
531 : : }
532 : : // non_witness_utxos cannot be dropped if the sighash type includes SIGHASH_ANYONECANPAY
533 : : // Since callers should have called SignPSBTInput which updates the sighash type in the PSBT, we only
534 : : // need to look at that field. If it is not present, then we can assume SIGHASH_DEFAULT or SIGHASH_ALL.
535 [ - + - - ]: 257 : if (input.sighash_type != std::nullopt && (*input.sighash_type & 0x80) == SIGHASH_ANYONECANPAY) {
536 [ - - ]: 251 : to_drop.clear();
537 : : break;
538 : : }
539 : :
540 [ - + ]: 257 : if (input.non_witness_utxo) {
541 [ # # ]: 0 : to_drop.push_back(i);
542 : : }
543 : 508 : }
544 : :
545 : : // Drop the non_witness_utxos that we can drop
546 [ - + ]: 406 : for (unsigned int i : to_drop) {
547 [ # # # # ]: 0 : psbtx.inputs.at(i).non_witness_utxo = nullptr;
548 : : }
549 : 406 : }
550 : :
551 : 10705 : bool FinalizePSBT(PartiallySignedTransaction& psbtx)
552 : : {
553 : : // Finalize input signatures -- in case we have partial signatures that add up to a complete
554 : : // signature, but have not combined them yet (e.g. because the combiner that created this
555 : : // PartiallySignedTransaction did not understand them), this will combine them into a final
556 : : // script.
557 : 10705 : bool complete = true;
558 : 10705 : const PrecomputedTransactionData txdata = PrecomputePSBTData(psbtx);
559 [ - + + + ]: 33209 : for (unsigned int i = 0; i < psbtx.tx->vin.size(); ++i) {
560 [ + - ]: 22504 : PSBTInput& input = psbtx.inputs.at(i);
561 [ + - ]: 22504 : complete &= (SignPSBTInput(DUMMY_SIGNING_PROVIDER, psbtx, i, &txdata, input.sighash_type, nullptr, true) == PSBTError::OK);
562 : : }
563 : :
564 : 10705 : return complete;
565 : 10705 : }
566 : :
567 : 5525 : bool FinalizeAndExtractPSBT(PartiallySignedTransaction& psbtx, CMutableTransaction& result)
568 : : {
569 : : // It's not safe to extract a PSBT that isn't finalized, and there's no easy way to check
570 : : // whether a PSBT is finalized without finalizing it, so we just do this.
571 [ + + ]: 5525 : if (!FinalizePSBT(psbtx)) {
572 : : return false;
573 : : }
574 : :
575 : 1060 : result = *psbtx.tx;
576 [ - + + + ]: 1510 : for (unsigned int i = 0; i < result.vin.size(); ++i) {
577 : 450 : result.vin[i].scriptSig = psbtx.inputs[i].final_script_sig;
578 : 450 : result.vin[i].scriptWitness = psbtx.inputs[i].final_script_witness;
579 : : }
580 : : return true;
581 : : }
582 : :
583 : 5706 : bool CombinePSBTs(PartiallySignedTransaction& out, const std::vector<PartiallySignedTransaction>& psbtxs)
584 : : {
585 : 5706 : out = psbtxs[0]; // Copy the first one
586 : :
587 : : // Merge
588 [ + + ]: 16530 : for (auto it = std::next(psbtxs.begin()); it != psbtxs.end(); ++it) {
589 [ + + ]: 11189 : if (!out.Merge(*it)) {
590 : : return false;
591 : : }
592 : : }
593 : : return true;
594 : : }
595 : :
596 : 16977 : std::string PSBTRoleName(PSBTRole role) {
597 [ + + + + : 16977 : switch (role) {
+ - ]
598 : 2338 : case PSBTRole::CREATOR: return "creator";
599 : 13490 : case PSBTRole::UPDATER: return "updater";
600 : 312 : case PSBTRole::SIGNER: return "signer";
601 : 131 : case PSBTRole::FINALIZER: return "finalizer";
602 : 706 : case PSBTRole::EXTRACTOR: return "extractor";
603 : : // no default case, so the compiler can warn about missing cases
604 : : }
605 : 0 : assert(false);
606 : : }
607 : :
608 : 22563 : bool DecodeBase64PSBT(PartiallySignedTransaction& psbt, const std::string& base64_tx, std::string& error)
609 : : {
610 [ - + ]: 22563 : auto tx_data = DecodeBase64(base64_tx);
611 [ + + ]: 22563 : if (!tx_data) {
612 [ + - ]: 22563 : error = "invalid base64";
613 : : return false;
614 : : }
615 [ + - ]: 22445 : return DecodeRawPSBT(psbt, MakeByteSpan(*tx_data), error);
616 : 22563 : }
617 : :
618 : 33845 : bool DecodeRawPSBT(PartiallySignedTransaction& psbt, std::span<const std::byte> tx_data, std::string& error)
619 : : {
620 : 33845 : DataStream ss_data{tx_data};
621 : 33845 : try {
622 [ + + ]: 33845 : ss_data >> psbt;
623 [ - + + + ]: 26803 : if (!ss_data.empty()) {
624 [ + - ]: 33845 : error = "extra data after PSBT";
625 : : return false;
626 : : }
627 [ - + ]: 7042 : } catch (const std::exception& e) {
628 [ + - ]: 7042 : error = e.what();
629 : 7042 : return false;
630 : 7042 : }
631 : : return true;
632 : 33845 : }
633 : :
634 : 62681 : uint32_t PartiallySignedTransaction::GetVersion() const
635 : : {
636 [ + + ]: 62681 : if (m_version != std::nullopt) {
637 : 164 : return *m_version;
638 : : }
639 : : return 0;
640 : : }
|
