LCOV - code coverage report
Current view: top level - src/primitives - transaction.cpp (source / functions) Coverage Total Hit
Test: fuzz_coverage.info Lines: 90.3 % 72 65
Test Date: 2024-12-04 04:00:22 Functions: 94.1 % 17 16
Branches: 66.4 % 116 77

             Branch data     Line data    Source code
       1                 :             : // Copyright (c) 2009-2010 Satoshi Nakamoto
       2                 :             : // Copyright (c) 2009-2022 The Bitcoin Core developers
       3                 :             : // Distributed under the MIT software license, see the accompanying
       4                 :             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       5                 :             : 
       6                 :             : #include <primitives/transaction.h>
       7                 :             : 
       8                 :             : #include <consensus/amount.h>
       9                 :             : #include <crypto/hex_base.h>
      10                 :             : #include <hash.h>
      11                 :             : #include <script/script.h>
      12                 :             : #include <serialize.h>
      13                 :             : #include <tinyformat.h>
      14                 :             : #include <uint256.h>
      15                 :             : #include <util/transaction_identifier.h>
      16                 :             : 
      17                 :             : #include <algorithm>
      18                 :             : #include <cassert>
      19                 :             : #include <stdexcept>
      20                 :             : 
      21                 :      531348 : std::string COutPoint::ToString() const
      22                 :             : {
      23   [ +  -  +  - ]:     1062696 :     return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10), n);
      24                 :             : }
      25                 :             : 
      26                 :     3096247 : CTxIn::CTxIn(COutPoint prevoutIn, CScript scriptSigIn, uint32_t nSequenceIn)
      27                 :             : {
      28                 :     3096247 :     prevout = prevoutIn;
      29                 :     3096247 :     scriptSig = scriptSigIn;
      30                 :     3096247 :     nSequence = nSequenceIn;
      31                 :     3096247 : }
      32                 :             : 
      33                 :           0 : CTxIn::CTxIn(Txid hashPrevTx, uint32_t nOut, CScript scriptSigIn, uint32_t nSequenceIn)
      34                 :             : {
      35                 :           0 :     prevout = COutPoint(hashPrevTx, nOut);
      36                 :           0 :     scriptSig = scriptSigIn;
      37                 :           0 :     nSequence = nSequenceIn;
      38                 :           0 : }
      39                 :             : 
      40                 :      531348 : std::string CTxIn::ToString() const
      41                 :             : {
      42         [ +  - ]:      531348 :     std::string str;
      43         [ +  - ]:      531348 :     str += "CTxIn(";
      44         [ +  - ]:     1062696 :     str += prevout.ToString();
      45         [ +  + ]:      531348 :     if (prevout.IsNull())
      46   [ +  +  +  -  :        1176 :         str += strprintf(", coinbase %s", HexStr(scriptSig));
                   +  - ]
      47                 :             :     else
      48   [ +  +  +  -  :     1592868 :         str += strprintf(", scriptSig=%s", HexStr(scriptSig).substr(0, 24));
             +  -  +  - ]
      49         [ +  + ]:      531348 :     if (nSequence != SEQUENCE_FINAL)
      50         [ +  - ]:     1019920 :         str += strprintf(", nSequence=%u", nSequence);
      51         [ +  - ]:      531348 :     str += ")";
      52                 :      531348 :     return str;
      53                 :           0 : }
      54                 :             : 
      55                 :    30601082 : CTxOut::CTxOut(const CAmount& nValueIn, CScript scriptPubKeyIn)
      56                 :             : {
      57                 :    30601082 :     nValue = nValueIn;
      58                 :    30601082 :     scriptPubKey = scriptPubKeyIn;
      59                 :    30601082 : }
      60                 :             : 
      61                 :     1161685 : std::string CTxOut::ToString() const
      62                 :             : {
      63   [ +  +  +  -  :     3485055 :     return strprintf("CTxOut(nValue=%d.%08d, scriptPubKey=%s)", nValue / COIN, nValue % COIN, HexStr(scriptPubKey).substr(0, 30));
                   +  - ]
      64                 :             : }
      65                 :             : 
      66                 :     2380680 : CMutableTransaction::CMutableTransaction() : version{CTransaction::CURRENT_VERSION}, nLockTime{0} {}
      67         [ +  - ]:      568748 : CMutableTransaction::CMutableTransaction(const CTransaction& tx) : vin(tx.vin), vout(tx.vout), version{tx.version}, nLockTime{tx.nLockTime} {}
      68                 :             : 
      69                 :      607035 : Txid CMutableTransaction::GetHash() const
      70                 :             : {
      71                 :      607035 :     return Txid::FromUint256((HashWriter{} << TX_NO_WITNESS(*this)).GetHash());
      72                 :             : }
      73                 :             : 
      74                 :     4881652 : bool CTransaction::ComputeHasWitness() const
      75                 :             : {
      76                 :    12734019 :     return std::any_of(vin.begin(), vin.end(), [](const auto& input) {
      77   [ +  +  +  +  :     4315390 :         return !input.scriptWitness.IsNull();
          +  +  +  +  +  
             +  +  +  +  
                      + ]
      78                 :     4881652 :     });
      79                 :             : }
      80                 :             : 
      81                 :     4881652 : Txid CTransaction::ComputeHash() const
      82                 :             : {
      83                 :     4881652 :     return Txid::FromUint256((HashWriter{} << TX_NO_WITNESS(*this)).GetHash());
      84                 :             : }
      85                 :             : 
      86                 :     4881652 : Wtxid CTransaction::ComputeWitnessHash() const
      87                 :             : {
      88         [ +  + ]:     4881652 :     if (!HasWitness()) {
      89                 :     3399845 :         return Wtxid::FromUint256(hash.ToUint256());
      90                 :             :     }
      91                 :             : 
      92                 :     1481807 :     return Wtxid::FromUint256((HashWriter{} << TX_WITH_WITNESS(*this)).GetHash());
      93                 :             : }
      94                 :             : 
      95   [ +  -  +  -  :     2143338 : CTransaction::CTransaction(const CMutableTransaction& tx) : vin(tx.vin), vout(tx.vout), version{tx.version}, nLockTime{tx.nLockTime}, m_has_witness{ComputeHasWitness()}, hash{ComputeHash()}, m_witness_hash{ComputeWitnessHash()} {}
             +  -  +  - ]
      96   [ +  -  +  -  :     2738314 : CTransaction::CTransaction(CMutableTransaction&& tx) : vin(std::move(tx.vin)), vout(std::move(tx.vout)), version{tx.version}, nLockTime{tx.nLockTime}, m_has_witness{ComputeHasWitness()}, hash{ComputeHash()}, m_witness_hash{ComputeWitnessHash()} {}
                   +  - ]
      97                 :             : 
      98                 :      633304 : CAmount CTransaction::GetValueOut() const
      99                 :             : {
     100                 :      633304 :     CAmount nValueOut = 0;
     101         [ +  + ]:     7996369 :     for (const auto& tx_out : vout) {
     102   [ +  +  +  + ]:     7363724 :         if (!MoneyRange(tx_out.nValue) || !MoneyRange(nValueOut + tx_out.nValue))
     103   [ +  -  +  - ]:        1977 :             throw std::runtime_error(std::string(__func__) + ": value out of range");
     104                 :     7363065 :         nValueOut += tx_out.nValue;
     105                 :             :     }
     106         [ -  + ]:      632645 :     assert(MoneyRange(nValueOut));
     107                 :      632645 :     return nValueOut;
     108                 :             : }
     109                 :             : 
     110                 :        3959 : unsigned int CTransaction::GetTotalSize() const
     111                 :             : {
     112                 :        3959 :     return ::GetSerializeSize(TX_WITH_WITNESS(*this));
     113                 :             : }
     114                 :             : 
     115                 :      533025 : std::string CTransaction::ToString() const
     116                 :             : {
     117         [ +  - ]:      533025 :     std::string str;
     118         [ +  - ]:     1066050 :     str += strprintf("CTransaction(hash=%s, ver=%u, vin.size=%u, vout.size=%u, nLockTime=%u)\n",
     119         [ +  - ]:     1066050 :         GetHash().ToString().substr(0,10),
     120                 :      533025 :         version,
     121         [ +  - ]:      533025 :         vin.size(),
     122                 :      533025 :         vout.size(),
     123         [ +  - ]:     1066050 :         nLockTime);
     124         [ +  + ]:     1064307 :     for (const auto& tx_in : vin)
     125   [ +  -  +  -  :     1593846 :         str += "    " + tx_in.ToString() + "\n";
                   +  - ]
     126         [ +  + ]:     1064307 :     for (const auto& tx_in : vin)
     127   [ +  -  +  -  :     1593846 :         str += "    " + tx_in.scriptWitness.ToString() + "\n";
                   +  - ]
     128         [ +  + ]:     1691332 :     for (const auto& tx_out : vout)
     129   [ +  -  +  -  :     3474921 :         str += "    " + tx_out.ToString() + "\n";
                   +  - ]
     130                 :      533025 :     return str;
     131                 :           0 : }
        

Generated by: LCOV version 2.0-1