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  bool IsFinalTx(const CTransaction &tx, int nBlockHeight, int64_t nBlockTime)
 18  {
 19      if (tx.nLockTime == 0)
 20          return true;
 21      if ((int64_t)tx.nLockTime < ((int64_t)tx.nLockTime < LOCKTIME_THRESHOLD ? (int64_t)nBlockHeight : nBlockTime))
 22          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      for (const auto& txin : tx.vin) {
 33          if (!(txin.nSequence == CTxIn::SEQUENCE_FINAL))
 34              return false;
 35      }
 36      return true;
 37  }
 38  
 39  std::pair<int, int64_t> CalculateSequenceLocks(const CTransaction &tx, int flags, std::vector<int>& prevHeights, const CBlockIndex& block)
 40  {
 41      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      int nMinHeight = -1;
 49      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      bool fEnforceBIP68 = static_cast<uint32_t>(tx.nVersion) >= 2
 55                        && flags & LOCKTIME_VERIFY_SEQUENCE;
 56  
 57      // Do not enforce sequence numbers as a relative lock time
 58      // unless we have been instructed to
 59      if (!fEnforceBIP68) {
 60          return std::make_pair(nMinHeight, nMinTime);
 61      }
 62  
 63      for (size_t txinIndex = 0; txinIndex < tx.vin.size(); txinIndex++) {
 64          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          if (txin.nSequence & CTxIn::SEQUENCE_LOCKTIME_DISABLE_FLAG) {
 70              // The height of this input is not relevant for sequence locks
 71              prevHeights[txinIndex] = 0;
 72              continue;
 73          }
 74  
 75          int nCoinHeight = prevHeights[txinIndex];
 76  
 77          if (txin.nSequence & CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG) {
 78              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              nMinTime = std::max(nMinTime, nCoinTime + (int64_t)((txin.nSequence & CTxIn::SEQUENCE_LOCKTIME_MASK) << CTxIn::SEQUENCE_LOCKTIME_GRANULARITY) - 1);
 93          } else {
 94              nMinHeight = std::max(nMinHeight, nCoinHeight + (int)(txin.nSequence & CTxIn::SEQUENCE_LOCKTIME_MASK) - 1);
 95          }
 96      }
 97  
 98      return std::make_pair(nMinHeight, nMinTime);
 99  }
100  
101  bool EvaluateSequenceLocks(const CBlockIndex& block, std::pair<int, int64_t> lockPair)
102  {
103      assert(block.pprev);
104      int64_t nBlockTime = block.pprev->GetMedianTimePast();
105      if (lockPair.first >= block.nHeight || lockPair.second >= nBlockTime)
106          return false;
107  
108      return true;
109  }
110  
111  bool SequenceLocks(const CTransaction &tx, int flags, std::vector<int>& prevHeights, const CBlockIndex& block)
112  {
113      return EvaluateSequenceLocks(block, CalculateSequenceLocks(tx, flags, prevHeights, block));
114  }
115  
116  unsigned int GetLegacySigOpCount(const CTransaction& tx)
117  {
118      unsigned int nSigOps = 0;
119      for (const auto& txin : tx.vin)
120      {
121          nSigOps += txin.scriptSig.GetSigOpCount(false);
122      }
123      for (const auto& txout : tx.vout)
124      {
125          nSigOps += txout.scriptPubKey.GetSigOpCount(false);
126      }
127      return nSigOps;
128  }
129  
130  unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewCache& inputs)
131  {
132      if (tx.IsCoinBase())
133          return 0;
134  
135      unsigned int nSigOps = 0;
136      for (unsigned int i = 0; i < tx.vin.size(); i++)
137      {
138          const Coin& coin = inputs.AccessCoin(tx.vin[i].prevout);
139          assert(!coin.IsSpent());
140          const CTxOut &prevout = coin.out;
141          if (prevout.scriptPubKey.IsPayToScriptHash())
142              nSigOps += prevout.scriptPubKey.GetSigOpCount(tx.vin[i].scriptSig);
143      }
144      return nSigOps;
145  }
146  
147  int64_t GetTransactionSigOpCost(const CTransaction& tx, const CCoinsViewCache& inputs, uint32_t flags)
148  {
149      int64_t nSigOps = GetLegacySigOpCount(tx) * WITNESS_SCALE_FACTOR;
150  
151      if (tx.IsCoinBase())
152          return nSigOps;
153  
154      if (flags & SCRIPT_VERIFY_P2SH) {
155          nSigOps += GetP2SHSigOpCount(tx, inputs) * WITNESS_SCALE_FACTOR;
156      }
157  
158      for (unsigned int i = 0; i < tx.vin.size(); i++)
159      {
160          const Coin& coin = inputs.AccessCoin(tx.vin[i].prevout);
161          assert(!coin.IsSpent());
162          const CTxOut &prevout = coin.out;
163          nSigOps += CountWitnessSigOps(tx.vin[i].scriptSig, prevout.scriptPubKey, &tx.vin[i].scriptWitness, flags);
164      }
165      return nSigOps;
166  }
167  
168  bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee)
169  {
170      // are the actual inputs available?
171      if (!inputs.HaveInputs(tx)) {
172          return state.Invalid(TxValidationResult::TX_MISSING_INPUTS, "bad-txns-inputs-missingorspent",
173                           strprintf("%s: inputs missing/spent", __func__));
174      }
175  
176      CAmount nValueIn = 0;
177      for (unsigned int i = 0; i < tx.vin.size(); ++i) {
178          const COutPoint &prevout = tx.vin[i].prevout;
179          const Coin& coin = inputs.AccessCoin(prevout);
180          assert(!coin.IsSpent());
181  
182          // If prev is coinbase, check that it's matured
183          if (coin.IsCoinBase() && nSpendHeight - coin.nHeight < COINBASE_MATURITY) {
184              return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND, "bad-txns-premature-spend-of-coinbase",
185                  strprintf("tried to spend coinbase at depth %d", nSpendHeight - coin.nHeight));
186          }
187  
188          // Check for negative or overflow input values
189          nValueIn += coin.out.nValue;
190          if (!MoneyRange(coin.out.nValue) || !MoneyRange(nValueIn)) {
191              return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-inputvalues-outofrange");
192          }
193      }
194  
195      const CAmount value_out = tx.GetValueOut();
196      if (nValueIn < value_out) {
197          return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-in-belowout",
198              strprintf("value in (%s) < value out (%s)", FormatMoney(nValueIn), FormatMoney(value_out)));
199      }
200  
201      // Tally transaction fees
202      const CAmount txfee_aux = nValueIn - value_out;
203      if (!MoneyRange(txfee_aux)) {
204          return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-fee-outofrange");
205      }
206  
207      txfee = txfee_aux;
208      return true;
209  }