Branch data Line data Source code
1 : : // Copyright (c) 2009-2022 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 <policy/policy.h>
8 : : #include <script/signingprovider.h>
9 : : #include <util/check.h>
10 : : #include <util/strencodings.h>
11 : :
12 : :
13 : 2166 : PartiallySignedTransaction::PartiallySignedTransaction(const CMutableTransaction& tx) : tx(tx)
14 : : {
15 [ + - ]: 2166 : inputs.resize(tx.vin.size());
16 [ + - ]: 2166 : outputs.resize(tx.vout.size());
17 [ + - ]: 2339 : }
18 [ + - ]: 173 :
19 : 1760 : bool PartiallySignedTransaction::IsNull() const
20 : : {
21 [ - + # # : 1760 : return !tx && inputs.empty() && outputs.empty() && unknown.empty();
# # ]
22 : : }
23 : :
24 : 6323 : bool PartiallySignedTransaction::Merge(const PartiallySignedTransaction& psbt)
25 : : {
26 : : // Prohibited to merge two PSBTs over different transactions
27 [ + + ]: 6496 : if (tx->GetHash() != psbt.tx->GetHash()) {
28 : 242 : return false;
29 : : }
30 : :
31 [ + + ]: 15777 : for (unsigned int i = 0; i < inputs.size(); ++i) {
32 : 9696 : inputs[i].Merge(psbt.inputs[i]);
33 : 9696 : }
34 [ + + ]: 20918 : for (unsigned int i = 0; i < outputs.size(); ++i) {
35 : 14837 : outputs[i].Merge(psbt.outputs[i]);
36 : 14837 : }
37 [ + + ]: 8596 : for (auto& xpub_pair : psbt.m_xpubs) {
38 [ + + ]: 2515 : if (m_xpubs.count(xpub_pair.first) == 0) {
39 : 696 : m_xpubs[xpub_pair.first] = xpub_pair.second;
40 : 696 : } else {
41 : 1819 : m_xpubs[xpub_pair.first].insert(xpub_pair.second.begin(), xpub_pair.second.end());
42 : : }
43 : : }
44 : 6081 : unknown.insert(psbt.unknown.begin(), psbt.unknown.end());
45 : :
46 : 6081 : return true;
47 : 6323 : }
48 : :
49 : 3566 : bool PartiallySignedTransaction::AddInput(const CTxIn& txin, PSBTInput& psbtin)
50 : : {
51 [ + + ]: 3566 : if (std::find(tx->vin.begin(), tx->vin.end(), txin) != tx->vin.end()) {
52 : 3363 : return false;
53 : : }
54 : 203 : tx->vin.push_back(txin);
55 : 203 : psbtin.partial_sigs.clear();
56 : 203 : psbtin.final_script_sig.clear();
57 : 203 : psbtin.final_script_witness.SetNull();
58 : 203 : inputs.push_back(psbtin);
59 : 203 : return true;
60 : 3566 : }
61 : :
62 : 5800 : bool PartiallySignedTransaction::AddOutput(const CTxOut& txout, const PSBTOutput& psbtout)
63 : : {
64 : 5800 : tx->vout.push_back(txout);
65 : 5800 : outputs.push_back(psbtout);
66 : 5800 : return true;
67 : : }
68 : :
69 : 18785 : bool PartiallySignedTransaction::GetInputUTXO(CTxOut& utxo, int input_index) const
70 : : {
71 : 18785 : const PSBTInput& input = inputs[input_index];
72 : 18785 : uint32_t prevout_index = tx->vin[input_index].prevout.n;
73 [ + + ]: 18785 : if (input.non_witness_utxo) {
74 [ + + ]: 1053 : if (prevout_index >= input.non_witness_utxo->vout.size()) {
75 : 88 : return false;
76 : : }
77 [ - + ]: 965 : if (input.non_witness_utxo->GetHash() != tx->vin[input_index].prevout.hash) {
78 : 0 : return false;
79 : : }
80 : 965 : utxo = input.non_witness_utxo->vout[prevout_index];
81 [ + + ]: 18697 : } else if (!input.witness_utxo.IsNull()) {
82 : 8333 : utxo = input.witness_utxo;
83 : 8333 : } else {
84 : 9399 : return false;
85 : : }
86 : 9298 : return true;
87 : 18785 : }
88 : :
89 : 3470 : bool PSBTInput::IsNull() const
90 : : {
91 [ + + + + : 3470 : return !non_witness_utxo && witness_utxo.IsNull() && partial_sigs.empty() && unknown.empty() && hd_keypaths.empty() && redeem_script.empty() && witness_script.empty();
+ + + + +
+ + + ]
92 : : }
93 : :
94 : 11441 : void PSBTInput::FillSignatureData(SignatureData& sigdata) const
95 : : {
96 [ + + ]: 11441 : if (!final_script_sig.empty()) {
97 : 1351 : sigdata.scriptSig = final_script_sig;
98 : 1351 : sigdata.complete = true;
99 : 1351 : }
100 [ + + ]: 11441 : if (!final_script_witness.IsNull()) {
101 : 387 : sigdata.scriptWitness = final_script_witness;
102 : 387 : sigdata.complete = true;
103 : 387 : }
104 [ + + ]: 11441 : if (sigdata.complete) {
105 : 1715 : return;
106 : : }
107 : :
108 : 9726 : sigdata.signatures.insert(partial_sigs.begin(), partial_sigs.end());
109 [ + + ]: 9726 : if (!redeem_script.empty()) {
110 : 1098 : sigdata.redeem_script = redeem_script;
111 : 1098 : }
112 [ + + ]: 9726 : if (!witness_script.empty()) {
113 : 1072 : sigdata.witness_script = witness_script;
114 : 1072 : }
115 [ + + ]: 11775 : for (const auto& key_pair : hd_keypaths) {
116 : 2049 : sigdata.misc_pubkeys.emplace(key_pair.first.GetID(), key_pair);
117 : : }
118 [ + + ]: 9726 : if (!m_tap_key_sig.empty()) {
119 : 34 : sigdata.taproot_key_path_sig = m_tap_key_sig;
120 : 34 : }
121 [ + + ]: 10628 : for (const auto& [pubkey_leaf, sig] : m_tap_script_sigs) {
122 : 1804 : sigdata.taproot_script_sigs.emplace(pubkey_leaf, sig);
123 : : }
124 [ + + ]: 9726 : if (!m_tap_internal_key.IsNull()) {
125 : 41 : sigdata.tr_spenddata.internal_key = m_tap_internal_key;
126 : 41 : }
127 [ + + ]: 9726 : if (!m_tap_merkle_root.IsNull()) {
128 : 42 : sigdata.tr_spenddata.merkle_root = m_tap_merkle_root;
129 : 42 : }
130 [ + + ]: 13135 : for (const auto& [leaf_script, control_block] : m_tap_scripts) {
131 : 6818 : sigdata.tr_spenddata.scripts.emplace(leaf_script, control_block);
132 : : }
133 [ + + ]: 9952 : for (const auto& [pubkey, leaf_origin] : m_tap_bip32_paths) {
134 : 452 : sigdata.taproot_misc_pubkeys.emplace(pubkey, leaf_origin);
135 : : }
136 [ + + ]: 10459 : for (const auto& [hash, preimage] : ripemd160_preimages) {
137 [ + - + - : 2199 : sigdata.ripemd160_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage);
+ - + - ]
138 : : }
139 [ + + ]: 10935 : for (const auto& [hash, preimage] : sha256_preimages) {
140 [ + - + - : 3627 : sigdata.sha256_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage);
+ - + - ]
141 : : }
142 [ + + ]: 12253 : for (const auto& [hash, preimage] : hash160_preimages) {
143 [ + - + - : 7581 : sigdata.hash160_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage);
+ - + - ]
144 : : }
145 [ + + ]: 10613 : for (const auto& [hash, preimage] : hash256_preimages) {
146 [ + - + - : 2661 : sigdata.hash256_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage);
+ - + - ]
147 : : }
148 : 11441 : }
149 : :
150 : 1970 : void PSBTInput::FromSignatureData(const SignatureData& sigdata)
151 : : {
152 [ + + ]: 1970 : if (sigdata.complete) {
153 : 314 : partial_sigs.clear();
154 : 314 : hd_keypaths.clear();
155 : 314 : redeem_script.clear();
156 : 314 : witness_script.clear();
157 : :
158 [ + + ]: 314 : if (!sigdata.scriptSig.empty()) {
159 : 195 : final_script_sig = sigdata.scriptSig;
160 : 195 : }
161 [ + + ]: 314 : if (!sigdata.scriptWitness.IsNull()) {
162 : 158 : final_script_witness = sigdata.scriptWitness;
163 : 158 : }
164 : 314 : return;
165 : : }
166 : :
167 : 1656 : partial_sigs.insert(sigdata.signatures.begin(), sigdata.signatures.end());
168 [ + + + + ]: 1656 : if (redeem_script.empty() && !sigdata.redeem_script.empty()) {
169 : 8 : redeem_script = sigdata.redeem_script;
170 : 8 : }
171 [ + + + - ]: 1656 : if (witness_script.empty() && !sigdata.witness_script.empty()) {
172 : 0 : witness_script = sigdata.witness_script;
173 : 0 : }
174 [ + + ]: 2974 : for (const auto& entry : sigdata.misc_pubkeys) {
175 : 1318 : hd_keypaths.emplace(entry.second);
176 : : }
177 [ + + ]: 1656 : if (!sigdata.taproot_key_path_sig.empty()) {
178 : 9 : m_tap_key_sig = sigdata.taproot_key_path_sig;
179 : 9 : }
180 [ + + ]: 1743 : for (const auto& [pubkey_leaf, sig] : sigdata.taproot_script_sigs) {
181 : 174 : m_tap_script_sigs.emplace(pubkey_leaf, sig);
182 : : }
183 [ + + ]: 1656 : if (!sigdata.tr_spenddata.internal_key.IsNull()) {
184 : 9 : m_tap_internal_key = sigdata.tr_spenddata.internal_key;
185 : 9 : }
186 [ + + ]: 1656 : if (!sigdata.tr_spenddata.merkle_root.IsNull()) {
187 : 9 : m_tap_merkle_root = sigdata.tr_spenddata.merkle_root;
188 : 9 : }
189 [ + + ]: 2253 : for (const auto& [leaf_script, control_block] : sigdata.tr_spenddata.scripts) {
190 : 1194 : m_tap_scripts.emplace(leaf_script, control_block);
191 : : }
192 [ + + ]: 1751 : for (const auto& [pubkey, leaf_origin] : sigdata.taproot_misc_pubkeys) {
193 : 190 : m_tap_bip32_paths.emplace(pubkey, leaf_origin);
194 : : }
195 : 1970 : }
196 : :
197 : 9696 : void PSBTInput::Merge(const PSBTInput& input)
198 : : {
199 [ + + + + ]: 9696 : if (!non_witness_utxo && input.non_witness_utxo) non_witness_utxo = input.non_witness_utxo;
200 [ + + + + ]: 9696 : if (witness_utxo.IsNull() && !input.witness_utxo.IsNull()) {
201 : 57 : witness_utxo = input.witness_utxo;
202 : 57 : }
203 : :
204 : 9696 : partial_sigs.insert(input.partial_sigs.begin(), input.partial_sigs.end());
205 : 9696 : ripemd160_preimages.insert(input.ripemd160_preimages.begin(), input.ripemd160_preimages.end());
206 : 9696 : sha256_preimages.insert(input.sha256_preimages.begin(), input.sha256_preimages.end());
207 : 9696 : hash160_preimages.insert(input.hash160_preimages.begin(), input.hash160_preimages.end());
208 : 9696 : hash256_preimages.insert(input.hash256_preimages.begin(), input.hash256_preimages.end());
209 : 9696 : hd_keypaths.insert(input.hd_keypaths.begin(), input.hd_keypaths.end());
210 : 9696 : unknown.insert(input.unknown.begin(), input.unknown.end());
211 : 9696 : m_tap_script_sigs.insert(input.m_tap_script_sigs.begin(), input.m_tap_script_sigs.end());
212 : 9696 : m_tap_scripts.insert(input.m_tap_scripts.begin(), input.m_tap_scripts.end());
213 : 9696 : m_tap_bip32_paths.insert(input.m_tap_bip32_paths.begin(), input.m_tap_bip32_paths.end());
214 : :
215 [ + + + + ]: 9696 : if (redeem_script.empty() && !input.redeem_script.empty()) redeem_script = input.redeem_script;
216 [ + + + + ]: 9696 : if (witness_script.empty() && !input.witness_script.empty()) witness_script = input.witness_script;
217 [ + + + + ]: 9696 : if (final_script_sig.empty() && !input.final_script_sig.empty()) final_script_sig = input.final_script_sig;
218 [ + + + + ]: 9696 : if (final_script_witness.IsNull() && !input.final_script_witness.IsNull()) final_script_witness = input.final_script_witness;
219 [ + + + + ]: 9696 : if (m_tap_key_sig.empty() && !input.m_tap_key_sig.empty()) m_tap_key_sig = input.m_tap_key_sig;
220 [ + + + + ]: 9696 : if (m_tap_internal_key.IsNull() && !input.m_tap_internal_key.IsNull()) m_tap_internal_key = input.m_tap_internal_key;
221 [ + + + + ]: 9696 : if (m_tap_merkle_root.IsNull() && !input.m_tap_merkle_root.IsNull()) m_tap_merkle_root = input.m_tap_merkle_root;
222 : 9696 : }
223 : :
224 : 65 : void PSBTOutput::FillSignatureData(SignatureData& sigdata) const
225 : : {
226 [ + + ]: 65 : if (!redeem_script.empty()) {
227 : 3 : sigdata.redeem_script = redeem_script;
228 : 3 : }
229 [ + + ]: 65 : if (!witness_script.empty()) {
230 : 4 : sigdata.witness_script = witness_script;
231 : 4 : }
232 [ + + ]: 93 : for (const auto& key_pair : hd_keypaths) {
233 : 28 : sigdata.misc_pubkeys.emplace(key_pair.first.GetID(), key_pair);
234 : : }
235 [ + + + - ]: 65 : if (!m_tap_tree.empty() && m_tap_internal_key.IsFullyValid()) {
236 : 0 : TaprootBuilder builder;
237 [ # # ]: 0 : for (const auto& [depth, leaf_ver, script] : m_tap_tree) {
238 [ # # # # : 0 : builder.Add((int)depth, script, (int)leaf_ver, /*track=*/true);
# # ]
239 : : }
240 [ # # # # ]: 0 : assert(builder.IsComplete());
241 [ # # ]: 0 : builder.Finalize(m_tap_internal_key);
242 [ # # ]: 0 : TaprootSpendData spenddata = builder.GetSpendData();
243 : :
244 : 0 : sigdata.tr_spenddata.internal_key = m_tap_internal_key;
245 [ # # # # ]: 0 : sigdata.tr_spenddata.Merge(spenddata);
246 : 0 : }
247 [ + + ]: 66 : for (const auto& [pubkey, leaf_origin] : m_tap_bip32_paths) {
248 : 2 : sigdata.taproot_misc_pubkeys.emplace(pubkey, leaf_origin);
249 : : }
250 : 65 : }
251 : :
252 : 65 : void PSBTOutput::FromSignatureData(const SignatureData& sigdata)
253 : : {
254 [ + + + - ]: 65 : if (redeem_script.empty() && !sigdata.redeem_script.empty()) {
255 : 0 : redeem_script = sigdata.redeem_script;
256 : 0 : }
257 [ + + + - ]: 65 : if (witness_script.empty() && !sigdata.witness_script.empty()) {
258 : 0 : witness_script = sigdata.witness_script;
259 : 0 : }
260 [ + + ]: 93 : for (const auto& entry : sigdata.misc_pubkeys) {
261 : 28 : hd_keypaths.emplace(entry.second);
262 : : }
263 [ + - ]: 65 : if (!sigdata.tr_spenddata.internal_key.IsNull()) {
264 : 0 : m_tap_internal_key = sigdata.tr_spenddata.internal_key;
265 : 0 : }
266 [ - + # # ]: 65 : if (sigdata.tr_builder.has_value() && sigdata.tr_builder->HasScripts()) {
267 : 0 : m_tap_tree = sigdata.tr_builder->GetTreeTuples();
268 : 0 : }
269 [ + + ]: 66 : for (const auto& [pubkey, leaf_origin] : sigdata.taproot_misc_pubkeys) {
270 : 2 : m_tap_bip32_paths.emplace(pubkey, leaf_origin);
271 : : }
272 : 65 : }
273 : :
274 : 5687 : bool PSBTOutput::IsNull() const
275 : : {
276 [ + + + + : 5687 : return redeem_script.empty() && witness_script.empty() && hd_keypaths.empty() && unknown.empty();
+ + ]
277 : : }
278 : :
279 : 14837 : void PSBTOutput::Merge(const PSBTOutput& output)
280 : : {
281 : 14837 : hd_keypaths.insert(output.hd_keypaths.begin(), output.hd_keypaths.end());
282 : 14837 : unknown.insert(output.unknown.begin(), output.unknown.end());
283 : 14837 : m_tap_bip32_paths.insert(output.m_tap_bip32_paths.begin(), output.m_tap_bip32_paths.end());
284 : :
285 [ + + + + ]: 14837 : if (redeem_script.empty() && !output.redeem_script.empty()) redeem_script = output.redeem_script;
286 [ + + + + ]: 14837 : if (witness_script.empty() && !output.witness_script.empty()) witness_script = output.witness_script;
287 [ + + + + ]: 14837 : if (m_tap_internal_key.IsNull() && !output.m_tap_internal_key.IsNull()) m_tap_internal_key = output.m_tap_internal_key;
288 [ + + + + ]: 14837 : if (m_tap_tree.empty() && !output.m_tap_tree.empty()) m_tap_tree = output.m_tap_tree;
289 : 14837 : }
290 : :
291 : 6973 : bool PSBTInputSigned(const PSBTInput& input)
292 : : {
293 [ + + ]: 6973 : return !input.final_script_sig.empty() || !input.final_script_witness.IsNull();
294 : : }
295 : :
296 : 14504 : bool PSBTInputSignedAndVerified(const PartiallySignedTransaction psbt, unsigned int input_index, const PrecomputedTransactionData* txdata)
297 : : {
298 : 14504 : CTxOut utxo;
299 [ + - ]: 14504 : assert(psbt.inputs.size() >= input_index);
300 : 14504 : const PSBTInput& input = psbt.inputs[input_index];
301 : :
302 [ + - + + ]: 14504 : if (input.non_witness_utxo) {
303 : : // If we're taking our information from a non-witness UTXO, verify that it matches the prevout.
304 [ + - ]: 830 : COutPoint prevout = psbt.tx->vin[input_index].prevout;
305 [ + + ]: 830 : if (prevout.n >= input.non_witness_utxo->vout.size()) {
306 : 38 : return false;
307 : : }
308 [ + - + - : 792 : if (input.non_witness_utxo->GetHash() != prevout.hash) {
+ - ]
309 : 0 : return false;
310 : : }
311 [ + - ]: 792 : utxo = input.non_witness_utxo->vout[prevout.n];
312 [ + - + + ]: 14466 : } else if (!input.witness_utxo.IsNull()) {
313 [ + - ]: 6077 : utxo = input.witness_utxo;
314 : 6077 : } else {
315 : 7597 : return false;
316 : : }
317 : :
318 [ + + ]: 6869 : if (txdata) {
319 [ + - + - : 6401 : 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});
+ - ]
320 : : } else {
321 [ + - + - : 468 : 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});
- + ]
322 : : }
323 : 14504 : }
324 : :
325 : 1760 : size_t CountPSBTUnsignedInputs(const PartiallySignedTransaction& psbt) {
326 : 1760 : size_t count = 0;
327 [ + + ]: 5230 : for (const auto& input : psbt.inputs) {
328 [ + + ]: 3470 : if (!PSBTInputSigned(input)) {
329 : 2868 : count++;
330 : 2868 : }
331 : : }
332 : :
333 : 1760 : return count;
334 : : }
335 : :
336 : 65 : void UpdatePSBTOutput(const SigningProvider& provider, PartiallySignedTransaction& psbt, int index)
337 : : {
338 : 65 : CMutableTransaction& tx = *Assert(psbt.tx);
339 : 65 : const CTxOut& out = tx.vout.at(index);
340 : 65 : PSBTOutput& psbt_out = psbt.outputs.at(index);
341 : :
342 : : // Fill a SignatureData with output info
343 : 65 : SignatureData sigdata;
344 [ + - ]: 65 : psbt_out.FillSignatureData(sigdata);
345 : :
346 : : // Construct a would-be spend of this output, to update sigdata with.
347 : : // Note that ProduceSignature is used to fill in metadata (not actual signatures),
348 : : // so provider does not need to provide any private keys (it can be a HidingSigningProvider).
349 [ + - ]: 65 : MutableTransactionSignatureCreator creator(tx, /*input_idx=*/0, out.nValue, SIGHASH_ALL);
350 [ + - ]: 65 : ProduceSignature(provider, creator, out.scriptPubKey, sigdata);
351 : :
352 : : // Put redeem_script, witness_script, key paths, into PSBTOutput.
353 [ + - ]: 65 : psbt_out.FromSignatureData(sigdata);
354 : 65 : }
355 : :
356 : 5813 : PrecomputedTransactionData PrecomputePSBTData(const PartiallySignedTransaction& psbt)
357 : : {
358 : 5813 : const CMutableTransaction& tx = *psbt.tx;
359 : 5813 : bool have_all_spent_outputs = true;
360 [ + - ]: 5813 : std::vector<CTxOut> utxos(tx.vin.size());
361 [ + + ]: 17651 : for (size_t idx = 0; idx < tx.vin.size(); ++idx) {
362 [ + - + + ]: 11838 : if (!psbt.GetInputUTXO(utxos[idx], idx)) have_all_spent_outputs = false;
363 : 11838 : }
364 [ + - ]: 5813 : PrecomputedTransactionData txdata;
365 [ + + ]: 5813 : if (have_all_spent_outputs) {
366 [ - + ]: 3183 : txdata.Init(tx, std::move(utxos), true);
367 : 3183 : } else {
368 [ - + ]: 2630 : txdata.Init(tx, {}, true);
369 : : }
370 : 5813 : return txdata;
371 [ + - ]: 5813 : }
372 : :
373 : 11630 : bool SignPSBTInput(const SigningProvider& provider, PartiallySignedTransaction& psbt, int index, const PrecomputedTransactionData* txdata, int sighash, SignatureData* out_sigdata, bool finalize)
374 : : {
375 : 11630 : PSBTInput& input = psbt.inputs.at(index);
376 : 11630 : const CMutableTransaction& tx = *psbt.tx;
377 : :
378 [ + - + + ]: 11630 : if (PSBTInputSignedAndVerified(psbt, index, txdata)) {
379 : 189 : return true;
380 : : }
381 : :
382 : : // Fill SignatureData with input info
383 : 11441 : SignatureData sigdata;
384 [ + - ]: 11441 : input.FillSignatureData(sigdata);
385 : :
386 : : // Get UTXO
387 : 11441 : bool require_witness_sig = false;
388 [ + - ]: 11441 : CTxOut utxo;
389 : :
390 [ + - + + ]: 11441 : if (input.non_witness_utxo) {
391 : : // If we're taking our information from a non-witness UTXO, verify that it matches the prevout.
392 : 659 : COutPoint prevout = tx.vin[index].prevout;
393 [ + + ]: 659 : if (prevout.n >= input.non_witness_utxo->vout.size()) {
394 : 38 : return false;
395 : : }
396 [ + - + - : 621 : if (input.non_witness_utxo->GetHash() != prevout.hash) {
+ - ]
397 : 0 : return false;
398 : : }
399 [ + - ]: 621 : utxo = input.non_witness_utxo->vout[prevout.n];
400 [ + - + + ]: 11403 : } else if (!input.witness_utxo.IsNull()) {
401 [ + - ]: 4779 : utxo = input.witness_utxo;
402 : : // When we're taking our information from a witness UTXO, we can't verify it is actually data from
403 : : // the output being spent. This is safe in case a witness signature is produced (which includes this
404 : : // information directly in the hash), but not for non-witness signatures. Remember that we require
405 : : // a witness signature in this situation.
406 : 4779 : require_witness_sig = true;
407 : 4779 : } else {
408 : 6003 : return false;
409 : : }
410 : :
411 : 5400 : sigdata.witness = false;
412 : : bool sig_complete;
413 [ + + ]: 5400 : if (txdata == nullptr) {
414 [ + - ]: 438 : sig_complete = ProduceSignature(provider, DUMMY_SIGNATURE_CREATOR, utxo.scriptPubKey, sigdata);
415 : 438 : } else {
416 [ + - ]: 4962 : MutableTransactionSignatureCreator creator(tx, index, utxo.nValue, txdata, sighash);
417 [ - + ]: 4962 : sig_complete = ProduceSignature(provider, creator, utxo.scriptPubKey, sigdata);
418 : 4962 : }
419 : : // Verify that a witness signature was produced in case one was required.
420 [ + + + + ]: 5400 : if (require_witness_sig && !sigdata.witness) return false;
421 : :
422 : : // If we are not finalizing, set sigdata.complete to false to not set the scriptWitness
423 [ - + # # ]: 1970 : if (!finalize && sigdata.complete) sigdata.complete = false;
424 : :
425 [ + - ]: 1970 : input.FromSignatureData(sigdata);
426 : :
427 : : // If we have a witness signature, put a witness UTXO.
428 [ + + ]: 1970 : if (sigdata.witness) {
429 [ + - ]: 1660 : input.witness_utxo = utxo;
430 : : // We can remove the non_witness_utxo if and only if there are no non-segwit or segwit v0
431 : : // inputs in this transaction. Since this requires inspecting the entire transaction, this
432 : : // is something for the caller to deal with (i.e. FillPSBT).
433 : 1660 : }
434 : :
435 : : // Fill in the missing info
436 [ + + ]: 1970 : if (out_sigdata) {
437 [ + - ]: 508 : out_sigdata->missing_pubkeys = sigdata.missing_pubkeys;
438 [ + - ]: 508 : out_sigdata->missing_sigs = sigdata.missing_sigs;
439 : 508 : out_sigdata->missing_redeem_script = sigdata.missing_redeem_script;
440 : 508 : out_sigdata->missing_witness_script = sigdata.missing_witness_script;
441 : 508 : }
442 : :
443 : 1970 : return sig_complete;
444 : 11630 : }
445 : :
446 : 40 : void RemoveUnnecessaryTransactions(PartiallySignedTransaction& psbtx, const int& sighash_type)
447 : : {
448 : : // Only drop non_witness_utxos if sighash_type != SIGHASH_ANYONECANPAY
449 [ - + ]: 40 : if ((sighash_type & 0x80) != SIGHASH_ANYONECANPAY) {
450 : : // Figure out if any non_witness_utxos should be dropped
451 : 40 : std::vector<unsigned int> to_drop;
452 [ + + ]: 40 : for (unsigned int i = 0; i < psbtx.inputs.size(); ++i) {
453 [ - + ]: 11 : const auto& input = psbtx.inputs.at(i);
454 : : int wit_ver;
455 : 11 : std::vector<unsigned char> wit_prog;
456 [ + - - + : 11 : if (input.witness_utxo.IsNull() || !input.witness_utxo.scriptPubKey.IsWitnessProgram(wit_ver, wit_prog)) {
# # # # ]
457 : : // There's a non-segwit input or Segwit v0, so we cannot drop any witness_utxos
458 : 11 : to_drop.clear();
459 : 11 : break;
460 : : }
461 [ # # ]: 0 : if (wit_ver == 0) {
462 : : // Segwit v0, so we cannot drop any non_witness_utxos
463 : 0 : to_drop.clear();
464 : 0 : break;
465 : : }
466 [ # # # # ]: 0 : if (input.non_witness_utxo) {
467 [ # # ]: 0 : to_drop.push_back(i);
468 : 0 : }
469 [ - + - ]: 11 : }
470 : :
471 : : // Drop the non_witness_utxos that we can drop
472 [ + - ]: 40 : for (unsigned int i : to_drop) {
473 [ # # ]: 0 : psbtx.inputs.at(i).non_witness_utxo = nullptr;
474 : : }
475 : 40 : }
476 : 40 : }
477 : :
478 : 3991 : bool FinalizePSBT(PartiallySignedTransaction& psbtx)
479 : : {
480 : : // Finalize input signatures -- in case we have partial signatures that add up to a complete
481 : : // signature, but have not combined them yet (e.g. because the combiner that created this
482 : : // PartiallySignedTransaction did not understand them), this will combine them into a final
483 : : // script.
484 : 3991 : bool complete = true;
485 : 3991 : const PrecomputedTransactionData txdata = PrecomputePSBTData(psbtx);
486 [ + - + + ]: 12323 : for (unsigned int i = 0; i < psbtx.tx->vin.size(); ++i) {
487 [ + - ]: 8332 : complete &= SignPSBTInput(DUMMY_SIGNING_PROVIDER, psbtx, i, &txdata, SIGHASH_ALL, nullptr, true);
488 : 8332 : }
489 : :
490 : 3991 : return complete;
491 : 3991 : }
492 : :
493 : 2231 : bool FinalizeAndExtractPSBT(PartiallySignedTransaction& psbtx, CMutableTransaction& result)
494 : : {
495 : : // It's not safe to extract a PSBT that isn't finalized, and there's no easy way to check
496 : : // whether a PSBT is finalized without finalizing it, so we just do this.
497 [ + + ]: 2231 : if (!FinalizePSBT(psbtx)) {
498 : 1818 : return false;
499 : : }
500 : :
501 : 413 : result = *psbtx.tx;
502 [ + + ]: 490 : for (unsigned int i = 0; i < result.vin.size(); ++i) {
503 : 77 : result.vin[i].scriptSig = psbtx.inputs[i].final_script_sig;
504 : 77 : result.vin[i].scriptWitness = psbtx.inputs[i].final_script_witness;
505 : 77 : }
506 : 413 : return true;
507 : 2231 : }
508 : :
509 : 2097 : TransactionError CombinePSBTs(PartiallySignedTransaction& out, const std::vector<PartiallySignedTransaction>& psbtxs)
510 : : {
511 : 2097 : out = psbtxs[0]; // Copy the first one
512 : :
513 : : // Merge
514 [ + + ]: 6519 : for (auto it = std::next(psbtxs.begin()); it != psbtxs.end(); ++it) {
515 [ + + ]: 4563 : if (!out.Merge(*it)) {
516 : 141 : return TransactionError::PSBT_MISMATCH;
517 : : }
518 : 4422 : }
519 : 1956 : return TransactionError::OK;
520 : 2097 : }
521 : :
522 : 4251 : std::string PSBTRoleName(PSBTRole role) {
523 [ + + + + : 4251 : switch (role) {
+ - ]
524 [ - + ]: 754 : case PSBTRole::CREATOR: return "creator";
525 [ + - ]: 2954 : case PSBTRole::UPDATER: return "updater";
526 [ + - ]: 317 : case PSBTRole::SIGNER: return "signer";
527 [ + - ]: 42 : case PSBTRole::FINALIZER: return "finalizer";
528 [ + - ]: 184 : case PSBTRole::EXTRACTOR: return "extractor";
529 : : // no default case, so the compiler can warn about missing cases
530 : : }
531 : 0 : assert(false);
532 : 4251 : }
533 : :
534 : 5780 : bool DecodeBase64PSBT(PartiallySignedTransaction& psbt, const std::string& base64_tx, std::string& error)
535 : : {
536 : 5780 : auto tx_data = DecodeBase64(base64_tx);
537 [ + + ]: 5780 : if (!tx_data) {
538 [ + - ]: 109 : error = "invalid base64";
539 : 109 : return false;
540 : : }
541 [ + - + - ]: 5671 : return DecodeRawPSBT(psbt, MakeByteSpan(*tx_data), error);
542 : 5780 : }
543 : :
544 : 9781 : bool DecodeRawPSBT(PartiallySignedTransaction& psbt, Span<const std::byte> tx_data, std::string& error)
545 : : {
546 : 9781 : CDataStream ss_data(tx_data, SER_NETWORK, PROTOCOL_VERSION);
547 : : try {
548 [ + + ]: 9781 : ss_data >> psbt;
549 [ + - + + ]: 7081 : if (!ss_data.empty()) {
550 [ + - ]: 400 : error = "extra data after PSBT";
551 : 400 : return false;
552 : : }
553 [ - + ]: 9381 : } catch (const std::exception& e) {
554 [ + - ]: 2700 : error = e.what();
555 : 2700 : return false;
556 [ + - # # ]: 2700 : }
557 : 6681 : return true;
558 : 12481 : }
559 : :
560 : 31916 : uint32_t PartiallySignedTransaction::GetVersion() const
561 : : {
562 [ + + ]: 31916 : if (m_version != std::nullopt) {
563 : 104 : return *m_version;
564 : : }
565 : 31812 : return 0;
566 : 31916 : }
|
