Line data    Source code

       1             : // Copyright (c) 2017-2021 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 <consensus/tx_verify.h>
       6             : 
       7             : #include <chain.h>
       8             : #include <coins.h>
       9             : #include <consensus/amount.h>
      10             : #include <consensus/consensus.h>
      11             : #include <consensus/validation.h>
      12             : #include <primitives/transaction.h>
      13             : #include <script/interpreter.h>
      14             : #include <util/check.h>
      15             : #include <util/moneystr.h>
      16             : 
      17       22672 : bool IsFinalTx(const CTransaction &tx, int nBlockHeight, int64_t nBlockTime)
      18             : {
      19       22672 :     if (tx.nLockTime == 0)
      20       14990 :         return true;
      21        7682 :     if ((int64_t)tx.nLockTime < ((int64_t)tx.nLockTime < LOCKTIME_THRESHOLD ? (int64_t)nBlockHeight : nBlockTime))
      22         363 :         return true;
      23             : 
      24             :     // Even if tx.nLockTime isn't satisfied by nBlockHeight/nBlockTime, a
      25             :     // transaction is still considered final if all inputs' nSequence ==
      26             :     // SEQUENCE_FINAL (0xffffffff), in which case nLockTime is ignored.
      27             :     //
      28             :     // Because of this behavior OP_CHECKLOCKTIMEVERIFY/CheckLockTime() will
      29             :     // also check that the spending input's nSequence != SEQUENCE_FINAL,
      30             :     // ensuring that an unsatisfied nLockTime value will actually cause
      31             :     // IsFinalTx() to return false here:
      32       13681 :     for (const auto& txin : tx.vin) {
      33       10295 :         if (!(txin.nSequence == CTxIn::SEQUENCE_FINAL))
      34        3933 :             return false;
      35             :     }
      36        3386 :     return true;
      37       22672 : }
      38             : 
      39        7372 : std::pair<int, int64_t> CalculateSequenceLocks(const CTransaction &tx, int flags, std::vector<int>& prevHeights, const CBlockIndex& block)
      40             : {
      41        7372 :     assert(prevHeights.size() == tx.vin.size());
      42             : 
      43             :     // Will be set to the equivalent height- and time-based nLockTime
      44             :     // values that would be necessary to satisfy all relative lock-
      45             :     // time constraints given our view of block chain history.
      46             :     // The semantics of nLockTime are the last invalid height/time, so
      47             :     // use -1 to have the effect of any height or time being valid.
      48        7372 :     int nMinHeight = -1;
      49        7372 :     int64_t nMinTime = -1;
      50             : 
      51             :     // tx.nVersion is signed integer so requires cast to unsigned otherwise
      52             :     // we would be doing a signed comparison and half the range of nVersion
      53             :     // wouldn't support BIP 68.
      54       14744 :     bool fEnforceBIP68 = static_cast<uint32_t>(tx.nVersion) >= 2
      55        7372 :                       && flags & LOCKTIME_VERIFY_SEQUENCE;
      56             : 
      57             :     // Do not enforce sequence numbers as a relative lock time
      58             :     // unless we have been instructed to
      59        7372 :     if (!fEnforceBIP68) {
      60           0 :         return std::make_pair(nMinHeight, nMinTime);
      61             :     }
      62             : 
      63       85711 :     for (size_t txinIndex = 0; txinIndex < tx.vin.size(); txinIndex++) {
      64       78339 :         const CTxIn& txin = tx.vin[txinIndex];
      65             : 
      66             :         // Sequence numbers with the most significant bit set are not
      67             :         // treated as relative lock-times, nor are they given any
      68             :         // consensus-enforced meaning at this point.
      69       78339 :         if (txin.nSequence & CTxIn::SEQUENCE_LOCKTIME_DISABLE_FLAG) {
      70             :             // The height of this input is not relevant for sequence locks
      71       35672 :             prevHeights[txinIndex] = 0;
      72       35672 :             continue;
      73             :         }
      74           2 : 
      75       42667 :         int nCoinHeight = prevHeights[txinIndex];
      76             : 
      77       42667 :         if (txin.nSequence & CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG) {
      78        1772 :             const int64_t nCoinTime{Assert(block.GetAncestor(std::max(nCoinHeight - 1, 0)))->GetMedianTimePast()};
      79             :             // NOTE: Subtract 1 to maintain nLockTime semantics
      80             :             // BIP 68 relative lock times have the semantics of calculating
      81             :             // the first block or time at which the transaction would be
      82             :             // valid. When calculating the effective block time or height
      83             :             // for the entire transaction, we switch to using the
      84             :             // semantics of nLockTime which is the last invalid block
      85             :             // time or height.  Thus we subtract 1 from the calculated
      86             :             // time or height.
      87             : 
      88             :             // Time-based relative lock-times are measured from the
      89             :             // smallest allowed timestamp of the block containing the
      90             :             // txout being spent, which is the median time past of the
      91             :             // block prior.
      92        1772 :             nMinTime = std::max(nMinTime, nCoinTime + (int64_t)((txin.nSequence & CTxIn::SEQUENCE_LOCKTIME_MASK) << CTxIn::SEQUENCE_LOCKTIME_GRANULARITY) - 1);
      93        1772 :         } else {
      94       40895 :             nMinHeight = std::max(nMinHeight, nCoinHeight + (int)(txin.nSequence & CTxIn::SEQUENCE_LOCKTIME_MASK) - 1);
      95             :         }
      96       42667 :     }
      97             : 
      98        7372 :     return std::make_pair(nMinHeight, nMinTime);
      99        7372 : }
     100             : 
     101        7372 : bool EvaluateSequenceLocks(const CBlockIndex& block, std::pair<int, int64_t> lockPair)
     102             : {
     103        7372 :     assert(block.pprev);
     104        7372 :     int64_t nBlockTime = block.pprev->GetMedianTimePast();
     105        7372 :     if (lockPair.first >= block.nHeight || lockPair.second >= nBlockTime)
     106        1510 :         return false;
     107             : 
     108        5862 :     return true;
     109        7372 : }
     110             : 
     111         815 : bool SequenceLocks(const CTransaction &tx, int flags, std::vector<int>& prevHeights, const CBlockIndex& block)
     112             : {
     113         815 :     return EvaluateSequenceLocks(block, CalculateSequenceLocks(tx, flags, prevHeights, block));
     114             : }
     115             : 
     116       28129 : unsigned int GetLegacySigOpCount(const CTransaction& tx)
     117             : {
     118       28129 :     unsigned int nSigOps = 0;
     119       75426 :     for (const auto& txin : tx.vin)
     120             :     {
     121       47297 :         nSigOps += txin.scriptSig.GetSigOpCount(false);
     122             :     }
     123      165983 :     for (const auto& txout : tx.vout)
     124             :     {
     125      137854 :         nSigOps += txout.scriptPubKey.GetSigOpCount(false);
     126             :     }
     127       28129 :     return nSigOps;
     128             : }
     129             : 
     130        5862 : unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewCache& inputs)
     131             : {
     132        5862 :     if (tx.IsCoinBase())
     133           0 :         return 0;
     134             : 
     135        5862 :     unsigned int nSigOps = 0;
     136       30344 :     for (unsigned int i = 0; i < tx.vin.size(); i++)
     137             :     {
     138       24482 :         const Coin& coin = inputs.AccessCoin(tx.vin[i].prevout);
     139       24482 :         assert(!coin.IsSpent());
     140       24482 :         const CTxOut &prevout = coin.out;
     141       24482 :         if (prevout.scriptPubKey.IsPayToScriptHash())
     142           0 :             nSigOps += prevout.scriptPubKey.GetSigOpCount(tx.vin[i].scriptSig);
     143       24482 :     }
     144        5862 :     return nSigOps;
     145        5862 : }
     146             : 
     147       11121 : int64_t GetTransactionSigOpCost(const CTransaction& tx, const CCoinsViewCache& inputs, uint32_t flags)
     148             : {
     149       11121 :     int64_t nSigOps = GetLegacySigOpCount(tx) * WITNESS_SCALE_FACTOR;
     150             : 
     151       11121 :     if (tx.IsCoinBase())
     152        5259 :         return nSigOps;
     153             : 
     154        5862 :     if (flags & SCRIPT_VERIFY_P2SH) {
     155        5862 :         nSigOps += GetP2SHSigOpCount(tx, inputs) * WITNESS_SCALE_FACTOR;
     156        5862 :     }
     157             : 
     158       30344 :     for (unsigned int i = 0; i < tx.vin.size(); i++)
     159             :     {
     160       24482 :         const Coin& coin = inputs.AccessCoin(tx.vin[i].prevout);
     161       24482 :         assert(!coin.IsSpent());
     162       24482 :         const CTxOut &prevout = coin.out;
     163       24482 :         nSigOps += CountWitnessSigOps(tx.vin[i].scriptSig, prevout.scriptPubKey, &tx.vin[i].scriptWitness, flags);
     164       24482 :     }
     165        5862 :     return nSigOps;
     166       11121 : }
     167             : 
     168        7867 : bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee)
     169             : {
     170             :     // are the actual inputs available?
     171        7867 :     if (!inputs.HaveInputs(tx)) {
     172           0 :         return state.Invalid(TxValidationResult::TX_MISSING_INPUTS, "bad-txns-inputs-missingorspent",
     173           0 :                          strprintf("%s: inputs missing/spent", __func__));
     174             :     }
     175             : 
     176        7867 :     CAmount nValueIn = 0;
     177       36658 :     for (unsigned int i = 0; i < tx.vin.size(); ++i) {
     178       28791 :         const COutPoint &prevout = tx.vin[i].prevout;
     179       28791 :         const Coin& coin = inputs.AccessCoin(prevout);
     180       28791 :         assert(!coin.IsSpent());
     181             : 
     182             :         // If prev is coinbase, check that it's matured
     183       28791 :         if (coin.IsCoinBase() && nSpendHeight - coin.nHeight < COINBASE_MATURITY) {
     184           0 :             return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND, "bad-txns-premature-spend-of-coinbase",
     185           0 :                 strprintf("tried to spend coinbase at depth %d", nSpendHeight - coin.nHeight));
     186             :         }
     187             : 
     188             :         // Check for negative or overflow input values
     189       28791 :         nValueIn += coin.out.nValue;
     190       28791 :         if (!MoneyRange(coin.out.nValue) || !MoneyRange(nValueIn)) {
     191           0 :             return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-inputvalues-outofrange");
     192             :         }
     193       28791 :     }
     194             : 
     195        7867 :     const CAmount value_out = tx.GetValueOut();
     196        7867 :     if (nValueIn < value_out) {
     197           0 :         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-in-belowout",
     198           0 :             strprintf("value in (%s) < value out (%s)", FormatMoney(nValueIn), FormatMoney(value_out)));
     199             :     }
     200             : 
     201             :     // Tally transaction fees
     202        7867 :     const CAmount txfee_aux = nValueIn - value_out;
     203        7867 :     if (!MoneyRange(txfee_aux)) {
     204           0 :         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-fee-outofrange");
     205             :     }
     206             : 
     207        7867 :     txfee = txfee_aux;
     208        7867 :     return true;
     209        7867 : }