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 [ - + ]: 399 : PartiallySignedTransaction::PartiallySignedTransaction(const CMutableTransaction& tx) : tx(tx)
17 : : {
18 [ - + + - ]: 399 : inputs.resize(tx.vin.size());
19 [ - + + - ]: 399 : outputs.resize(tx.vout.size());
20 [ - - ]: 399 : }
21 : :
22 : 0 : bool PartiallySignedTransaction::IsNull() const
23 : : {
24 [ # # # # : 0 : return !tx && inputs.empty() && outputs.empty() && unknown.empty();
# # # # ]
25 : : }
26 : :
27 : 72 : bool PartiallySignedTransaction::Merge(const PartiallySignedTransaction& psbt)
28 : : {
29 : : // Prohibited to merge two PSBTs over different transactions
30 [ + + ]: 72 : if (tx->GetHash() != psbt.tx->GetHash()) {
31 : : return false;
32 : : }
33 : :
34 [ - + + + ]: 144 : for (unsigned int i = 0; i < inputs.size(); ++i) {
35 : 73 : inputs[i].Merge(psbt.inputs[i]);
36 : : }
37 [ - + + + ]: 209 : for (unsigned int i = 0; i < outputs.size(); ++i) {
38 : 138 : outputs[i].Merge(psbt.outputs[i]);
39 : : }
40 [ - + ]: 71 : for (auto& xpub_pair : psbt.m_xpubs) {
41 [ # # ]: 0 : if (m_xpubs.count(xpub_pair.first) == 0) {
42 : 0 : m_xpubs[xpub_pair.first] = xpub_pair.second;
43 : : } else {
44 : 0 : m_xpubs[xpub_pair.first].insert(xpub_pair.second.begin(), xpub_pair.second.end());
45 : : }
46 : : }
47 : 71 : unknown.insert(psbt.unknown.begin(), psbt.unknown.end());
48 : :
49 : 71 : return true;
50 : : }
51 : :
52 : 18 : bool PartiallySignedTransaction::AddInput(const CTxIn& txin, PSBTInput& psbtin)
53 : : {
54 [ + + ]: 18 : if (std::find(tx->vin.begin(), tx->vin.end(), txin) != tx->vin.end()) {
55 : : return false;
56 : : }
57 : 17 : tx->vin.push_back(txin);
58 : 17 : psbtin.partial_sigs.clear();
59 : 17 : psbtin.final_script_sig.clear();
60 : 17 : psbtin.final_script_witness.SetNull();
61 : 17 : inputs.push_back(psbtin);
62 : 17 : return true;
63 : : }
64 : :
65 : 9 : bool PartiallySignedTransaction::AddOutput(const CTxOut& txout, const PSBTOutput& psbtout)
66 : : {
67 : 9 : tx->vout.push_back(txout);
68 : 9 : outputs.push_back(psbtout);
69 : 9 : return true;
70 : : }
71 : :
72 : 5237 : bool PartiallySignedTransaction::GetInputUTXO(CTxOut& utxo, int input_index) const
73 : : {
74 [ + + ]: 5237 : const PSBTInput& input = inputs[input_index];
75 [ + + ]: 5237 : uint32_t prevout_index = tx->vin[input_index].prevout.n;
76 [ + + ]: 5237 : if (input.non_witness_utxo) {
77 [ - + + + ]: 4594 : if (prevout_index >= input.non_witness_utxo->vout.size()) {
78 : : return false;
79 : : }
80 [ + - ]: 4593 : if (input.non_witness_utxo->GetHash() != tx->vin[input_index].prevout.hash) {
81 : : return false;
82 : : }
83 : 4593 : utxo = input.non_witness_utxo->vout[prevout_index];
84 [ + + ]: 643 : } else if (!input.witness_utxo.IsNull()) {
85 : 615 : utxo = input.witness_utxo;
86 : : } else {
87 : : return false;
88 : : }
89 : : return true;
90 : : }
91 : :
92 : 0 : bool PSBTInput::IsNull() const
93 : : {
94 [ # # # # : 0 : return !non_witness_utxo && witness_utxo.IsNull() && partial_sigs.empty() && unknown.empty() && hd_keypaths.empty() && redeem_script.empty() && witness_script.empty();
# # # # #
# # # # #
# # # # ]
95 : : }
96 : :
97 : 22700 : void PSBTInput::FillSignatureData(SignatureData& sigdata) const
98 : : {
99 [ - + - + ]: 22700 : if (!final_script_sig.empty()) {
100 : 0 : sigdata.scriptSig = final_script_sig;
101 : 0 : sigdata.complete = true;
102 : : }
103 [ - + ]: 22700 : if (!final_script_witness.IsNull()) {
104 : 0 : sigdata.scriptWitness = final_script_witness;
105 : 0 : sigdata.complete = true;
106 : : }
107 [ + - ]: 22700 : if (sigdata.complete) {
108 : : return;
109 : : }
110 : :
111 : 22700 : sigdata.signatures.insert(partial_sigs.begin(), partial_sigs.end());
112 [ + + + + ]: 22772 : if (!redeem_script.empty()) {
113 : 4400 : sigdata.redeem_script = redeem_script;
114 : : }
115 [ + + + + ]: 22982 : if (!witness_script.empty()) {
116 : 328 : sigdata.witness_script = witness_script;
117 : : }
118 [ + + ]: 36437 : for (const auto& key_pair : hd_keypaths) {
119 : 13737 : sigdata.misc_pubkeys.emplace(key_pair.first.GetID(), key_pair);
120 : : }
121 [ + + ]: 22700 : if (!m_tap_key_sig.empty()) {
122 : 203 : sigdata.taproot_key_path_sig = m_tap_key_sig;
123 : : }
124 [ + + ]: 23194 : for (const auto& [pubkey_leaf, sig] : m_tap_script_sigs) {
125 : 494 : sigdata.taproot_script_sigs.emplace(pubkey_leaf, sig);
126 : : }
127 [ + + ]: 45400 : if (!m_tap_internal_key.IsNull()) {
128 : 1994 : sigdata.tr_spenddata.internal_key = m_tap_internal_key;
129 : : }
130 [ + + ]: 45400 : if (!m_tap_merkle_root.IsNull()) {
131 : 1507 : sigdata.tr_spenddata.merkle_root = m_tap_merkle_root;
132 : : }
133 [ + + ]: 25091 : for (const auto& [leaf_script, control_block] : m_tap_scripts) {
134 : 2391 : sigdata.tr_spenddata.scripts.emplace(leaf_script, control_block);
135 : : }
136 [ + + ]: 31429 : for (const auto& [pubkey, leaf_origin] : m_tap_bip32_paths) {
137 : 8729 : sigdata.taproot_misc_pubkeys.emplace(pubkey, leaf_origin);
138 : 8729 : sigdata.tap_pubkeys.emplace(Hash160(pubkey), pubkey);
139 : : }
140 [ - + ]: 22700 : for (const auto& [hash, preimage] : ripemd160_preimages) {
141 [ # # ]: 0 : sigdata.ripemd160_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage);
142 : : }
143 [ + + ]: 22712 : for (const auto& [hash, preimage] : sha256_preimages) {
144 [ + - ]: 24 : sigdata.sha256_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage);
145 : : }
146 [ - + ]: 22700 : for (const auto& [hash, preimage] : hash160_preimages) {
147 [ # # ]: 0 : sigdata.hash160_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage);
148 : : }
149 [ - + ]: 22700 : for (const auto& [hash, preimage] : hash256_preimages) {
150 [ # # ]: 0 : sigdata.hash256_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage);
151 : : }
152 : 22700 : sigdata.musig2_pubkeys.insert(m_musig2_participants.begin(), m_musig2_participants.end());
153 [ + + ]: 24081 : for (const auto& [agg_key_lh, pubnonces] : m_musig2_pubnonces) {
154 : 1381 : sigdata.musig2_pubnonces[agg_key_lh].insert(pubnonces.begin(), pubnonces.end());
155 : : }
156 [ + + ]: 22978 : for (const auto& [agg_key_lh, psigs] : m_musig2_partial_sigs) {
157 : 278 : sigdata.musig2_partial_sigs[agg_key_lh].insert(psigs.begin(), psigs.end());
158 : : }
159 : : }
160 : :
161 : 22649 : void PSBTInput::FromSignatureData(const SignatureData& sigdata)
162 : : {
163 [ + + ]: 22649 : if (sigdata.complete) {
164 : 1609 : partial_sigs.clear();
165 : 1609 : hd_keypaths.clear();
166 : 1609 : redeem_script.clear();
167 : 1609 : witness_script.clear();
168 : :
169 [ + + + + ]: 1844 : if (!sigdata.scriptSig.empty()) {
170 : 749 : final_script_sig = sigdata.scriptSig;
171 : : }
172 [ + + ]: 1609 : if (!sigdata.scriptWitness.IsNull()) {
173 : 1374 : final_script_witness = sigdata.scriptWitness;
174 : : }
175 : 1609 : return;
176 : : }
177 : :
178 : 21040 : partial_sigs.insert(sigdata.signatures.begin(), sigdata.signatures.end());
179 [ + + + + : 21112 : if (redeem_script.empty() && !sigdata.redeem_script.empty()) {
+ + + + ]
180 : 542 : redeem_script = sigdata.redeem_script;
181 : : }
182 [ + + + + : 21298 : if (witness_script.empty() && !sigdata.witness_script.empty()) {
+ + + + ]
183 : 34 : witness_script = sigdata.witness_script;
184 : : }
185 [ + + ]: 34833 : for (const auto& entry : sigdata.misc_pubkeys) {
186 : 13793 : hd_keypaths.emplace(entry.second);
187 : : }
188 [ + + ]: 21040 : if (!sigdata.taproot_key_path_sig.empty()) {
189 : 230 : m_tap_key_sig = sigdata.taproot_key_path_sig;
190 : : }
191 [ + + ]: 21593 : for (const auto& [pubkey_leaf, sig] : sigdata.taproot_script_sigs) {
192 : 553 : m_tap_script_sigs.emplace(pubkey_leaf, sig);
193 : : }
194 [ + + ]: 42080 : if (!sigdata.tr_spenddata.internal_key.IsNull()) {
195 : 1921 : m_tap_internal_key = sigdata.tr_spenddata.internal_key;
196 : : }
197 [ + + ]: 42080 : if (!sigdata.tr_spenddata.merkle_root.IsNull()) {
198 : 1442 : m_tap_merkle_root = sigdata.tr_spenddata.merkle_root;
199 : : }
200 [ + + ]: 23331 : for (const auto& [leaf_script, control_block] : sigdata.tr_spenddata.scripts) {
201 : 2291 : m_tap_scripts.emplace(leaf_script, control_block);
202 : : }
203 [ + + ]: 29512 : for (const auto& [pubkey, leaf_origin] : sigdata.taproot_misc_pubkeys) {
204 : 8472 : m_tap_bip32_paths.emplace(pubkey, leaf_origin);
205 : : }
206 : 21040 : m_musig2_participants.insert(sigdata.musig2_pubkeys.begin(), sigdata.musig2_pubkeys.end());
207 [ + + ]: 22466 : for (const auto& [agg_key_lh, pubnonces] : sigdata.musig2_pubnonces) {
208 : 1426 : m_musig2_pubnonces[agg_key_lh].insert(pubnonces.begin(), pubnonces.end());
209 : : }
210 [ + + ]: 21333 : for (const auto& [agg_key_lh, psigs] : sigdata.musig2_partial_sigs) {
211 : 293 : m_musig2_partial_sigs[agg_key_lh].insert(psigs.begin(), psigs.end());
212 : : }
213 : : }
214 : :
215 : 73 : void PSBTInput::Merge(const PSBTInput& input)
216 : : {
217 [ + + + + ]: 73 : if (!non_witness_utxo && input.non_witness_utxo) non_witness_utxo = input.non_witness_utxo;
218 [ + + + + ]: 73 : if (witness_utxo.IsNull() && !input.witness_utxo.IsNull()) {
219 : 1 : witness_utxo = input.witness_utxo;
220 : : }
221 : :
222 : 73 : partial_sigs.insert(input.partial_sigs.begin(), input.partial_sigs.end());
223 : 73 : ripemd160_preimages.insert(input.ripemd160_preimages.begin(), input.ripemd160_preimages.end());
224 : 73 : sha256_preimages.insert(input.sha256_preimages.begin(), input.sha256_preimages.end());
225 : 73 : hash160_preimages.insert(input.hash160_preimages.begin(), input.hash160_preimages.end());
226 : 73 : hash256_preimages.insert(input.hash256_preimages.begin(), input.hash256_preimages.end());
227 : 73 : hd_keypaths.insert(input.hd_keypaths.begin(), input.hd_keypaths.end());
228 : 73 : unknown.insert(input.unknown.begin(), input.unknown.end());
229 : 73 : m_tap_script_sigs.insert(input.m_tap_script_sigs.begin(), input.m_tap_script_sigs.end());
230 : 73 : m_tap_scripts.insert(input.m_tap_scripts.begin(), input.m_tap_scripts.end());
231 : 73 : m_tap_bip32_paths.insert(input.m_tap_bip32_paths.begin(), input.m_tap_bip32_paths.end());
232 : :
233 [ + + + + : 74 : if (redeem_script.empty() && !input.redeem_script.empty()) redeem_script = input.redeem_script;
- + - + ]
234 [ + + + + : 75 : if (witness_script.empty() && !input.witness_script.empty()) witness_script = input.witness_script;
- + - + ]
235 [ - + + - : 73 : if (final_script_sig.empty() && !input.final_script_sig.empty()) final_script_sig = input.final_script_sig;
- + - + ]
236 [ + + + + ]: 73 : if (final_script_witness.IsNull() && !input.final_script_witness.IsNull()) final_script_witness = input.final_script_witness;
237 [ + - - + ]: 73 : if (m_tap_key_sig.empty() && !input.m_tap_key_sig.empty()) m_tap_key_sig = input.m_tap_key_sig;
238 [ + + - + ]: 170 : if (m_tap_internal_key.IsNull() && !input.m_tap_internal_key.IsNull()) m_tap_internal_key = input.m_tap_internal_key;
239 [ + + - + ]: 190 : if (m_tap_merkle_root.IsNull() && !input.m_tap_merkle_root.IsNull()) m_tap_merkle_root = input.m_tap_merkle_root;
240 : 73 : m_musig2_participants.insert(input.m_musig2_participants.begin(), input.m_musig2_participants.end());
241 [ + + ]: 156 : for (const auto& [agg_key_lh, pubnonces] : input.m_musig2_pubnonces) {
242 : 83 : m_musig2_pubnonces[agg_key_lh].insert(pubnonces.begin(), pubnonces.end());
243 : : }
244 [ + + ]: 110 : for (const auto& [agg_key_lh, psigs] : input.m_musig2_partial_sigs) {
245 : 37 : m_musig2_partial_sigs[agg_key_lh].insert(psigs.begin(), psigs.end());
246 : : }
247 : 73 : }
248 : :
249 : 917 : void PSBTOutput::FillSignatureData(SignatureData& sigdata) const
250 : : {
251 [ - + + + ]: 917 : if (!redeem_script.empty()) {
252 : 5 : sigdata.redeem_script = redeem_script;
253 : : }
254 [ + + + + ]: 925 : if (!witness_script.empty()) {
255 : 8 : sigdata.witness_script = witness_script;
256 : : }
257 [ + + ]: 1210 : for (const auto& key_pair : hd_keypaths) {
258 : 293 : sigdata.misc_pubkeys.emplace(key_pair.first.GetID(), key_pair);
259 : : }
260 [ + + + - ]: 917 : if (!m_tap_tree.empty() && m_tap_internal_key.IsFullyValid()) {
261 : 115 : TaprootBuilder builder;
262 [ - + + + ]: 404 : for (const auto& [depth, leaf_ver, script] : m_tap_tree) {
263 [ - + + - ]: 289 : builder.Add((int)depth, script, (int)leaf_ver, /*track=*/true);
264 : : }
265 [ - + ]: 115 : assert(builder.IsComplete());
266 [ + - ]: 115 : builder.Finalize(m_tap_internal_key);
267 [ + - ]: 115 : TaprootSpendData spenddata = builder.GetSpendData();
268 : :
269 : 115 : sigdata.tr_spenddata.internal_key = m_tap_internal_key;
270 [ + - + - ]: 230 : sigdata.tr_spenddata.Merge(spenddata);
271 : 115 : }
272 [ + + ]: 1377 : for (const auto& [pubkey, leaf_origin] : m_tap_bip32_paths) {
273 : 460 : sigdata.taproot_misc_pubkeys.emplace(pubkey, leaf_origin);
274 : 460 : sigdata.tap_pubkeys.emplace(Hash160(pubkey), pubkey);
275 : : }
276 : 917 : sigdata.musig2_pubkeys.insert(m_musig2_participants.begin(), m_musig2_participants.end());
277 : 917 : }
278 : :
279 : 917 : void PSBTOutput::FromSignatureData(const SignatureData& sigdata)
280 : : {
281 [ - + + + : 917 : if (redeem_script.empty() && !sigdata.redeem_script.empty()) {
- + + + ]
282 : 21 : redeem_script = sigdata.redeem_script;
283 : : }
284 [ + + + + : 935 : if (witness_script.empty() && !sigdata.witness_script.empty()) {
+ + + + ]
285 : 10 : witness_script = sigdata.witness_script;
286 : : }
287 [ + + ]: 1613 : for (const auto& entry : sigdata.misc_pubkeys) {
288 : 696 : hd_keypaths.emplace(entry.second);
289 : : }
290 [ + + ]: 1834 : if (!sigdata.tr_spenddata.internal_key.IsNull()) {
291 : 218 : m_tap_internal_key = sigdata.tr_spenddata.internal_key;
292 : : }
293 [ + + + + ]: 917 : if (sigdata.tr_builder.has_value() && sigdata.tr_builder->HasScripts()) {
294 : 174 : m_tap_tree = sigdata.tr_builder->GetTreeTuples();
295 : : }
296 [ + + ]: 1619 : for (const auto& [pubkey, leaf_origin] : sigdata.taproot_misc_pubkeys) {
297 : 702 : m_tap_bip32_paths.emplace(pubkey, leaf_origin);
298 : : }
299 : 917 : m_musig2_participants.insert(sigdata.musig2_pubkeys.begin(), sigdata.musig2_pubkeys.end());
300 : 917 : }
301 : :
302 : 0 : bool PSBTOutput::IsNull() const
303 : : {
304 [ # # # # : 0 : return redeem_script.empty() && witness_script.empty() && hd_keypaths.empty() && unknown.empty();
# # # # #
# # # ]
305 : : }
306 : :
307 : 138 : void PSBTOutput::Merge(const PSBTOutput& output)
308 : : {
309 : 138 : hd_keypaths.insert(output.hd_keypaths.begin(), output.hd_keypaths.end());
310 : 138 : unknown.insert(output.unknown.begin(), output.unknown.end());
311 : 138 : m_tap_bip32_paths.insert(output.m_tap_bip32_paths.begin(), output.m_tap_bip32_paths.end());
312 : :
313 [ - + + - : 138 : if (redeem_script.empty() && !output.redeem_script.empty()) redeem_script = output.redeem_script;
- + - + ]
314 [ + + + + : 139 : if (witness_script.empty() && !output.witness_script.empty()) witness_script = output.witness_script;
- + - + ]
315 [ + + - + ]: 365 : if (m_tap_internal_key.IsNull() && !output.m_tap_internal_key.IsNull()) m_tap_internal_key = output.m_tap_internal_key;
316 [ + + - + ]: 138 : if (m_tap_tree.empty() && !output.m_tap_tree.empty()) m_tap_tree = output.m_tap_tree;
317 : 138 : m_musig2_participants.insert(output.m_musig2_participants.begin(), output.m_musig2_participants.end());
318 : 138 : }
319 : :
320 : 54885 : bool PSBTInputSigned(const PSBTInput& input)
321 : : {
322 [ + + + + : 56077 : return !input.final_script_sig.empty() || !input.final_script_witness.IsNull();
+ + ]
323 : : }
324 : :
325 : 27553 : bool PSBTInputSignedAndVerified(const PartiallySignedTransaction psbt, unsigned int input_index, const PrecomputedTransactionData* txdata)
326 : : {
327 : 27553 : CTxOut utxo;
328 [ - + - + ]: 27553 : assert(psbt.inputs.size() >= input_index);
329 [ + + ]: 27553 : const PSBTInput& input = psbt.inputs[input_index];
330 : :
331 [ + + ]: 27553 : if (input.non_witness_utxo) {
332 : : // If we're taking our information from a non-witness UTXO, verify that it matches the prevout.
333 [ - + ]: 25757 : COutPoint prevout = psbt.tx->vin[input_index].prevout;
334 [ - + + - ]: 25757 : if (prevout.n >= input.non_witness_utxo->vout.size()) {
335 : : return false;
336 : : }
337 [ + - ]: 25757 : if (input.non_witness_utxo->GetHash() != prevout.hash) {
338 : : return false;
339 : : }
340 : 25757 : utxo = input.non_witness_utxo->vout[prevout.n];
341 [ + + ]: 1796 : } else if (!input.witness_utxo.IsNull()) {
342 : 1768 : utxo = input.witness_utxo;
343 : : } else {
344 : : return false;
345 : : }
346 : :
347 [ + + ]: 27525 : if (txdata) {
348 [ + - ]: 27522 : 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 [ + - ]: 3 : 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 : 27553 : }
353 : :
354 : 0 : size_t CountPSBTUnsignedInputs(const PartiallySignedTransaction& psbt) {
355 : 0 : size_t count = 0;
356 [ # # ]: 0 : for (const auto& input : psbt.inputs) {
357 [ # # ]: 0 : if (!PSBTInputSigned(input)) {
358 : 0 : count++;
359 : : }
360 : : }
361 : :
362 : 0 : return count;
363 : : }
364 : :
365 : 917 : void UpdatePSBTOutput(const SigningProvider& provider, PartiallySignedTransaction& psbt, int index)
366 : : {
367 : 917 : CMutableTransaction& tx = *Assert(psbt.tx);
368 : 917 : const CTxOut& out = tx.vout.at(index);
369 : 917 : PSBTOutput& psbt_out = psbt.outputs.at(index);
370 : :
371 : : // Fill a SignatureData with output info
372 : 917 : SignatureData sigdata;
373 [ + - ]: 917 : 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 [ + - ]: 917 : MutableTransactionSignatureCreator creator(tx, /*input_idx=*/0, out.nValue, SIGHASH_ALL);
379 [ + - ]: 917 : ProduceSignature(provider, creator, out.scriptPubKey, sigdata);
380 : :
381 : : // Put redeem_script, witness_script, key paths, into PSBTOutput.
382 [ + - ]: 917 : psbt_out.FromSignatureData(sigdata);
383 : 917 : }
384 : :
385 : 1609 : PrecomputedTransactionData PrecomputePSBTData(const PartiallySignedTransaction& psbt)
386 : : {
387 [ - + ]: 1609 : const CMutableTransaction& tx = *psbt.tx;
388 : 1609 : bool have_all_spent_outputs = true;
389 [ - + ]: 1609 : std::vector<CTxOut> utxos(tx.vin.size());
390 [ - + + + ]: 6836 : for (size_t idx = 0; idx < tx.vin.size(); ++idx) {
391 [ + - + + ]: 5227 : if (!psbt.GetInputUTXO(utxos[idx], idx)) have_all_spent_outputs = false;
392 : : }
393 : 1609 : PrecomputedTransactionData txdata;
394 [ + + ]: 1609 : if (have_all_spent_outputs) {
395 [ + - ]: 1581 : txdata.Init(tx, std::move(utxos), true);
396 : : } else {
397 [ + - ]: 28 : txdata.Init(tx, {}, true);
398 : : }
399 : 1609 : return txdata;
400 : 1609 : }
401 : :
402 : 24054 : PSBTError SignPSBTInput(const SigningProvider& provider, PartiallySignedTransaction& psbt, int index, const PrecomputedTransactionData* txdata, std::optional<int> sighash, SignatureData* out_sigdata, bool finalize)
403 : : {
404 : 24054 : PSBTInput& input = psbt.inputs.at(index);
405 : 24054 : const CMutableTransaction& tx = *psbt.tx;
406 : :
407 [ + - + + ]: 24054 : if (PSBTInputSignedAndVerified(psbt, index, txdata)) {
408 : : return PSBTError::OK;
409 : : }
410 : :
411 : : // Fill SignatureData with input info
412 : 22700 : SignatureData sigdata;
413 [ + - ]: 22700 : input.FillSignatureData(sigdata);
414 : :
415 : : // Get UTXO
416 : 22700 : bool require_witness_sig = false;
417 : 22700 : CTxOut utxo;
418 : :
419 [ + + ]: 22700 : if (input.non_witness_utxo) {
420 : : // If we're taking our information from a non-witness UTXO, verify that it matches the prevout.
421 [ - + ]: 21623 : COutPoint prevout = tx.vin[index].prevout;
422 [ - + + - ]: 21623 : if (prevout.n >= input.non_witness_utxo->vout.size()) {
423 : : return PSBTError::MISSING_INPUTS;
424 : : }
425 [ + - ]: 21623 : if (input.non_witness_utxo->GetHash() != prevout.hash) {
426 : : return PSBTError::MISSING_INPUTS;
427 : : }
428 : 21623 : utxo = input.non_witness_utxo->vout[prevout.n];
429 [ + + ]: 1077 : } else if (!input.witness_utxo.IsNull()) {
430 : 1073 : 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 : 1073 : 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 [ + + + - : 42081 : if (!sighash) sighash = utxo.scriptPubKey.IsPayToTaproot() ? SIGHASH_DEFAULT : SIGHASH_ALL;
+ + ]
446 [ + - ]: 22696 : 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 [ + + + - ]: 45396 : 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 [ + - + + : 22682 : if (utxo.scriptPubKey.IsPayToTaproot() ? sighash != SIGHASH_DEFAULT :
+ - ]
455 [ + - + - ]: 39684 : (sighash != SIGHASH_DEFAULT && sighash != SIGHASH_ALL)) {
456 : 91 : input.sighash_type = sighash;
457 : : }
458 : :
459 : : // Check all existing signatures use the sighash type
460 [ + - ]: 22682 : if (sighash == SIGHASH_DEFAULT) {
461 [ + + - + : 2763 : if (!input.m_tap_key_sig.empty() && input.m_tap_key_sig.size() != 64) {
+ - ]
462 : : return PSBTError::SIGHASH_MISMATCH;
463 : : }
464 [ - + + + ]: 3257 : for (const auto& [_, sig] : input.m_tap_script_sigs) {
465 [ - + + - ]: 494 : if (sig.size() != 64) return PSBTError::SIGHASH_MISMATCH;
466 : : }
467 : : } else {
468 [ + + - + : 19919 : 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 [ - - - + ]: 19917 : for (const auto& [_, sig] : input.m_tap_script_sigs) {
472 [ # # # # : 0 : if (sig.size() != 65 || sig.back() != *sighash) return PSBTError::SIGHASH_MISMATCH;
# # ]
473 : : }
474 [ + + + + ]: 20298 : for (const auto& [_, sig] : input.partial_sigs) {
475 [ + + ]: 383 : if (sig.second.back() != *sighash) return PSBTError::SIGHASH_MISMATCH;
476 : : }
477 : : }
478 : :
479 : 22678 : sigdata.witness = false;
480 : 22678 : bool sig_complete;
481 [ + + ]: 22678 : if (txdata == nullptr) {
482 [ + - ]: 1 : sig_complete = ProduceSignature(provider, DUMMY_SIGNATURE_CREATOR, utxo.scriptPubKey, sigdata);
483 : : } else {
484 [ + - ]: 22677 : MutableTransactionSignatureCreator creator(tx, index, utxo.nValue, txdata, *sighash);
485 [ + - ]: 22677 : sig_complete = ProduceSignature(provider, creator, utxo.scriptPubKey, sigdata);
486 : 22677 : }
487 : : // Verify that a witness signature was produced in case one was required.
488 [ + + + + ]: 22678 : 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 [ + + + + ]: 22649 : if (!finalize && sigdata.complete) sigdata.complete = false;
492 : :
493 [ + - ]: 22649 : input.FromSignatureData(sigdata);
494 : :
495 : : // If we have a witness signature, put a witness UTXO.
496 [ + + ]: 22649 : if (sigdata.witness) {
497 : 17782 : 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 [ + + ]: 22649 : if (out_sigdata) {
505 [ + - ]: 3 : out_sigdata->missing_pubkeys = sigdata.missing_pubkeys;
506 [ + - ]: 3 : out_sigdata->missing_sigs = sigdata.missing_sigs;
507 : 3 : out_sigdata->missing_redeem_script = sigdata.missing_redeem_script;
508 : 3 : out_sigdata->missing_witness_script = sigdata.missing_witness_script;
509 : : }
510 : :
511 [ + + ]: 22649 : return sig_complete ? PSBTError::OK : PSBTError::INCOMPLETE;
512 : 22700 : }
513 : :
514 : 1088 : void RemoveUnnecessaryTransactions(PartiallySignedTransaction& psbtx)
515 : : {
516 : : // Figure out if any non_witness_utxos should be dropped
517 : 1088 : std::vector<unsigned int> to_drop;
518 [ - + + + ]: 1722 : for (unsigned int i = 0; i < psbtx.inputs.size(); ++i) {
519 [ + - ]: 1274 : const auto& input = psbtx.inputs.at(i);
520 : 1274 : int wit_ver;
521 : 1274 : std::vector<unsigned char> wit_prog;
522 [ + + + - : 1274 : 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 [ - + ]: 188 : to_drop.clear();
525 : : break;
526 : : }
527 [ + + ]: 1086 : if (wit_ver == 0) {
528 : : // Segwit v0, so we cannot drop any non_witness_utxos
529 [ - + ]: 446 : 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 [ + + + + ]: 640 : if (input.sighash_type != std::nullopt && (*input.sighash_type & 0x80) == SIGHASH_ANYONECANPAY) {
536 [ - + ]: 640 : to_drop.clear();
537 : : break;
538 : : }
539 : :
540 [ + + ]: 634 : if (input.non_witness_utxo) {
541 [ + - ]: 361 : to_drop.push_back(i);
542 : : }
543 : 1274 : }
544 : :
545 : : // Drop the non_witness_utxos that we can drop
546 [ + + ]: 1449 : for (unsigned int i : to_drop) {
547 [ + - - + ]: 361 : psbtx.inputs.at(i).non_witness_utxo = nullptr;
548 : : }
549 : 1088 : }
550 : :
551 : 498 : 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 : 498 : bool complete = true;
558 : 498 : const PrecomputedTransactionData txdata = PrecomputePSBTData(psbtx);
559 [ - + + + ]: 2194 : for (unsigned int i = 0; i < psbtx.tx->vin.size(); ++i) {
560 [ + - ]: 1696 : PSBTInput& input = psbtx.inputs.at(i);
561 [ + - ]: 1696 : complete &= (SignPSBTInput(DUMMY_SIGNING_PROVIDER, psbtx, i, &txdata, input.sighash_type, nullptr, true) == PSBTError::OK);
562 : : }
563 : :
564 : 498 : return complete;
565 : 498 : }
566 : :
567 : 495 : 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 [ + + ]: 495 : if (!FinalizePSBT(psbtx)) {
572 : : return false;
573 : : }
574 : :
575 : 463 : result = *psbtx.tx;
576 [ - + + + ]: 2079 : for (unsigned int i = 0; i < result.vin.size(); ++i) {
577 : 1616 : result.vin[i].scriptSig = psbtx.inputs[i].final_script_sig;
578 : 1616 : result.vin[i].scriptWitness = psbtx.inputs[i].final_script_witness;
579 : : }
580 : : return true;
581 : : }
582 : :
583 : 38 : bool CombinePSBTs(PartiallySignedTransaction& out, const std::vector<PartiallySignedTransaction>& psbtxs)
584 : : {
585 : 38 : out = psbtxs[0]; // Copy the first one
586 : :
587 : : // Merge
588 [ + + ]: 109 : for (auto it = std::next(psbtxs.begin()); it != psbtxs.end(); ++it) {
589 [ + + ]: 72 : if (!out.Merge(*it)) {
590 : : return false;
591 : : }
592 : : }
593 : : return true;
594 : : }
595 : :
596 : 11 : std::string PSBTRoleName(PSBTRole role) {
597 [ + + + + : 11 : switch (role) {
+ - ]
598 : 3 : case PSBTRole::CREATOR: return "creator";
599 : 2 : case PSBTRole::UPDATER: return "updater";
600 : 2 : case PSBTRole::SIGNER: return "signer";
601 : 2 : case PSBTRole::FINALIZER: return "finalizer";
602 : 2 : 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 : 1197 : bool DecodeBase64PSBT(PartiallySignedTransaction& psbt, const std::string& base64_tx, std::string& error)
609 : : {
610 [ - + ]: 1197 : auto tx_data = DecodeBase64(base64_tx);
611 [ + + ]: 1197 : if (!tx_data) {
612 [ + - ]: 1197 : error = "invalid base64";
613 : : return false;
614 : : }
615 [ + - ]: 1195 : return DecodeRawPSBT(psbt, MakeByteSpan(*tx_data), error);
616 : 1197 : }
617 : :
618 : 1195 : bool DecodeRawPSBT(PartiallySignedTransaction& psbt, std::span<const std::byte> tx_data, std::string& error)
619 : : {
620 : 1195 : DataStream ss_data{tx_data};
621 : 1195 : try {
622 [ + + ]: 1195 : ss_data >> psbt;
623 [ - + - + ]: 1140 : if (!ss_data.empty()) {
624 [ - - ]: 1195 : error = "extra data after PSBT";
625 : : return false;
626 : : }
627 [ - + ]: 55 : } catch (const std::exception& e) {
628 [ + - ]: 55 : error = e.what();
629 : 55 : return false;
630 : 55 : }
631 : : return true;
632 : 1195 : }
633 : :
634 : 1131 : uint32_t PartiallySignedTransaction::GetVersion() const
635 : : {
636 [ + + ]: 1131 : if (m_version != std::nullopt) {
637 : 1 : return *m_version;
638 : : }
639 : : return 0;
640 : : }
|
