Bitcoin Core 29.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-present 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>
14#include <policy/feerate.h>
16#include <script/interpreter.h>
17#include <script/script.h>
18#include <script/solver.h>
19#include <serialize.h>
20#include <span.h>
21
22#include <algorithm>
23#include <cstddef>
24#include <vector>
25
26CAmount 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
65bool IsDust(const CTxOut& txout, const CFeeRate& dustRelayFeeIn)
66{
67 return (txout.nValue < GetDustThreshold(txout, dustRelayFeeIn));
68}
69
70std::vector<uint32_t> GetDust(const CTransaction& tx, CFeeRate dust_relay_rate)
71{
72 std::vector<uint32_t> dust_outputs;
73 for (uint32_t i{0}; i < tx.vout.size(); ++i) {
74 if (IsDust(tx.vout[i], dust_relay_rate)) dust_outputs.push_back(i);
75 }
76 return dust_outputs;
77}
78
79bool IsStandard(const CScript& scriptPubKey, TxoutType& whichType)
80{
81 std::vector<std::vector<unsigned char> > vSolutions;
82 whichType = Solver(scriptPubKey, vSolutions);
83
84 if (whichType == TxoutType::NONSTANDARD) {
85 return false;
86 } else if (whichType == TxoutType::MULTISIG) {
87 unsigned char m = vSolutions.front()[0];
88 unsigned char n = vSolutions.back()[0];
89 // Support up to x-of-3 multisig txns as standard
90 if (n < 1 || n > 3)
91 return false;
92 if (m < 1 || m > n)
93 return false;
94 }
95
96 return true;
97}
98
99bool IsStandardTx(const CTransaction& tx, const std::optional<unsigned>& max_datacarrier_bytes, bool permit_bare_multisig, const CFeeRate& dust_relay_fee, std::string& reason)
100{
102 reason = "version";
103 return false;
104 }
105
106 // Extremely large transactions with lots of inputs can cost the network
107 // almost as much to process as they cost the sender in fees, because
108 // computing signature hashes is O(ninputs*txsize). Limiting transactions
109 // to MAX_STANDARD_TX_WEIGHT mitigates CPU exhaustion attacks.
110 unsigned int sz = GetTransactionWeight(tx);
111 if (sz > MAX_STANDARD_TX_WEIGHT) {
112 reason = "tx-size";
113 return false;
114 }
115
116 for (const CTxIn& txin : tx.vin)
117 {
118 // Biggest 'standard' txin involving only keys is a 15-of-15 P2SH
119 // multisig with compressed keys (remember the MAX_SCRIPT_ELEMENT_SIZE byte limit on
120 // redeemScript size). That works out to a (15*(33+1))+3=513 byte
121 // redeemScript, 513+1+15*(73+1)+3=1627 bytes of scriptSig, which
122 // we round off to 1650(MAX_STANDARD_SCRIPTSIG_SIZE) bytes for
123 // some minor future-proofing. That's also enough to spend a
124 // 20-of-20 CHECKMULTISIG scriptPubKey, though such a scriptPubKey
125 // is not considered standard.
127 reason = "scriptsig-size";
128 return false;
129 }
130 if (!txin.scriptSig.IsPushOnly()) {
131 reason = "scriptsig-not-pushonly";
132 return false;
133 }
134 }
135
136 unsigned int datacarrier_bytes_left = max_datacarrier_bytes.value_or(0);
137 TxoutType whichType;
138 for (const CTxOut& txout : tx.vout) {
139 if (!::IsStandard(txout.scriptPubKey, whichType)) {
140 reason = "scriptpubkey";
141 return false;
142 }
143
144 if (whichType == TxoutType::NULL_DATA) {
145 unsigned int size = txout.scriptPubKey.size();
146 if (size > datacarrier_bytes_left) {
147 reason = "datacarrier";
148 return false;
149 }
150 datacarrier_bytes_left -= size;
151 } else if ((whichType == TxoutType::MULTISIG) && (!permit_bare_multisig)) {
152 reason = "bare-multisig";
153 return false;
154 }
155 }
156
157 // Only MAX_DUST_OUTPUTS_PER_TX dust is permitted(on otherwise valid ephemeral dust)
158 if (GetDust(tx, dust_relay_fee).size() > MAX_DUST_OUTPUTS_PER_TX) {
159 reason = "dust";
160 return false;
161 }
162
163 return true;
164}
165
169static bool CheckSigopsBIP54(const CTransaction& tx, const CCoinsViewCache& inputs)
170{
171 Assert(!tx.IsCoinBase());
172
173 unsigned int sigops{0};
174 for (const auto& txin: tx.vin) {
175 const auto& prev_txo{inputs.AccessCoin(txin.prevout).out};
176
177 // Unlike the existing block wide sigop limit which counts sigops present in the block
178 // itself (including the scriptPubKey which is not executed until spending later), BIP54
179 // counts sigops in the block where they are potentially executed (only).
180 // This means sigops in the spent scriptPubKey count toward the limit.
181 // `fAccurate` means correctly accounting sigops for CHECKMULTISIGs(VERIFY) with 16 pubkeys
182 // or fewer. This method of accounting was introduced by BIP16, and BIP54 reuses it.
183 // The GetSigOpCount call on the previous scriptPubKey counts both bare and P2SH sigops.
184 sigops += txin.scriptSig.GetSigOpCount(/*fAccurate=*/true);
185 sigops += prev_txo.scriptPubKey.GetSigOpCount(txin.scriptSig);
186
187 if (sigops > MAX_TX_LEGACY_SIGOPS) {
188 return false;
189 }
190 }
191
192 return true;
193}
194
213bool AreInputsStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs)
214{
215 if (tx.IsCoinBase()) {
216 return true; // Coinbases don't use vin normally
217 }
218
219 if (!CheckSigopsBIP54(tx, mapInputs)) {
220 return false;
221 }
222
223 for (unsigned int i = 0; i < tx.vin.size(); i++) {
224 const CTxOut& prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
225
226 std::vector<std::vector<unsigned char> > vSolutions;
227 TxoutType whichType = Solver(prev.scriptPubKey, vSolutions);
228 if (whichType == TxoutType::NONSTANDARD || whichType == TxoutType::WITNESS_UNKNOWN) {
229 // WITNESS_UNKNOWN failures are typically also caught with a policy
230 // flag in the script interpreter, but it can be helpful to catch
231 // this type of NONSTANDARD transaction earlier in transaction
232 // validation.
233 return false;
234 } else if (whichType == TxoutType::SCRIPTHASH) {
235 std::vector<std::vector<unsigned char> > stack;
236 // convert the scriptSig into a stack, so we can inspect the redeemScript
238 return false;
239 if (stack.empty())
240 return false;
241 CScript subscript(stack.back().begin(), stack.back().end());
242 if (subscript.GetSigOpCount(true) > MAX_P2SH_SIGOPS) {
243 return false;
244 }
245 }
246 }
247
248 return true;
249}
250
251bool IsWitnessStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs)
252{
253 if (tx.IsCoinBase())
254 return true; // Coinbases are skipped
255
256 for (unsigned int i = 0; i < tx.vin.size(); i++)
257 {
258 // We don't care if witness for this input is empty, since it must not be bloated.
259 // If the script is invalid without witness, it would be caught sooner or later during validation.
260 if (tx.vin[i].scriptWitness.IsNull())
261 continue;
262
263 const CTxOut &prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
264
265 // get the scriptPubKey corresponding to this input:
266 CScript prevScript = prev.scriptPubKey;
267
268 // witness stuffing detected
269 if (prevScript.IsPayToAnchor()) {
270 return false;
271 }
272
273 bool p2sh = false;
274 if (prevScript.IsPayToScriptHash()) {
275 std::vector <std::vector<unsigned char> > stack;
276 // If the scriptPubKey is P2SH, we try to extract the redeemScript casually by converting the scriptSig
277 // into a stack. We do not check IsPushOnly nor compare the hash as these will be done later anyway.
278 // If the check fails at this stage, we know that this txid must be a bad one.
280 return false;
281 if (stack.empty())
282 return false;
283 prevScript = CScript(stack.back().begin(), stack.back().end());
284 p2sh = true;
285 }
286
287 int witnessversion = 0;
288 std::vector<unsigned char> witnessprogram;
289
290 // Non-witness program must not be associated with any witness
291 if (!prevScript.IsWitnessProgram(witnessversion, witnessprogram))
292 return false;
293
294 // Check P2WSH standard limits
295 if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE) {
296 if (tx.vin[i].scriptWitness.stack.back().size() > MAX_STANDARD_P2WSH_SCRIPT_SIZE)
297 return false;
298 size_t sizeWitnessStack = tx.vin[i].scriptWitness.stack.size() - 1;
299 if (sizeWitnessStack > MAX_STANDARD_P2WSH_STACK_ITEMS)
300 return false;
301 for (unsigned int j = 0; j < sizeWitnessStack; j++) {
302 if (tx.vin[i].scriptWitness.stack[j].size() > MAX_STANDARD_P2WSH_STACK_ITEM_SIZE)
303 return false;
304 }
305 }
306
307 // Check policy limits for Taproot spends:
308 // - MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE limit for stack item size
309 // - No annexes
310 if (witnessversion == 1 && witnessprogram.size() == WITNESS_V1_TAPROOT_SIZE && !p2sh) {
311 // Taproot spend (non-P2SH-wrapped, version 1, witness program size 32; see BIP 341)
312 std::span stack{tx.vin[i].scriptWitness.stack};
313 if (stack.size() >= 2 && !stack.back().empty() && stack.back()[0] == ANNEX_TAG) {
314 // Annexes are nonstandard as long as no semantics are defined for them.
315 return false;
316 }
317 if (stack.size() >= 2) {
318 // Script path spend (2 or more stack elements after removing optional annex)
319 const auto& control_block = SpanPopBack(stack);
320 SpanPopBack(stack); // Ignore script
321 if (control_block.empty()) return false; // Empty control block is invalid
322 if ((control_block[0] & TAPROOT_LEAF_MASK) == TAPROOT_LEAF_TAPSCRIPT) {
323 // Leaf version 0xc0 (aka Tapscript, see BIP 342)
324 for (const auto& item : stack) {
325 if (item.size() > MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE) return false;
326 }
327 }
328 } else if (stack.size() == 1) {
329 // Key path spend (1 stack element after removing optional annex)
330 // (no policy rules apply)
331 } else {
332 // 0 stack elements; this is already invalid by consensus rules
333 return false;
334 }
335 }
336 }
337 return true;
338}
339
341{
342 if (tx.IsCoinBase()) {
343 return false;
344 }
345
346 int version;
347 std::vector<uint8_t> program;
348 for (const auto& txin: tx.vin) {
349 const auto& prev_spk{prevouts.AccessCoin(txin.prevout).out.scriptPubKey};
350
351 // Note this includes not-yet-defined witness programs.
352 if (prev_spk.IsWitnessProgram(version, program) && !prev_spk.IsPayToAnchor(version, program)) {
353 return true;
354 }
355
356 // For P2SH extract the redeem script and check if it spends a non-Taproot witness program. Note
357 // this is fine to call EvalScript (as done in AreInputsStandard/IsWitnessStandard) because this
358 // function is only ever called after IsStandardTx, which checks the scriptsig is pushonly.
359 if (prev_spk.IsPayToScriptHash()) {
360 // If EvalScript fails or results in an empty stack, the transaction is invalid by consensus.
361 std::vector <std::vector<uint8_t>> stack;
363 || stack.empty()) {
364 continue;
365 }
366 const CScript redeem_script{stack.back().begin(), stack.back().end()};
367 if (redeem_script.IsWitnessProgram(version, program)) {
368 return true;
369 }
370 }
371 }
372
373 return false;
374}
375
376int64_t GetVirtualTransactionSize(int64_t nWeight, int64_t nSigOpCost, unsigned int bytes_per_sigop)
377{
378 return (std::max(nWeight, nSigOpCost * bytes_per_sigop) + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR;
379}
380
381int64_t GetVirtualTransactionSize(const CTransaction& tx, int64_t nSigOpCost, unsigned int bytes_per_sigop)
382{
383 return GetVirtualTransactionSize(GetTransactionWeight(tx), nSigOpCost, bytes_per_sigop);
384}
385
386int64_t GetVirtualTransactionInputSize(const CTxIn& txin, int64_t nSigOpCost, unsigned int bytes_per_sigop)
387{
388 return GetVirtualTransactionSize(GetTransactionInputWeight(txin), nSigOpCost, bytes_per_sigop);
389}
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
#define Assert(val)
Identity function.
Definition: check.h:106
CCoinsView that adds a memory cache for transactions to another CCoinsView.
Definition: coins.h:363
const Coin & AccessCoin(const COutPoint &output) const
Return a reference to Coin in the cache, or coinEmpty if not found.
Definition: coins.cpp:154
Fee rate in satoshis per virtualbyte: CAmount / vB the feerate is represented internally as FeeFrac.
Definition: feerate.h:35
CAmount GetFee(int32_t virtual_bytes) const
Return the fee in satoshis for the given vsize in vbytes.
Definition: feerate.cpp:20
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:413
bool IsPushOnly(const_iterator pc) const
Called by IsStandardTx and P2SH/BIP62 VerifyScript (which makes it consensus-critical).
Definition: script.cpp:266
bool IsPayToScriptHash() const
Definition: script.cpp:224
bool IsUnspendable() const
Returns whether the script is guaranteed to fail at execution, regardless of the initial stack.
Definition: script.h:571
unsigned int GetSigOpCount(bool fAccurate) const
Pre-version-0.6, Bitcoin always counted CHECKMULTISIGs as 20 sigops.
Definition: script.cpp:159
bool IsPayToAnchor() const
Definition: script.cpp:207
bool IsWitnessProgram(int &version, std::vector< unsigned char > &program) const
Definition: script.cpp:250
The basic transaction that is broadcasted on the network and contained in blocks.
Definition: transaction.h:296
const std::vector< CTxOut > vout
Definition: transaction.h:307
bool IsCoinBase() const
Definition: transaction.h:356
const uint32_t version
Definition: transaction.h:308
const std::vector< CTxIn > vin
Definition: transaction.h:306
An input of a transaction.
Definition: transaction.h:67
CScript scriptSig
Definition: transaction.h:70
An output of a transaction.
Definition: transaction.h:150
CScript scriptPubKey
Definition: transaction.h:153
CAmount nValue
Definition: transaction.h:152
CTxOut out
unspent transaction output
Definition: coins.h:36
size_type size() const
Definition: prevector.h:255
T & back()
Definition: prevector.h:416
static int64_t GetTransactionInputWeight(const CTxIn &txin)
Definition: validation.h:140
static int32_t GetTransactionWeight(const CTransaction &tx)
Definition: validation.h:132
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.
static constexpr uint8_t TAPROOT_LEAF_MASK
Definition: interpreter.h:231
@ SCRIPT_VERIFY_NONE
Definition: interpreter.h:46
static constexpr uint8_t TAPROOT_LEAF_TAPSCRIPT
Definition: interpreter.h:232
static constexpr size_t WITNESS_V0_SCRIPTHASH_SIZE
Signature hash sizes.
Definition: interpreter.h:227
static constexpr size_t WITNESS_V1_TAPROOT_SIZE
Definition: interpreter.h:229
bool SpendsNonAnchorWitnessProg(const CTransaction &tx, const CCoinsViewCache &prevouts)
Check whether this transaction spends any witness program but P2A, including not-yet-defined ones.
Definition: policy.cpp:340
bool AreInputsStandard(const CTransaction &tx, const CCoinsViewCache &mapInputs)
Check transaction inputs.
Definition: policy.cpp:213
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:376
int64_t GetVirtualTransactionInputSize(const CTxIn &txin, int64_t nSigOpCost, unsigned int bytes_per_sigop)
Definition: policy.cpp:386
static bool CheckSigopsBIP54(const CTransaction &tx, const CCoinsViewCache &inputs)
Check the total number of non-witness sigops across the whole transaction, as per BIP54.
Definition: policy.cpp:169
bool IsWitnessStandard(const CTransaction &tx, const CCoinsViewCache &mapInputs)
Check if the transaction is over standard P2WSH resources limit: 3600bytes witnessScript size,...
Definition: policy.cpp:251
bool IsStandard(const CScript &scriptPubKey, TxoutType &whichType)
Definition: policy.cpp:79
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:99
bool IsDust(const CTxOut &txout, const CFeeRate &dustRelayFeeIn)
Definition: policy.cpp:65
std::vector< uint32_t > GetDust(const CTransaction &tx, CFeeRate dust_relay_rate)
Get the vout index numbers of all dust outputs.
Definition: policy.cpp:70
static constexpr decltype(CTransaction::version) TX_MIN_STANDARD_VERSION
Definition: policy.h:148
static constexpr unsigned int MAX_TX_LEGACY_SIGOPS
The maximum number of potentially executed legacy signature operations in a single standard tx.
Definition: policy.h:42
static constexpr decltype(CTransaction::version) TX_MAX_STANDARD_VERSION
Definition: policy.h:149
static constexpr unsigned int MAX_STANDARD_P2WSH_STACK_ITEMS
The maximum number of witness stack items in a standard P2WSH script.
Definition: policy.h:50
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:54
static constexpr unsigned int MAX_DUST_OUTPUTS_PER_TX
Maximum number of ephemeral dust outputs allowed.
Definition: policy.h:91
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:52
static constexpr int32_t MAX_STANDARD_TX_WEIGHT
The maximum weight for transactions we're willing to relay/mine.
Definition: policy.h:34
static constexpr unsigned int MAX_P2SH_SIGOPS
Maximum number of signature check operations in an IsStandard() P2SH script.
Definition: policy.h:38
static constexpr unsigned int MAX_STANDARD_P2WSH_SCRIPT_SIZE
The maximum size in bytes of a standard witnessScript.
Definition: policy.h:56
static constexpr unsigned int MAX_STANDARD_SCRIPTSIG_SIZE
The maximum size of a standard ScriptSig.
Definition: policy.h:58
static constexpr unsigned int ANNEX_TAG
Definition: script.h:58
size_t GetSerializeSize(const T &t)
Definition: serialize.h:1094
TxoutType Solver(const CScript &scriptPubKey, std::vector< std::vector< unsigned char > > &vSolutionsRet)
Parse a scriptPubKey and identify script type for standard scripts.
Definition: solver.cpp:141
TxoutType
Definition: solver.h:22
@ WITNESS_UNKNOWN
Only for Witness versions not already defined above.
@ NULL_DATA
unspendable OP_RETURN script that carries data
T & SpanPopBack(std::span< T > &span)
A span is an object that can refer to a contiguous sequence of objects.
Definition: span.h:75