LCOV - code coverage report
Current view: top level - src - psbt.cpp (source / functions) Hit Total Coverage
Test: fuzz_coverage.info Lines: 3 387 0.8 %
Date: 2023-11-12 01:39:15 Functions: 0 31 0.0 %
Branches: 2 441 0.5 %

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

Generated by: LCOV version 1.14