Bitcoin Core  0.18.99
P2P Digital Currency
tx_verify.cpp
Go to the documentation of this file.
1 // Copyright (c) 2017-2018 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 <consensus/consensus.h>
9 #include <script/interpreter.h>
10 #include <consensus/validation.h>
11 
12 // TODO remove the following dependencies
13 #include <chain.h>
14 #include <coins.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  for (const auto& txin : tx.vin) {
24  if (!(txin.nSequence == CTxIn::SEQUENCE_FINAL))
25  return false;
26  }
27  return true;
28 }
29 
30 std::pair<int, int64_t> CalculateSequenceLocks(const CTransaction &tx, int flags, std::vector<int>* prevHeights, const CBlockIndex& block)
31 {
32  assert(prevHeights->size() == tx.vin.size());
33 
34  // Will be set to the equivalent height- and time-based nLockTime
35  // values that would be necessary to satisfy all relative lock-
36  // time constraints given our view of block chain history.
37  // The semantics of nLockTime are the last invalid height/time, so
38  // use -1 to have the effect of any height or time being valid.
39  int nMinHeight = -1;
40  int64_t nMinTime = -1;
41 
42  // tx.nVersion is signed integer so requires cast to unsigned otherwise
43  // we would be doing a signed comparison and half the range of nVersion
44  // wouldn't support BIP 68.
45  bool fEnforceBIP68 = static_cast<uint32_t>(tx.nVersion) >= 2
46  && flags & LOCKTIME_VERIFY_SEQUENCE;
47 
48  // Do not enforce sequence numbers as a relative lock time
49  // unless we have been instructed to
50  if (!fEnforceBIP68) {
51  return std::make_pair(nMinHeight, nMinTime);
52  }
53 
54  for (size_t txinIndex = 0; txinIndex < tx.vin.size(); txinIndex++) {
55  const CTxIn& txin = tx.vin[txinIndex];
56 
57  // Sequence numbers with the most significant bit set are not
58  // treated as relative lock-times, nor are they given any
59  // consensus-enforced meaning at this point.
61  // The height of this input is not relevant for sequence locks
62  (*prevHeights)[txinIndex] = 0;
63  continue;
64  }
65 
66  int nCoinHeight = (*prevHeights)[txinIndex];
67 
69  int64_t nCoinTime = block.GetAncestor(std::max(nCoinHeight-1, 0))->GetMedianTimePast();
70  // NOTE: Subtract 1 to maintain nLockTime semantics
71  // BIP 68 relative lock times have the semantics of calculating
72  // the first block or time at which the transaction would be
73  // valid. When calculating the effective block time or height
74  // for the entire transaction, we switch to using the
75  // semantics of nLockTime which is the last invalid block
76  // time or height. Thus we subtract 1 from the calculated
77  // time or height.
78 
79  // Time-based relative lock-times are measured from the
80  // smallest allowed timestamp of the block containing the
81  // txout being spent, which is the median time past of the
82  // block prior.
83  nMinTime = std::max(nMinTime, nCoinTime + (int64_t)((txin.nSequence & CTxIn::SEQUENCE_LOCKTIME_MASK) << CTxIn::SEQUENCE_LOCKTIME_GRANULARITY) - 1);
84  } else {
85  nMinHeight = std::max(nMinHeight, nCoinHeight + (int)(txin.nSequence & CTxIn::SEQUENCE_LOCKTIME_MASK) - 1);
86  }
87  }
88 
89  return std::make_pair(nMinHeight, nMinTime);
90 }
91 
92 bool EvaluateSequenceLocks(const CBlockIndex& block, std::pair<int, int64_t> lockPair)
93 {
94  assert(block.pprev);
95  int64_t nBlockTime = block.pprev->GetMedianTimePast();
96  if (lockPair.first >= block.nHeight || lockPair.second >= nBlockTime)
97  return false;
98 
99  return true;
100 }
101 
102 bool SequenceLocks(const CTransaction &tx, int flags, std::vector<int>* prevHeights, const CBlockIndex& block)
103 {
104  return EvaluateSequenceLocks(block, CalculateSequenceLocks(tx, flags, prevHeights, block));
105 }
106 
107 unsigned int GetLegacySigOpCount(const CTransaction& tx)
108 {
109  unsigned int nSigOps = 0;
110  for (const auto& txin : tx.vin)
111  {
112  nSigOps += txin.scriptSig.GetSigOpCount(false);
113  }
114  for (const auto& txout : tx.vout)
115  {
116  nSigOps += txout.scriptPubKey.GetSigOpCount(false);
117  }
118  return nSigOps;
119 }
120 
121 unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewCache& inputs)
122 {
123  if (tx.IsCoinBase())
124  return 0;
125 
126  unsigned int nSigOps = 0;
127  for (unsigned int i = 0; i < tx.vin.size(); i++)
128  {
129  const Coin& coin = inputs.AccessCoin(tx.vin[i].prevout);
130  assert(!coin.IsSpent());
131  const CTxOut &prevout = coin.out;
132  if (prevout.scriptPubKey.IsPayToScriptHash())
133  nSigOps += prevout.scriptPubKey.GetSigOpCount(tx.vin[i].scriptSig);
134  }
135  return nSigOps;
136 }
137 
138 int64_t GetTransactionSigOpCost(const CTransaction& tx, const CCoinsViewCache& inputs, int flags)
139 {
140  int64_t nSigOps = GetLegacySigOpCount(tx) * WITNESS_SCALE_FACTOR;
141 
142  if (tx.IsCoinBase())
143  return nSigOps;
144 
145  if (flags & SCRIPT_VERIFY_P2SH) {
146  nSigOps += GetP2SHSigOpCount(tx, inputs) * WITNESS_SCALE_FACTOR;
147  }
148 
149  for (unsigned int i = 0; i < tx.vin.size(); i++)
150  {
151  const Coin& coin = inputs.AccessCoin(tx.vin[i].prevout);
152  assert(!coin.IsSpent());
153  const CTxOut &prevout = coin.out;
154  nSigOps += CountWitnessSigOps(tx.vin[i].scriptSig, prevout.scriptPubKey, &tx.vin[i].scriptWitness, flags);
155  }
156  return nSigOps;
157 }
158 
159 bool Consensus::CheckTxInputs(const CTransaction& tx, CValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee)
160 {
161  // are the actual inputs available?
162  if (!inputs.HaveInputs(tx)) {
163  return state.Invalid(ValidationInvalidReason::TX_MISSING_INPUTS, false, REJECT_INVALID, "bad-txns-inputs-missingorspent",
164  strprintf("%s: inputs missing/spent", __func__));
165  }
166 
167  CAmount nValueIn = 0;
168  for (unsigned int i = 0; i < tx.vin.size(); ++i) {
169  const COutPoint &prevout = tx.vin[i].prevout;
170  const Coin& coin = inputs.AccessCoin(prevout);
171  assert(!coin.IsSpent());
172 
173  // If prev is coinbase, check that it's matured
174  if (coin.IsCoinBase() && nSpendHeight - coin.nHeight < COINBASE_MATURITY) {
175  return state.Invalid(ValidationInvalidReason::TX_PREMATURE_SPEND, false, REJECT_INVALID, "bad-txns-premature-spend-of-coinbase",
176  strprintf("tried to spend coinbase at depth %d", nSpendHeight - coin.nHeight));
177  }
178 
179  // Check for negative or overflow input values
180  nValueIn += coin.out.nValue;
181  if (!MoneyRange(coin.out.nValue) || !MoneyRange(nValueIn)) {
182  return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-txns-inputvalues-outofrange");
183  }
184  }
185 
186  const CAmount value_out = tx.GetValueOut();
187  if (nValueIn < value_out) {
188  return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-txns-in-belowout",
189  strprintf("value in (%s) < value out (%s)", FormatMoney(nValueIn), FormatMoney(value_out)));
190  }
191 
192  // Tally transaction fees
193  const CAmount txfee_aux = nValueIn - value_out;
194  if (!MoneyRange(txfee_aux)) {
195  return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-txns-fee-outofrange");
196  }
197 
198  txfee = txfee_aux;
199  return true;
200 }
unsigned int GetSigOpCount(bool fAccurate) const
Pre-version-0.6, Bitcoin always counted CHECKMULTISIGs as 20 sigops.
Definition: script.cpp:148
CAmount nValue
Definition: transaction.h:136
bool IsSpent() const
Definition: coins.h:76
static constexpr unsigned int LOCKTIME_VERIFY_SEQUENCE
Flags for nSequence and nLockTime locks.
Definition: consensus.h:28
bool IsCoinBase() const
Definition: coins.h:55
invalid by consensus rules (excluding any below reasons)
static const int WITNESS_SCALE_FACTOR
Definition: consensus.h:21
std::pair< int, int64_t > CalculateSequenceLocks(const CTransaction &tx, int flags, std::vector< int > *prevHeights, const CBlockIndex &block)
Calculates the block height and previous block&#39;s median time past at which the transaction will be co...
Definition: tx_verify.cpp:30
CScript scriptPubKey
Definition: transaction.h:137
CBlockIndex * pprev
pointer to the index of the predecessor of this block
Definition: chain.h:146
const Coin & AccessCoin(const COutPoint &output) const
Return a reference to Coin in the cache, or a pruned one if not found.
Definition: coins.cpp:118
bool SequenceLocks(const CTransaction &tx, int flags, std::vector< int > *prevHeights, const CBlockIndex &block)
Check if transaction is final per BIP 68 sequence numbers and can be included in a block...
Definition: tx_verify.cpp:102
A UTXO entry.
Definition: coins.h:30
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1067
size_t CountWitnessSigOps(const CScript &scriptSig, const CScript &scriptPubKey, const CScriptWitness *witness, unsigned int flags)
static const uint32_t SEQUENCE_FINAL
Definition: transaction.h:73
bool MoneyRange(const CAmount &nValue)
Definition: amount.h:26
static const uint32_t SEQUENCE_LOCKTIME_DISABLE_FLAG
Definition: transaction.h:78
CTxOut out
unspent transaction output
Definition: coins.h:34
static const int COINBASE_MATURITY
Coinbase transaction outputs can only be spent after this number of new blocks (network rule) ...
Definition: consensus.h:19
static const int SEQUENCE_LOCKTIME_GRANULARITY
Definition: transaction.h:96
std::string FormatMoney(const CAmount &n)
Money parsing/formatting utilities.
Definition: moneystr.cpp:12
bool HaveInputs(const CTransaction &tx) const
Check whether all prevouts of the transaction are present in the UTXO set represented by this view...
Definition: coins.cpp:237
static const unsigned char REJECT_INVALID
Definition: validation.h:17
bool IsCoinBase() const
Definition: transaction.h:337
const std::vector< CTxIn > vin
Definition: transaction.h:287
CAmount GetValueOut() const
Definition: transaction.cpp:83
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
uint32_t nHeight
at which height this containing transaction was included in the active block chain ...
Definition: coins.h:40
An input of a transaction.
Definition: transaction.h:63
bool CheckTxInputs(const CTransaction &tx, CValidationState &state, const CCoinsViewCache &inputs, int nSpendHeight, CAmount &txfee)
Check whether all inputs of this transaction are valid (no double spends and amounts) This does not m...
Definition: tx_verify.cpp:159
const std::vector< CTxOut > vout
Definition: transaction.h:288
bool EvaluateSequenceLocks(const CBlockIndex &block, std::pair< int, int64_t > lockPair)
Definition: tx_verify.cpp:92
transaction spends a coinbase too early, or violates locktime/sequence locks
An output of a transaction.
Definition: transaction.h:133
static const uint32_t SEQUENCE_LOCKTIME_TYPE_FLAG
Definition: transaction.h:83
An outpoint - a combination of a transaction hash and an index n into its vout.
Definition: transaction.h:18
int64_t GetMedianTimePast() const
Definition: chain.h:287
int flags
Definition: bitcoin-tx.cpp:509
Capture information about block/transaction validation.
Definition: validation.h:98
const int32_t nVersion
Definition: transaction.h:289
bool Invalid(ValidationInvalidReason reasonIn, bool ret=false, unsigned int chRejectCodeIn=0, const std::string &strRejectReasonIn="", const std::string &strDebugMessageIn="")
Definition: validation.h:111
static const uint32_t SEQUENCE_LOCKTIME_MASK
Definition: transaction.h:87
unsigned int GetLegacySigOpCount(const CTransaction &tx)
Auxiliary functions for transaction validation (ideally should not be exposed)
Definition: tx_verify.cpp:107
The block chain is a tree shaped structure starting with the genesis block at the root...
Definition: chain.h:139
uint32_t nSequence
Definition: transaction.h:68
unsigned int GetP2SHSigOpCount(const CTransaction &tx, const CCoinsViewCache &inputs)
Count ECDSA signature operations in pay-to-script-hash inputs.
Definition: tx_verify.cpp:121
a transaction was missing some of its inputs
bool IsFinalTx(const CTransaction &tx, int nBlockHeight, int64_t nBlockTime)
Check if transaction is final and can be included in a block with the specified height and time...
Definition: tx_verify.cpp:17
static const unsigned int LOCKTIME_THRESHOLD
Definition: script.h:39
The basic transaction that is broadcasted on the network and contained in blocks. ...
Definition: transaction.h:270
int nHeight
height of the entry in the chain. The genesis block has height 0
Definition: chain.h:152
CCoinsView that adds a memory cache for transactions to another CCoinsView.
Definition: coins.h:202
CBlockIndex * GetAncestor(int height)
Efficiently find an ancestor of this block.
Definition: chain.cpp:111
int64_t GetTransactionSigOpCost(const CTransaction &tx, const CCoinsViewCache &inputs, int flags)
Compute total signature operation cost of a transaction.
Definition: tx_verify.cpp:138
const uint32_t nLockTime
Definition: transaction.h:290