LCOV - code coverage report
Current view: top level - src/primitives - transaction.h (source / functions) Hit Total Coverage
Test: fuzz_coverage.info Lines: 96 134 71.6 %
Date: 2023-11-12 01:39:15 Functions: 84 227 37.0 %
Branches: 48 164 29.3 %

           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                 :            : #ifndef BITCOIN_PRIMITIVES_TRANSACTION_H
       7                 :            : #define BITCOIN_PRIMITIVES_TRANSACTION_H
       8                 :            : 
       9                 :            : #include <attributes.h>
      10                 :            : #include <consensus/amount.h>
      11                 :            : #include <script/script.h>
      12                 :            : #include <serialize.h>
      13                 :            : #include <uint256.h>
      14                 :            : #include <util/transaction_identifier.h> // IWYU pragma: export
      15                 :            : 
      16                 :            : #include <cstddef>
      17                 :            : #include <cstdint>
      18                 :            : #include <ios>
      19                 :            : #include <limits>
      20                 :            : #include <memory>
      21                 :            : #include <numeric>
      22                 :            : #include <string>
      23                 :            : #include <tuple>
      24                 :            : #include <utility>
      25                 :            : #include <vector>
      26                 :            : 
      27                 :            : /**
      28                 :            :  * A flag that is ORed into the protocol version to designate that a transaction
      29                 :            :  * should be (un)serialized without witness data.
      30                 :            :  * Make sure that this does not collide with any of the values in `version.h`
      31                 :            :  * or with `ADDRV2_FORMAT`.
      32                 :            :  */
      33                 :            : static const int SERIALIZE_TRANSACTION_NO_WITNESS = 0x40000000;
      34                 :            : 
      35                 :            : /** An outpoint - a combination of a transaction hash and an index n into its vout */
      36                 :            : class COutPoint
      37                 :            : {
      38                 :            : public:
      39                 :            :     uint256 hash;
      40                 :            :     uint32_t n;
      41                 :            : 
      42                 :            :     static constexpr uint32_t NULL_INDEX = std::numeric_limits<uint32_t>::max();
      43                 :            : 
      44                 :     310794 :     COutPoint(): n(NULL_INDEX) { }
      45                 :    1360125 :     COutPoint(const uint256& hashIn, uint32_t nIn): hash(hashIn), n(nIn) { }
      46                 :            : 
      47                 :    4328145 :     SERIALIZE_METHODS(COutPoint, obj) { READWRITE(obj.hash, obj.n); }
      48                 :            : 
      49                 :        200 :     void SetNull() { hash.SetNull(); n = NULL_INDEX; }
      50         [ +  + ]:     326726 :     bool IsNull() const { return (hash.IsNull() && n == NULL_INDEX); }
      51                 :            : 
      52                 :   22714503 :     friend bool operator<(const COutPoint& a, const COutPoint& b)
      53                 :            :     {
      54                 :   22714503 :         int cmp = a.hash.Compare(b.hash);
      55 [ +  + ][ +  + ]:   22714503 :         return cmp < 0 || (cmp == 0 && a.n < b.n);
      56                 :            :     }
      57                 :            : 
      58                 :    1119397 :     friend bool operator==(const COutPoint& a, const COutPoint& b)
      59                 :            :     {
      60         [ +  + ]:    1119397 :         return (a.hash == b.hash && a.n == b.n);
      61                 :            :     }
      62                 :            : 
      63                 :            :     friend bool operator!=(const COutPoint& a, const COutPoint& b)
      64                 :            :     {
      65                 :            :         return !(a == b);
      66                 :            :     }
      67                 :            : 
      68                 :            :     std::string ToString() const;
      69                 :            : };
      70                 :            : 
      71                 :            : /** An input of a transaction.  It contains the location of the previous
      72                 :            :  * transaction's output that it claims and a signature that matches the
      73                 :            :  * output's public key.
      74                 :            :  */
      75                 :     419250 : class CTxIn
      76                 :            : {
      77                 :            : public:
      78                 :            :     COutPoint prevout;
      79                 :            :     CScript scriptSig;
      80                 :            :     uint32_t nSequence;
      81                 :            :     CScriptWitness scriptWitness; //!< Only serialized through CTransaction
      82                 :            : 
      83                 :            :     /**
      84                 :            :      * Setting nSequence to this value for every input in a transaction
      85                 :            :      * disables nLockTime/IsFinalTx().
      86                 :            :      * It fails OP_CHECKLOCKTIMEVERIFY/CheckLockTime() for any input that has
      87                 :            :      * it set (BIP 65).
      88                 :            :      * It has SEQUENCE_LOCKTIME_DISABLE_FLAG set (BIP 68/112).
      89                 :            :      */
      90                 :            :     static const uint32_t SEQUENCE_FINAL = 0xffffffff;
      91                 :            :     /**
      92                 :            :      * This is the maximum sequence number that enables both nLockTime and
      93                 :            :      * OP_CHECKLOCKTIMEVERIFY (BIP 65).
      94                 :            :      * It has SEQUENCE_LOCKTIME_DISABLE_FLAG set (BIP 68/112).
      95                 :            :      */
      96                 :            :     static const uint32_t MAX_SEQUENCE_NONFINAL{SEQUENCE_FINAL - 1};
      97                 :            : 
      98                 :            :     // Below flags apply in the context of BIP 68. BIP 68 requires the tx
      99                 :            :     // version to be set to 2, or higher.
     100                 :            :     /**
     101                 :            :      * If this flag is set, CTxIn::nSequence is NOT interpreted as a
     102                 :            :      * relative lock-time.
     103                 :            :      * It skips SequenceLocks() for any input that has it set (BIP 68).
     104                 :            :      * It fails OP_CHECKSEQUENCEVERIFY/CheckSequence() for any input that has
     105                 :            :      * it set (BIP 112).
     106                 :            :      */
     107                 :            :     static const uint32_t SEQUENCE_LOCKTIME_DISABLE_FLAG = (1U << 31);
     108                 :            : 
     109                 :            :     /**
     110                 :            :      * If CTxIn::nSequence encodes a relative lock-time and this flag
     111                 :            :      * is set, the relative lock-time has units of 512 seconds,
     112                 :            :      * otherwise it specifies blocks with a granularity of 1. */
     113                 :            :     static const uint32_t SEQUENCE_LOCKTIME_TYPE_FLAG = (1 << 22);
     114                 :            : 
     115                 :            :     /**
     116                 :            :      * If CTxIn::nSequence encodes a relative lock-time, this mask is
     117                 :            :      * applied to extract that lock-time from the sequence field. */
     118                 :            :     static const uint32_t SEQUENCE_LOCKTIME_MASK = 0x0000ffff;
     119                 :            : 
     120                 :            :     /**
     121                 :            :      * In order to use the same number of bits to encode roughly the
     122                 :            :      * same wall-clock duration, and because blocks are naturally
     123                 :            :      * limited to occur every 600s on average, the minimum granularity
     124                 :            :      * for time-based relative lock-time is fixed at 512 seconds.
     125                 :            :      * Converting from CTxIn::nSequence to seconds is performed by
     126                 :            :      * multiplying by 512 = 2^9, or equivalently shifting up by
     127                 :            :      * 9 bits. */
     128                 :            :     static const int SEQUENCE_LOCKTIME_GRANULARITY = 9;
     129                 :            : 
     130         [ +  - ]:     310794 :     CTxIn()
     131                 :            :     {
     132                 :     310794 :         nSequence = SEQUENCE_FINAL;
     133                 :     310794 :     }
     134                 :            : 
     135                 :            :     explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), uint32_t nSequenceIn=SEQUENCE_FINAL);
     136                 :            :     CTxIn(uint256 hashPrevTx, uint32_t nOut, CScript scriptSigIn=CScript(), uint32_t nSequenceIn=SEQUENCE_FINAL);
     137                 :            : 
     138                 :    4291878 :     SERIALIZE_METHODS(CTxIn, obj) { READWRITE(obj.prevout, obj.scriptSig, obj.nSequence); }
     139                 :            : 
     140                 :     111418 :     friend bool operator==(const CTxIn& a, const CTxIn& b)
     141                 :            :     {
     142         [ +  + ]:     118305 :         return (a.prevout   == b.prevout &&
     143         [ -  + ]:       6887 :                 a.scriptSig == b.scriptSig &&
     144                 :       6887 :                 a.nSequence == b.nSequence);
     145                 :            :     }
     146                 :            : 
     147                 :            :     friend bool operator!=(const CTxIn& a, const CTxIn& b)
     148                 :            :     {
     149                 :            :         return !(a == b);
     150                 :            :     }
     151                 :            : 
     152                 :            :     std::string ToString() const;
     153                 :            : };
     154                 :            : 
     155                 :            : /** An output of a transaction.  It contains the public key that the next input
     156                 :            :  * must be able to sign with to claim it.
     157                 :            :  */
     158                 :          0 : class CTxOut
     159                 :            : {
     160                 :            : public:
     161                 :            :     CAmount nValue;
     162                 :            :     CScript scriptPubKey;
     163                 :            : 
     164                 :     205668 :     CTxOut()
     165                 :            :     {
     166         [ +  - ]:     205668 :         SetNull();
     167                 :     205668 :     }
     168                 :            : 
     169                 :            :     CTxOut(const CAmount& nValueIn, CScript scriptPubKeyIn);
     170                 :            : 
     171                 :   12938424 :     SERIALIZE_METHODS(CTxOut, obj) { READWRITE(obj.nValue, obj.scriptPubKey); }
     172                 :            : 
     173                 :     206975 :     void SetNull()
     174                 :            :     {
     175                 :     206975 :         nValue = -1;
     176                 :     206975 :         scriptPubKey.clear();
     177                 :     206975 :     }
     178                 :            : 
     179                 :     594424 :     bool IsNull() const
     180                 :            :     {
     181                 :     594424 :         return (nValue == -1);
     182                 :            :     }
     183                 :            : 
     184                 :      10773 :     friend bool operator==(const CTxOut& a, const CTxOut& b)
     185                 :            :     {
     186         [ -  + ]:      21546 :         return (a.nValue       == b.nValue &&
     187                 :      10773 :                 a.scriptPubKey == b.scriptPubKey);
     188                 :            :     }
     189                 :            : 
     190                 :          0 :     friend bool operator!=(const CTxOut& a, const CTxOut& b)
     191                 :            :     {
     192                 :          0 :         return !(a == b);
     193                 :            :     }
     194                 :            : 
     195                 :            :     std::string ToString() const;
     196                 :            : };
     197                 :            : 
     198                 :            : struct CMutableTransaction;
     199                 :            : 
     200                 :            : /**
     201                 :            :  * Basic transaction serialization format:
     202                 :            :  * - int32_t nVersion
     203                 :            :  * - std::vector<CTxIn> vin
     204                 :            :  * - std::vector<CTxOut> vout
     205                 :            :  * - uint32_t nLockTime
     206                 :            :  *
     207                 :            :  * Extended transaction serialization format:
     208                 :            :  * - int32_t nVersion
     209                 :            :  * - unsigned char dummy = 0x00
     210                 :            :  * - unsigned char flags (!= 0)
     211                 :            :  * - std::vector<CTxIn> vin
     212                 :            :  * - std::vector<CTxOut> vout
     213                 :            :  * - if (flags & 1):
     214                 :            :  *   - CScriptWitness scriptWitness; (deserialized into CTxIn)
     215                 :            :  * - uint32_t nLockTime
     216                 :            :  */
     217                 :            : template<typename Stream, typename TxType>
     218                 :          1 : inline void UnserializeTransaction(TxType& tx, Stream& s) {
     219                 :          1 :     const bool fAllowWitness = !(s.GetVersion() & SERIALIZE_TRANSACTION_NO_WITNESS);
     220                 :            : 
     221                 :          1 :     s >> tx.nVersion;
     222                 :          1 :     unsigned char flags = 0;
     223                 :          1 :     tx.vin.clear();
     224                 :          1 :     tx.vout.clear();
     225                 :            :     /* Try to read the vin. In case the dummy is there, this will be read as an empty vector. */
     226                 :          1 :     s >> tx.vin;
     227 [ -  + ][ #  # ]:          1 :     if (tx.vin.size() == 0 && fAllowWitness) {
         [ #  # ][ #  # ]
     228                 :            :         /* We read a dummy or an empty vin. */
     229                 :          0 :         s >> flags;
     230 [ #  # ][ #  # ]:          0 :         if (flags != 0) {
     231                 :          0 :             s >> tx.vin;
     232                 :          0 :             s >> tx.vout;
     233                 :          0 :         }
     234                 :          0 :     } else {
     235                 :            :         /* We read a non-empty vin. Assume a normal vout follows. */
     236                 :          1 :         s >> tx.vout;
     237                 :            :     }
     238 [ -  + ][ #  # ]:          1 :     if ((flags & 1) && fAllowWitness) {
         [ #  # ][ #  # ]
     239                 :            :         /* The witness flag is present, and we support witnesses. */
     240                 :          0 :         flags ^= 1;
     241 [ #  # ][ #  # ]:          0 :         for (size_t i = 0; i < tx.vin.size(); i++) {
     242                 :          0 :             s >> tx.vin[i].scriptWitness.stack;
     243                 :          0 :         }
     244 [ #  # ][ #  # ]:          0 :         if (!tx.HasWitness()) {
     245                 :            :             /* It's illegal to encode witnesses when all witness stacks are empty. */
     246 [ #  # ][ #  # ]:          0 :             throw std::ios_base::failure("Superfluous witness record");
     247                 :            :         }
     248                 :          0 :     }
     249 [ +  - ][ #  # ]:          1 :     if (flags) {
     250                 :            :         /* Unknown flag in the serialization */
     251 [ #  # ][ #  # ]:          0 :         throw std::ios_base::failure("Unknown transaction optional data");
     252                 :            :     }
     253                 :          1 :     s >> tx.nLockTime;
     254                 :          1 : }
     255                 :            : 
     256                 :            : template<typename Stream, typename TxType>
     257                 :     309487 : inline void SerializeTransaction(const TxType& tx, Stream& s) {
     258                 :     309487 :     const bool fAllowWitness = !(s.GetVersion() & SERIALIZE_TRANSACTION_NO_WITNESS);
     259                 :            : 
     260                 :     309487 :     s << tx.nVersion;
     261                 :     309487 :     unsigned char flags = 0;
     262                 :            :     // Consistency check
     263 [ +  + ][ +  + ]:     309487 :     if (fAllowWitness) {
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     264                 :            :         /* Check whether witnesses need to be serialized. */
     265 [ +  + ][ -  + ]:     113453 :         if (tx.HasWitness()) {
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     266                 :     113450 :             flags |= 1;
     267                 :     113450 :         }
     268                 :     113453 :     }
     269 [ +  + ][ +  + ]:     309487 :     if (flags) {
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     270                 :            :         /* Use extended format in case witnesses are to be serialized. */
     271                 :     113450 :         std::vector<CTxIn> vinDummy;
     272 [ +  - ][ +  - ]:     113450 :         s << vinDummy;
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     273 [ +  - ][ +  - ]:     113450 :         s << flags;
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     274                 :     113450 :     }
     275                 :     309487 :     s << tx.vin;
     276                 :     309487 :     s << tx.vout;
     277 [ +  + ][ +  + ]:     309487 :     if (flags & 1) {
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     278 [ +  + ][ +  + ]:     647334 :         for (size_t i = 0; i < tx.vin.size(); i++) {
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     279                 :     533884 :             s << tx.vin[i].scriptWitness.stack;
     280                 :     533884 :         }
     281                 :     113450 :     }
     282                 :     309487 :     s << tx.nLockTime;
     283                 :     309487 : }
     284                 :            : 
     285                 :            : template<typename TxType>
     286                 :          0 : inline CAmount CalculateOutputValue(const TxType& tx)
     287                 :            : {
     288                 :          0 :     return std::accumulate(tx.vout.cbegin(), tx.vout.cend(), CAmount{0}, [](CAmount sum, const auto& txout) { return sum + txout.nValue; });
     289                 :            : }
     290                 :            : 
     291                 :            : 
     292                 :            : /** The basic transaction that is broadcasted on the network and contained in
     293                 :            :  * blocks.  A transaction can contain multiple inputs and outputs.
     294                 :            :  */
     295                 :       2806 : class CTransaction
     296                 :            : {
     297                 :            : public:
     298                 :            :     // Default transaction version.
     299                 :            :     static const int32_t CURRENT_VERSION=2;
     300                 :            : 
     301                 :            :     // The local variables are made const to prevent unintended modification
     302                 :            :     // without updating the cached hash value. However, CTransaction is not
     303                 :            :     // actually immutable; deserialization and assignment are implemented,
     304                 :            :     // and bypass the constness. This is safe, as they update the entire
     305                 :            :     // structure, including the hash.
     306                 :            :     const std::vector<CTxIn> vin;
     307                 :            :     const std::vector<CTxOut> vout;
     308                 :            :     const int32_t nVersion;
     309                 :            :     const uint32_t nLockTime;
     310                 :            : 
     311                 :            : private:
     312                 :            :     /** Memory only. */
     313                 :            :     const Txid hash;
     314                 :            :     const Wtxid m_witness_hash;
     315                 :            : 
     316                 :            :     Txid ComputeHash() const;
     317                 :            :     Wtxid ComputeWitnessHash() const;
     318                 :            : 
     319                 :            : public:
     320                 :            :     /** Convert a CMutableTransaction into a CTransaction. */
     321                 :            :     explicit CTransaction(const CMutableTransaction& tx);
     322                 :            :     explicit CTransaction(CMutableTransaction&& tx);
     323                 :            : 
     324                 :            :     template <typename Stream>
     325                 :     309487 :     inline void Serialize(Stream& s) const {
     326                 :     309487 :         SerializeTransaction(*this, s);
     327                 :     309487 :     }
     328                 :            : 
     329                 :            :     /** This deserializing constructor is provided instead of an Unserialize method.
     330                 :            :      *  Unserialize is not possible, since it would require overwriting const fields. */
     331                 :            :     template <typename Stream>
     332 [ +  - ][ #  # ]:          1 :     CTransaction(deserialize_type, Stream& s) : CTransaction(CMutableTransaction(deserialize, s)) {}
     333                 :            : 
     334                 :          0 :     bool IsNull() const {
     335         [ #  # ]:          0 :         return vin.empty() && vout.empty();
     336                 :            :     }
     337                 :            : 
     338                 :    1730363 :     const Txid& GetHash() const LIFETIMEBOUND { return hash; }
     339                 :     192256 :     const Wtxid& GetWitnessHash() const LIFETIMEBOUND { return m_witness_hash; };
     340                 :            : 
     341                 :            :     // Return sum of txouts.
     342                 :            :     CAmount GetValueOut() const;
     343                 :            : 
     344                 :            :     /**
     345                 :            :      * Get the total transaction size in bytes, including witness data.
     346                 :            :      * "Total Size" defined in BIP141 and BIP144.
     347                 :            :      * @return Total transaction size in bytes
     348                 :            :      */
     349                 :            :     unsigned int GetTotalSize() const;
     350                 :            : 
     351                 :     182473 :     bool IsCoinBase() const
     352                 :            :     {
     353         [ +  + ]:     182473 :         return (vin.size() == 1 && vin[0].prevout.IsNull());
     354                 :            :     }
     355                 :            : 
     356                 :          0 :     friend bool operator==(const CTransaction& a, const CTransaction& b)
     357                 :            :     {
     358                 :          0 :         return a.hash == b.hash;
     359                 :            :     }
     360                 :            : 
     361                 :          0 :     friend bool operator!=(const CTransaction& a, const CTransaction& b)
     362                 :            :     {
     363                 :          0 :         return a.hash != b.hash;
     364                 :            :     }
     365                 :            : 
     366                 :            :     std::string ToString() const;
     367                 :            : 
     368                 :     170828 :     bool HasWitness() const
     369                 :            :     {
     370         [ +  + ]:     171437 :         for (size_t i = 0; i < vin.size(); i++) {
     371         [ +  + ]:     170828 :             if (!vin[i].scriptWitness.IsNull()) {
     372                 :     170219 :                 return true;
     373                 :            :             }
     374                 :        609 :         }
     375                 :        609 :         return false;
     376                 :     170828 :     }
     377                 :            : };
     378                 :            : 
     379                 :            : /** A mutable version of CTransaction. */
     380                 :          0 : struct CMutableTransaction
     381                 :            : {
     382                 :            :     std::vector<CTxIn> vin;
     383                 :            :     std::vector<CTxOut> vout;
     384                 :            :     int32_t nVersion;
     385                 :            :     uint32_t nLockTime;
     386                 :            : 
     387                 :            :     explicit CMutableTransaction();
     388                 :            :     explicit CMutableTransaction(const CTransaction& tx);
     389                 :            : 
     390                 :            :     template <typename Stream>
     391                 :          0 :     inline void Serialize(Stream& s) const {
     392                 :          0 :         SerializeTransaction(*this, s);
     393                 :          0 :     }
     394                 :            : 
     395                 :            : 
     396                 :            :     template <typename Stream>
     397                 :          1 :     inline void Unserialize(Stream& s) {
     398                 :          1 :         UnserializeTransaction(*this, s);
     399                 :          1 :     }
     400                 :            : 
     401                 :            :     template <typename Stream>
     402                 :          1 :     CMutableTransaction(deserialize_type, Stream& s) {
     403 [ +  - ][ #  # ]:          1 :         Unserialize(s);
     404                 :          1 :     }
     405                 :            : 
     406                 :            :     /** Compute the hash of this CMutableTransaction. This is computed on the
     407                 :            :      * fly, as opposed to GetHash() in CTransaction, which uses a cached result.
     408                 :            :      */
     409                 :            :     Txid GetHash() const;
     410                 :            : 
     411                 :          0 :     bool HasWitness() const
     412                 :            :     {
     413         [ #  # ]:          0 :         for (size_t i = 0; i < vin.size(); i++) {
     414         [ #  # ]:          0 :             if (!vin[i].scriptWitness.IsNull()) {
     415                 :          0 :                 return true;
     416                 :            :             }
     417                 :          0 :         }
     418                 :          0 :         return false;
     419                 :          0 :     }
     420                 :            : };
     421                 :            : 
     422                 :            : typedef std::shared_ptr<const CTransaction> CTransactionRef;
     423                 :      37066 : template <typename Tx> static inline CTransactionRef MakeTransactionRef(Tx&& txIn) { return std::make_shared<const CTransaction>(std::forward<Tx>(txIn)); }
     424                 :            : 
     425                 :            : /** A generic txid reference (txid or wtxid). */
     426                 :            : class GenTxid
     427                 :            : {
     428                 :            :     bool m_is_wtxid;
     429                 :            :     uint256 m_hash;
     430                 :     110684 :     GenTxid(bool is_wtxid, const uint256& hash) : m_is_wtxid(is_wtxid), m_hash(hash) {}
     431                 :            : 
     432                 :            : public:
     433                 :      56912 :     static GenTxid Txid(const uint256& hash) { return GenTxid{false, hash}; }
     434                 :      53772 :     static GenTxid Wtxid(const uint256& hash) { return GenTxid{true, hash}; }
     435                 :     110684 :     bool IsWtxid() const { return m_is_wtxid; }
     436                 :     110684 :     const uint256& GetHash() const LIFETIMEBOUND { return m_hash; }
     437         [ #  # ]:          0 :     friend bool operator==(const GenTxid& a, const GenTxid& b) { return a.m_is_wtxid == b.m_is_wtxid && a.m_hash == b.m_hash; }
     438                 :          0 :     friend bool operator<(const GenTxid& a, const GenTxid& b) { return std::tie(a.m_is_wtxid, a.m_hash) < std::tie(b.m_is_wtxid, b.m_hash); }
     439                 :            : };
     440                 :            : 
     441                 :            : #endif // BITCOIN_PRIMITIVES_TRANSACTION_H

Generated by: LCOV version 1.14