Branch data 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 : 34493 : bool IsFinalTx(const CTransaction &tx, int nBlockHeight, int64_t nBlockTime)
18 : : {
19 [ + + ]: 34493 : if (tx.nLockTime == 0)
20 : 25021 : return true;
21 [ + + ][ + + ]: 9472 : if ((int64_t)tx.nLockTime < ((int64_t)tx.nLockTime < LOCKTIME_THRESHOLD ? (int64_t)nBlockHeight : nBlockTime))
22 : 6218 : 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 [ + + ]: 10753 : for (const auto& txin : tx.vin) {
33 [ + + ]: 7794 : if (!(txin.nSequence == CTxIn::SEQUENCE_FINAL))
34 : 295 : return false;
35 : : }
36 : 2959 : return true;
37 : 34493 : }
38 : :
39 : 21036 : std::pair<int, int64_t> CalculateSequenceLocks(const CTransaction &tx, int flags, std::vector<int>& prevHeights, const CBlockIndex& block)
40 : : {
41 [ + - ]: 21036 : 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 : 21036 : int nMinHeight = -1;
49 : 21036 : 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 : 42072 : bool fEnforceBIP68 = static_cast<uint32_t>(tx.nVersion) >= 2
55 [ - + ]: 21036 : && flags & LOCKTIME_VERIFY_SEQUENCE;
56 : :
57 : : // Do not enforce sequence numbers as a relative lock time
58 : : // unless we have been instructed to
59 [ + - ]: 21036 : if (!fEnforceBIP68) {
60 : 0 : return std::make_pair(nMinHeight, nMinTime);
61 : : }
62 : :
63 [ + + ]: 78313 : for (size_t txinIndex = 0; txinIndex < tx.vin.size(); txinIndex++) {
64 : 57277 : 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 [ + + ]: 57277 : if (txin.nSequence & CTxIn::SEQUENCE_LOCKTIME_DISABLE_FLAG) {
70 : : // The height of this input is not relevant for sequence locks
71 : 24035 : prevHeights[txinIndex] = 0;
72 : 24035 : continue;
73 : : }
74 : :
75 : 33242 : int nCoinHeight = prevHeights[txinIndex];
76 : :
77 [ + + ]: 33242 : if (txin.nSequence & CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG) {
78 : 525 : 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 : 525 : nMinTime = std::max(nMinTime, nCoinTime + (int64_t)((txin.nSequence & CTxIn::SEQUENCE_LOCKTIME_MASK) << CTxIn::SEQUENCE_LOCKTIME_GRANULARITY) - 1);
93 : 525 : } else {
94 : 32717 : nMinHeight = std::max(nMinHeight, nCoinHeight + (int)(txin.nSequence & CTxIn::SEQUENCE_LOCKTIME_MASK) - 1);
95 : : }
96 : 33242 : }
97 : :
98 : 21036 : return std::make_pair(nMinHeight, nMinTime);
99 : 21036 : }
100 : :
101 : 21036 : bool EvaluateSequenceLocks(const CBlockIndex& block, std::pair<int, int64_t> lockPair)
102 : : {
103 [ + - ]: 21036 : assert(block.pprev);
104 : 21036 : int64_t nBlockTime = block.pprev->GetMedianTimePast();
105 [ + + ][ + + ]: 21036 : if (lockPair.first >= block.nHeight || lockPair.second >= nBlockTime)
106 : 928 : return false;
107 : :
108 : 20108 : return true;
109 : 21036 : }
110 : :
111 : 0 : bool SequenceLocks(const CTransaction &tx, int flags, std::vector<int>& prevHeights, const CBlockIndex& block)
112 : : {
113 : 0 : return EvaluateSequenceLocks(block, CalculateSequenceLocks(tx, flags, prevHeights, block));
114 : : }
115 : :
116 : 21309 : unsigned int GetLegacySigOpCount(const CTransaction& tx)
117 : : {
118 : 21309 : unsigned int nSigOps = 0;
119 [ + + ]: 67975 : for (const auto& txin : tx.vin)
120 : : {
121 : 46666 : nSigOps += txin.scriptSig.GetSigOpCount(false);
122 : : }
123 [ + + ]: 237761 : for (const auto& txout : tx.vout)
124 : : {
125 : 216452 : nSigOps += txout.scriptPubKey.GetSigOpCount(false);
126 : : }
127 : 21309 : return nSigOps;
128 : : }
129 : :
130 : 20108 : unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewCache& inputs)
131 : : {
132 [ - + ]: 20108 : if (tx.IsCoinBase())
133 : 0 : return 0;
134 : :
135 : 20108 : unsigned int nSigOps = 0;
136 [ + + ]: 65573 : for (unsigned int i = 0; i < tx.vin.size(); i++)
137 : : {
138 : 45465 : const Coin& coin = inputs.AccessCoin(tx.vin[i].prevout);
139 [ + - ]: 45465 : assert(!coin.IsSpent());
140 : 45465 : const CTxOut &prevout = coin.out;
141 [ + - ]: 45465 : if (prevout.scriptPubKey.IsPayToScriptHash())
142 : 0 : nSigOps += prevout.scriptPubKey.GetSigOpCount(tx.vin[i].scriptSig);
143 : 45465 : }
144 : 20108 : return nSigOps;
145 : 20108 : }
146 : :
147 : 20508 : int64_t GetTransactionSigOpCost(const CTransaction& tx, const CCoinsViewCache& inputs, uint32_t flags)
148 : : {
149 : 20508 : int64_t nSigOps = GetLegacySigOpCount(tx) * WITNESS_SCALE_FACTOR;
150 : :
151 [ + + ]: 20508 : if (tx.IsCoinBase())
152 : 400 : return nSigOps;
153 : :
154 [ - + ]: 20108 : if (flags & SCRIPT_VERIFY_P2SH) {
155 : 20108 : nSigOps += GetP2SHSigOpCount(tx, inputs) * WITNESS_SCALE_FACTOR;
156 : 20108 : }
157 : :
158 [ + + ]: 65573 : for (unsigned int i = 0; i < tx.vin.size(); i++)
159 : : {
160 : 45465 : const Coin& coin = inputs.AccessCoin(tx.vin[i].prevout);
161 [ + - ]: 45465 : assert(!coin.IsSpent());
162 : 45465 : const CTxOut &prevout = coin.out;
163 : 45465 : nSigOps += CountWitnessSigOps(tx.vin[i].scriptSig, prevout.scriptPubKey, &tx.vin[i].scriptWitness, flags);
164 : 45465 : }
165 : 20108 : return nSigOps;
166 : 20508 : }
167 : :
168 : 21140 : bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee)
169 : : {
170 : : // are the actual inputs available?
171 [ - + ]: 21140 : 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 : 21140 : CAmount nValueIn = 0;
177 [ + + ]: 69043 : for (unsigned int i = 0; i < tx.vin.size(); ++i) {
178 : 47903 : const COutPoint &prevout = tx.vin[i].prevout;
179 : 47903 : const Coin& coin = inputs.AccessCoin(prevout);
180 [ + - ]: 47903 : assert(!coin.IsSpent());
181 : :
182 : : // If prev is coinbase, check that it's matured
183 [ + + ][ + - ]: 47903 : 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 : 47903 : nValueIn += coin.out.nValue;
190 [ + - ][ - + ]: 47903 : if (!MoneyRange(coin.out.nValue) || !MoneyRange(nValueIn)) {
191 [ # # ][ # # ]: 0 : return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-inputvalues-outofrange");
[ # # ]
192 : : }
193 : 47903 : }
194 : :
195 : 21140 : const CAmount value_out = tx.GetValueOut();
196 [ - + ]: 21140 : 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 : 21140 : const CAmount txfee_aux = nValueIn - value_out;
203 [ + - ]: 21140 : if (!MoneyRange(txfee_aux)) {
204 [ # # ][ # # ]: 0 : return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-fee-outofrange");
[ # # ]
205 : : }
206 : :
207 : 21140 : txfee = txfee_aux;
208 : 21140 : return true;
209 : 21140 : }
|
