Bitcoin Core  24.99.0
P2P Digital Currency
policy.cpp
Go to the documentation of this file.
1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2009-2021 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 // NOTE: This file is intended to be customised by the end user, and includes only local node policy logic
7 
8 #include <policy/policy.h>
9 
10 #include <coins.h>
11 #include <consensus/amount.h>
12 #include <consensus/consensus.h>
13 #include <consensus/validation.h>
14 #include <policy/feerate.h>
15 #include <primitives/transaction.h>
16 #include <script/interpreter.h>
17 #include <script/script.h>
18 #include <script/standard.h>
19 #include <serialize.h>
20 #include <span.h>
21 
22 #include <algorithm>
23 #include <cstddef>
24 #include <vector>
25 
26 CAmount GetDustThreshold(const CTxOut& txout, const CFeeRate& dustRelayFeeIn)
27 {
28  // "Dust" is defined in terms of dustRelayFee,
29  // which has units satoshis-per-kilobyte.
30  // If you'd pay more in fees than the value of the output
31  // to spend something, then we consider it dust.
32  // A typical spendable non-segwit txout is 34 bytes big, and will
33  // need a CTxIn of at least 148 bytes to spend:
34  // so dust is a spendable txout less than
35  // 182*dustRelayFee/1000 (in satoshis).
36  // 546 satoshis at the default rate of 3000 sat/kvB.
37  // A typical spendable segwit P2WPKH txout is 31 bytes big, and will
38  // need a CTxIn of at least 67 bytes to spend:
39  // so dust is a spendable txout less than
40  // 98*dustRelayFee/1000 (in satoshis).
41  // 294 satoshis at the default rate of 3000 sat/kvB.
42  if (txout.scriptPubKey.IsUnspendable())
43  return 0;
44 
45  size_t nSize = GetSerializeSize(txout);
46  int witnessversion = 0;
47  std::vector<unsigned char> witnessprogram;
48 
49  // Note this computation is for spending a Segwit v0 P2WPKH output (a 33 bytes
50  // public key + an ECDSA signature). For Segwit v1 Taproot outputs the minimum
51  // satisfaction is lower (a single BIP340 signature) but this computation was
52  // kept to not further reduce the dust level.
53  // See discussion in https://github.com/bitcoin/bitcoin/pull/22779 for details.
54  if (txout.scriptPubKey.IsWitnessProgram(witnessversion, witnessprogram)) {
55  // sum the sizes of the parts of a transaction input
56  // with 75% segwit discount applied to the script size.
57  nSize += (32 + 4 + 1 + (107 / WITNESS_SCALE_FACTOR) + 4);
58  } else {
59  nSize += (32 + 4 + 1 + 107 + 4); // the 148 mentioned above
60  }
61 
62  return dustRelayFeeIn.GetFee(nSize);
63 }
64 
65 bool IsDust(const CTxOut& txout, const CFeeRate& dustRelayFeeIn)
66 {
67  return (txout.nValue < GetDustThreshold(txout, dustRelayFeeIn));
68 }
69 
70 bool IsStandard(const CScript& scriptPubKey, const std::optional<unsigned>& max_datacarrier_bytes, TxoutType& whichType)
71 {
72  std::vector<std::vector<unsigned char> > vSolutions;
73  whichType = Solver(scriptPubKey, vSolutions);
74 
75  if (whichType == TxoutType::NONSTANDARD) {
76  return false;
77  } else if (whichType == TxoutType::MULTISIG) {
78  unsigned char m = vSolutions.front()[0];
79  unsigned char n = vSolutions.back()[0];
80  // Support up to x-of-3 multisig txns as standard
81  if (n < 1 || n > 3)
82  return false;
83  if (m < 1 || m > n)
84  return false;
85  } else if (whichType == TxoutType::NULL_DATA) {
86  if (!max_datacarrier_bytes || scriptPubKey.size() > *max_datacarrier_bytes) {
87  return false;
88  }
89  }
90 
91  return true;
92 }
93 
94 bool IsStandardTx(const CTransaction& tx, const std::optional<unsigned>& max_datacarrier_bytes, bool permit_bare_multisig, const CFeeRate& dust_relay_fee, std::string& reason)
95 {
96  if (tx.nVersion > TX_MAX_STANDARD_VERSION || tx.nVersion < 1) {
97  reason = "version";
98  return false;
99  }
100 
101  // Extremely large transactions with lots of inputs can cost the network
102  // almost as much to process as they cost the sender in fees, because
103  // computing signature hashes is O(ninputs*txsize). Limiting transactions
104  // to MAX_STANDARD_TX_WEIGHT mitigates CPU exhaustion attacks.
105  unsigned int sz = GetTransactionWeight(tx);
106  if (sz > MAX_STANDARD_TX_WEIGHT) {
107  reason = "tx-size";
108  return false;
109  }
110 
111  for (const CTxIn& txin : tx.vin)
112  {
113  // Biggest 'standard' txin involving only keys is a 15-of-15 P2SH
114  // multisig with compressed keys (remember the 520 byte limit on
115  // redeemScript size). That works out to a (15*(33+1))+3=513 byte
116  // redeemScript, 513+1+15*(73+1)+3=1627 bytes of scriptSig, which
117  // we round off to 1650(MAX_STANDARD_SCRIPTSIG_SIZE) bytes for
118  // some minor future-proofing. That's also enough to spend a
119  // 20-of-20 CHECKMULTISIG scriptPubKey, though such a scriptPubKey
120  // is not considered standard.
122  reason = "scriptsig-size";
123  return false;
124  }
125  if (!txin.scriptSig.IsPushOnly()) {
126  reason = "scriptsig-not-pushonly";
127  return false;
128  }
129  }
130 
131  unsigned int nDataOut = 0;
132  TxoutType whichType;
133  for (const CTxOut& txout : tx.vout) {
134  if (!::IsStandard(txout.scriptPubKey, max_datacarrier_bytes, whichType)) {
135  reason = "scriptpubkey";
136  return false;
137  }
138 
139  if (whichType == TxoutType::NULL_DATA)
140  nDataOut++;
141  else if ((whichType == TxoutType::MULTISIG) && (!permit_bare_multisig)) {
142  reason = "bare-multisig";
143  return false;
144  } else if (IsDust(txout, dust_relay_fee)) {
145  reason = "dust";
146  return false;
147  }
148  }
149 
150  // only one OP_RETURN txout is permitted
151  if (nDataOut > 1) {
152  reason = "multi-op-return";
153  return false;
154  }
155 
156  return true;
157 }
158 
177 bool AreInputsStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs)
178 {
179  if (tx.IsCoinBase()) {
180  return true; // Coinbases don't use vin normally
181  }
182 
183  for (unsigned int i = 0; i < tx.vin.size(); i++) {
184  const CTxOut& prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
185 
186  std::vector<std::vector<unsigned char> > vSolutions;
187  TxoutType whichType = Solver(prev.scriptPubKey, vSolutions);
188  if (whichType == TxoutType::NONSTANDARD || whichType == TxoutType::WITNESS_UNKNOWN) {
189  // WITNESS_UNKNOWN failures are typically also caught with a policy
190  // flag in the script interpreter, but it can be helpful to catch
191  // this type of NONSTANDARD transaction earlier in transaction
192  // validation.
193  return false;
194  } else if (whichType == TxoutType::SCRIPTHASH) {
195  std::vector<std::vector<unsigned char> > stack;
196  // convert the scriptSig into a stack, so we can inspect the redeemScript
197  if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker(), SigVersion::BASE))
198  return false;
199  if (stack.empty())
200  return false;
201  CScript subscript(stack.back().begin(), stack.back().end());
202  if (subscript.GetSigOpCount(true) > MAX_P2SH_SIGOPS) {
203  return false;
204  }
205  }
206  }
207 
208  return true;
209 }
210 
211 bool IsWitnessStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs)
212 {
213  if (tx.IsCoinBase())
214  return true; // Coinbases are skipped
215 
216  for (unsigned int i = 0; i < tx.vin.size(); i++)
217  {
218  // We don't care if witness for this input is empty, since it must not be bloated.
219  // If the script is invalid without witness, it would be caught sooner or later during validation.
220  if (tx.vin[i].scriptWitness.IsNull())
221  continue;
222 
223  const CTxOut &prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
224 
225  // get the scriptPubKey corresponding to this input:
226  CScript prevScript = prev.scriptPubKey;
227 
228  bool p2sh = false;
229  if (prevScript.IsPayToScriptHash()) {
230  std::vector <std::vector<unsigned char> > stack;
231  // If the scriptPubKey is P2SH, we try to extract the redeemScript casually by converting the scriptSig
232  // into a stack. We do not check IsPushOnly nor compare the hash as these will be done later anyway.
233  // If the check fails at this stage, we know that this txid must be a bad one.
234  if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker(), SigVersion::BASE))
235  return false;
236  if (stack.empty())
237  return false;
238  prevScript = CScript(stack.back().begin(), stack.back().end());
239  p2sh = true;
240  }
241 
242  int witnessversion = 0;
243  std::vector<unsigned char> witnessprogram;
244 
245  // Non-witness program must not be associated with any witness
246  if (!prevScript.IsWitnessProgram(witnessversion, witnessprogram))
247  return false;
248 
249  // Check P2WSH standard limits
250  if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE) {
251  if (tx.vin[i].scriptWitness.stack.back().size() > MAX_STANDARD_P2WSH_SCRIPT_SIZE)
252  return false;
253  size_t sizeWitnessStack = tx.vin[i].scriptWitness.stack.size() - 1;
254  if (sizeWitnessStack > MAX_STANDARD_P2WSH_STACK_ITEMS)
255  return false;
256  for (unsigned int j = 0; j < sizeWitnessStack; j++) {
257  if (tx.vin[i].scriptWitness.stack[j].size() > MAX_STANDARD_P2WSH_STACK_ITEM_SIZE)
258  return false;
259  }
260  }
261 
262  // Check policy limits for Taproot spends:
263  // - MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE limit for stack item size
264  // - No annexes
265  if (witnessversion == 1 && witnessprogram.size() == WITNESS_V1_TAPROOT_SIZE && !p2sh) {
266  // Taproot spend (non-P2SH-wrapped, version 1, witness program size 32; see BIP 341)
267  Span stack{tx.vin[i].scriptWitness.stack};
268  if (stack.size() >= 2 && !stack.back().empty() && stack.back()[0] == ANNEX_TAG) {
269  // Annexes are nonstandard as long as no semantics are defined for them.
270  return false;
271  }
272  if (stack.size() >= 2) {
273  // Script path spend (2 or more stack elements after removing optional annex)
274  const auto& control_block = SpanPopBack(stack);
275  SpanPopBack(stack); // Ignore script
276  if (control_block.empty()) return false; // Empty control block is invalid
277  if ((control_block[0] & TAPROOT_LEAF_MASK) == TAPROOT_LEAF_TAPSCRIPT) {
278  // Leaf version 0xc0 (aka Tapscript, see BIP 342)
279  for (const auto& item : stack) {
280  if (item.size() > MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE) return false;
281  }
282  }
283  } else if (stack.size() == 1) {
284  // Key path spend (1 stack element after removing optional annex)
285  // (no policy rules apply)
286  } else {
287  // 0 stack elements; this is already invalid by consensus rules
288  return false;
289  }
290  }
291  }
292  return true;
293 }
294 
295 int64_t GetVirtualTransactionSize(int64_t nWeight, int64_t nSigOpCost, unsigned int bytes_per_sigop)
296 {
297  return (std::max(nWeight, nSigOpCost * bytes_per_sigop) + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR;
298 }
299 
300 int64_t GetVirtualTransactionSize(const CTransaction& tx, int64_t nSigOpCost, unsigned int bytes_per_sigop)
301 {
302  return GetVirtualTransactionSize(GetTransactionWeight(tx), nSigOpCost, bytes_per_sigop);
303 }
304 
305 int64_t GetVirtualTransactionInputSize(const CTxIn& txin, int64_t nSigOpCost, unsigned int bytes_per_sigop)
306 {
307  return GetVirtualTransactionSize(GetTransactionInputWeight(txin), nSigOpCost, bytes_per_sigop);
308 }
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
CCoinsView that adds a memory cache for transactions to another CCoinsView.
Definition: coins.h:213
const Coin & AccessCoin(const COutPoint &output) const
Return a reference to Coin in the cache, or coinEmpty if not found.
Definition: coins.cpp:150
Fee rate in satoshis per kilovirtualbyte: CAmount / kvB.
Definition: feerate.h:33
CAmount GetFee(uint32_t num_bytes) const
Return the fee in satoshis for the given vsize in vbytes.
Definition: feerate.cpp:23
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:411
bool IsPushOnly(const_iterator pc) const
Called by IsStandardTx and P2SH/BIP62 VerifyScript (which makes it consensus-critical).
Definition: script.cpp:236
bool IsPayToScriptHash() const
Definition: script.cpp:201
bool IsUnspendable() const
Returns whether the script is guaranteed to fail at execution, regardless of the initial stack.
Definition: script.h:549
unsigned int GetSigOpCount(bool fAccurate) const
Pre-version-0.6, Bitcoin always counted CHECKMULTISIGs as 20 sigops.
Definition: script.cpp:153
bool IsWitnessProgram(int &version, std::vector< unsigned char > &program) const
Definition: script.cpp:220
The basic transaction that is broadcasted on the network and contained in blocks.
Definition: transaction.h:288
const std::vector< CTxOut > vout
Definition: transaction.h:299
bool IsCoinBase() const
Definition: transaction.h:343
const int32_t nVersion
Definition: transaction.h:300
const std::vector< CTxIn > vin
Definition: transaction.h:298
An input of a transaction.
Definition: transaction.h:74
CScript scriptSig
Definition: transaction.h:77
An output of a transaction.
Definition: transaction.h:157
CScript scriptPubKey
Definition: transaction.h:160
CAmount nValue
Definition: transaction.h:159
CTxOut out
unspent transaction output
Definition: coins.h:34
A Span is an object that can refer to a contiguous sequence of objects.
Definition: span.h:97
size_type size() const
Definition: prevector.h:284
static int64_t GetTransactionInputWeight(const CTxIn &txin)
Definition: validation.h:156
static int64_t GetTransactionWeight(const CTransaction &tx)
Definition: validation.h:148
static const int WITNESS_SCALE_FACTOR
Definition: consensus.h:21
bool EvalScript(std::vector< std::vector< unsigned char > > &stack, const CScript &script, unsigned int flags, const BaseSignatureChecker &checker, SigVersion sigversion, ScriptExecutionData &execdata, ScriptError *serror)
@ BASE
Bare scripts and BIP16 P2SH-wrapped redeemscripts.
@ SCRIPT_VERIFY_NONE
Definition: interpreter.h:44
static constexpr uint8_t TAPROOT_LEAF_MASK
Definition: interpreter.h:229
static constexpr uint8_t TAPROOT_LEAF_TAPSCRIPT
Definition: interpreter.h:230
static constexpr size_t WITNESS_V0_SCRIPTHASH_SIZE
Signature hash sizes.
Definition: interpreter.h:225
static constexpr size_t WITNESS_V1_TAPROOT_SIZE
Definition: interpreter.h:227
bool IsStandard(const CScript &scriptPubKey, const std::optional< unsigned > &max_datacarrier_bytes, TxoutType &whichType)
Definition: policy.cpp:70
bool AreInputsStandard(const CTransaction &tx, const CCoinsViewCache &mapInputs)
Check transaction inputs to mitigate two potential denial-of-service attacks:
Definition: policy.cpp:177
CAmount GetDustThreshold(const CTxOut &txout, const CFeeRate &dustRelayFeeIn)
Definition: policy.cpp:26
int64_t GetVirtualTransactionSize(int64_t nWeight, int64_t nSigOpCost, unsigned int bytes_per_sigop)
Compute the virtual transaction size (weight reinterpreted as bytes).
Definition: policy.cpp:295
int64_t GetVirtualTransactionInputSize(const CTxIn &txin, int64_t nSigOpCost, unsigned int bytes_per_sigop)
Definition: policy.cpp:305
bool IsWitnessStandard(const CTransaction &tx, const CCoinsViewCache &mapInputs)
Check if the transaction is over standard P2WSH resources limit: 3600bytes witnessScript size,...
Definition: policy.cpp:211
bool IsStandardTx(const CTransaction &tx, const std::optional< unsigned > &max_datacarrier_bytes, bool permit_bare_multisig, const CFeeRate &dust_relay_fee, std::string &reason)
Check for standard transaction types.
Definition: policy.cpp:94
bool IsDust(const CTxOut &txout, const CFeeRate &dustRelayFeeIn)
Definition: policy.cpp:65
static constexpr unsigned int MAX_STANDARD_P2WSH_STACK_ITEMS
The maximum number of witness stack items in a standard P2WSH script.
Definition: policy.h:41
static constexpr unsigned int MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE
The maximum size in bytes of each witness stack item in a standard BIP 342 script (Taproot,...
Definition: policy.h:45
static constexpr unsigned int MAX_STANDARD_TX_WEIGHT
The maximum weight for transactions we're willing to relay/mine.
Definition: policy.h:27
static constexpr unsigned int MAX_STANDARD_P2WSH_STACK_ITEM_SIZE
The maximum size in bytes of each witness stack item in a standard P2WSH script.
Definition: policy.h:43
static constexpr decltype(CTransaction::nVersion) TX_MAX_STANDARD_VERSION
Definition: policy.h:114
static constexpr unsigned int MAX_P2SH_SIGOPS
Maximum number of signature check operations in an IsStandard() P2SH script.
Definition: policy.h:31
static constexpr unsigned int MAX_STANDARD_P2WSH_SCRIPT_SIZE
The maximum size in bytes of a standard witnessScript.
Definition: policy.h:47
static constexpr unsigned int MAX_STANDARD_SCRIPTSIG_SIZE
The maximum size of a standard ScriptSig.
Definition: policy.h:49
static constexpr unsigned int ANNEX_TAG
Definition: script.h:54
size_t GetSerializeSize(const T &t, int nVersion=0)
Definition: serialize.h:1109
T & SpanPopBack(Span< T > &span)
Pop the last element off a span, and return a reference to that element.
Definition: span.h:237
TxoutType Solver(const CScript &scriptPubKey, std::vector< std::vector< unsigned char >> &vSolutionsRet)
Parse a scriptPubKey and identify script type for standard scripts.
Definition: standard.cpp:168
TxoutType
Definition: standard.h:51
@ WITNESS_UNKNOWN
Only for Witness versions not already defined above.
@ NULL_DATA
unspendable OP_RETURN script that carries data