Branch data     Line data    Source code

       1                 :            : // Copyright (c) 2009-2010 Satoshi Nakamoto
       2                 :            : // Copyright (c) 2009-2022 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                 :            : #ifndef BITCOIN_POLICY_POLICY_H
       7                 :            : #define BITCOIN_POLICY_POLICY_H
       8                 :            : 
       9                 :            : #include <consensus/amount.h>
      10                 :            : #include <consensus/consensus.h>
      11                 :            : #include <primitives/transaction.h>
      12                 :            : #include <script/interpreter.h>
      13                 :            : #include <script/solver.h>
      14                 :            : 
      15                 :            : #include <cstdint>
      16                 :            : #include <string>
      17                 :            : 
      18                 :            : class CCoinsViewCache;
      19                 :            : class CFeeRate;
      20                 :            : class CScript;
      21                 :            : 
      22                 :            : /** Default for -blockmaxweight, which controls the range of block weights the mining code will create **/
      23                 :            : static constexpr unsigned int DEFAULT_BLOCK_MAX_WEIGHT{MAX_BLOCK_WEIGHT - 4000};
      24                 :            : /** Default for -blockmintxfee, which sets the minimum feerate for a transaction in blocks created by mining code **/
      25                 :            : static constexpr unsigned int DEFAULT_BLOCK_MIN_TX_FEE{1000};
      26                 :            : /** The maximum weight for transactions we're willing to relay/mine */
      27                 :            : static constexpr int32_t MAX_STANDARD_TX_WEIGHT{400000};
      28                 :            : /** The minimum non-witness size for transactions we're willing to relay/mine: one larger than 64  */
      29                 :            : static constexpr unsigned int MIN_STANDARD_TX_NONWITNESS_SIZE{65};
      30                 :            : /** Maximum number of signature check operations in an IsStandard() P2SH script */
      31                 :            : static constexpr unsigned int MAX_P2SH_SIGOPS{15};
      32                 :            : /** The maximum number of sigops we're willing to relay/mine in a single tx */
      33                 :            : static constexpr unsigned int MAX_STANDARD_TX_SIGOPS_COST{MAX_BLOCK_SIGOPS_COST/5};
      34                 :            : /** Default for -incrementalrelayfee, which sets the minimum feerate increase for mempool limiting or replacement **/
      35                 :            : static constexpr unsigned int DEFAULT_INCREMENTAL_RELAY_FEE{1000};
      36                 :            : /** Default for -bytespersigop */
      37                 :            : static constexpr unsigned int DEFAULT_BYTES_PER_SIGOP{20};
      38                 :            : /** Default for -permitbaremultisig */
      39                 :            : static constexpr bool DEFAULT_PERMIT_BAREMULTISIG{true};
      40                 :            : /** The maximum number of witness stack items in a standard P2WSH script */
      41                 :            : static constexpr unsigned int MAX_STANDARD_P2WSH_STACK_ITEMS{100};
      42                 :            : /** The maximum size in bytes of each witness stack item in a standard P2WSH script */
      43                 :            : static constexpr unsigned int MAX_STANDARD_P2WSH_STACK_ITEM_SIZE{80};
      44                 :            : /** The maximum size in bytes of each witness stack item in a standard BIP 342 script (Taproot, leaf version 0xc0) */
      45                 :            : static constexpr unsigned int MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE{80};
      46                 :            : /** The maximum size in bytes of a standard witnessScript */
      47                 :            : static constexpr unsigned int MAX_STANDARD_P2WSH_SCRIPT_SIZE{3600};
      48                 :            : /** The maximum size of a standard ScriptSig */
      49                 :            : static constexpr unsigned int MAX_STANDARD_SCRIPTSIG_SIZE{1650};
      50                 :            : /** Min feerate for defining dust.
      51                 :            :  * Changing the dust limit changes which transactions are
      52                 :            :  * standard and should be done with care and ideally rarely. It makes sense to
      53                 :            :  * only increase the dust limit after prior releases were already not creating
      54                 :            :  * outputs below the new threshold */
      55                 :            : static constexpr unsigned int DUST_RELAY_TX_FEE{3000};
      56                 :            : /** Default for -minrelaytxfee, minimum relay fee for transactions */
      57                 :            : static constexpr unsigned int DEFAULT_MIN_RELAY_TX_FEE{1000};
      58                 :            : /** Default for -limitancestorcount, max number of in-mempool ancestors */
      59                 :            : static constexpr unsigned int DEFAULT_ANCESTOR_LIMIT{25};
      60                 :            : /** Default for -limitancestorsize, maximum kilobytes of tx + all in-mempool ancestors */
      61                 :            : static constexpr unsigned int DEFAULT_ANCESTOR_SIZE_LIMIT_KVB{101};
      62                 :            : /** Default for -limitdescendantcount, max number of in-mempool descendants */
      63                 :            : static constexpr unsigned int DEFAULT_DESCENDANT_LIMIT{25};
      64                 :            : /** Default for -limitdescendantsize, maximum kilobytes of in-mempool descendants */
      65                 :            : static constexpr unsigned int DEFAULT_DESCENDANT_SIZE_LIMIT_KVB{101};
      66                 :            : /** Default for -datacarrier */
      67                 :            : static const bool DEFAULT_ACCEPT_DATACARRIER = true;
      68                 :            : /**
      69                 :            :  * Default setting for -datacarriersize. 80 bytes of data, +1 for OP_RETURN,
      70                 :            :  * +2 for the pushdata opcodes.
      71                 :            :  */
      72                 :            : static const unsigned int MAX_OP_RETURN_RELAY = 83;
      73                 :            : /**
      74                 :            :  * An extra transaction can be added to a package, as long as it only has one
      75                 :            :  * ancestor and is no larger than this. Not really any reason to make this
      76                 :            :  * configurable as it doesn't materially change DoS parameters.
      77                 :            :  */
      78                 :            : static constexpr unsigned int EXTRA_DESCENDANT_TX_SIZE_LIMIT{10000};
      79                 :            : 
      80                 :            : 
      81                 :            : /**
      82                 :            :  * Mandatory script verification flags that all new transactions must comply with for
      83                 :            :  * them to be valid. Failing one of these tests may trigger a DoS ban;
      84                 :            :  * see CheckInputScripts() for details.
      85                 :            :  *
      86                 :            :  * Note that this does not affect consensus validity; see GetBlockScriptFlags()
      87                 :            :  * for that.
      88                 :            :  */
      89                 :            : static constexpr unsigned int MANDATORY_SCRIPT_VERIFY_FLAGS{SCRIPT_VERIFY_P2SH |
      90                 :            :                                                              SCRIPT_VERIFY_DERSIG |
      91                 :            :                                                              SCRIPT_VERIFY_NULLDUMMY |
      92                 :            :                                                              SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY |
      93                 :            :                                                              SCRIPT_VERIFY_CHECKSEQUENCEVERIFY |
      94                 :            :                                                              SCRIPT_VERIFY_WITNESS |
      95                 :            :                                                              SCRIPT_VERIFY_TAPROOT};
      96                 :            : 
      97                 :            : /**
      98                 :            :  * Standard script verification flags that standard transactions will comply
      99                 :            :  * with. However we do not ban/disconnect nodes that forward txs violating
     100                 :            :  * the additional (non-mandatory) rules here, to improve forwards and
     101                 :            :  * backwards compatability.
     102                 :            :  */
     103                 :            : static constexpr unsigned int STANDARD_SCRIPT_VERIFY_FLAGS{MANDATORY_SCRIPT_VERIFY_FLAGS |
     104                 :            :                                                              SCRIPT_VERIFY_STRICTENC |
     105                 :            :                                                              SCRIPT_VERIFY_MINIMALDATA |
     106                 :            :                                                              SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS |
     107                 :            :                                                              SCRIPT_VERIFY_CLEANSTACK |
     108                 :            :                                                              SCRIPT_VERIFY_MINIMALIF |
     109                 :            :                                                              SCRIPT_VERIFY_NULLFAIL |
     110                 :            :                                                              SCRIPT_VERIFY_LOW_S |
     111                 :            :                                                              SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM |
     112                 :            :                                                              SCRIPT_VERIFY_WITNESS_PUBKEYTYPE |
     113                 :            :                                                              SCRIPT_VERIFY_CONST_SCRIPTCODE |
     114                 :            :                                                              SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_TAPROOT_VERSION |
     115                 :            :                                                              SCRIPT_VERIFY_DISCOURAGE_OP_SUCCESS |
     116                 :            :                                                              SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_PUBKEYTYPE};
     117                 :            : 
     118                 :            : /** For convenience, standard but not mandatory verify flags. */
     119                 :            : static constexpr unsigned int STANDARD_NOT_MANDATORY_VERIFY_FLAGS{STANDARD_SCRIPT_VERIFY_FLAGS & ~MANDATORY_SCRIPT_VERIFY_FLAGS};
     120                 :            : 
     121                 :            : /** Used as the flags parameter to sequence and nLocktime checks in non-consensus code. */
     122                 :            : static constexpr unsigned int STANDARD_LOCKTIME_VERIFY_FLAGS{LOCKTIME_VERIFY_SEQUENCE};
     123                 :            : 
     124                 :            : CAmount GetDustThreshold(const CTxOut& txout, const CFeeRate& dustRelayFee);
     125                 :            : 
     126                 :            : bool IsDust(const CTxOut& txout, const CFeeRate& dustRelayFee);
     127                 :            : 
     128                 :            : bool IsStandard(const CScript& scriptPubKey, const std::optional<unsigned>& max_datacarrier_bytes, TxoutType& whichType);
     129                 :            : 
     130                 :            : 
     131                 :            : // Changing the default transaction version requires a two step process: first
     132                 :            : // adapting relay policy by bumping TX_MAX_STANDARD_VERSION, and then later
     133                 :            : // allowing the new transaction version in the wallet/RPC.
     134                 :            : static constexpr decltype(CTransaction::nVersion) TX_MAX_STANDARD_VERSION{2};
     135                 :            : 
     136                 :            : /**
     137                 :            : * Check for standard transaction types
     138                 :            : * @return True if all outputs (scriptPubKeys) use only standard transaction forms
     139                 :            : */
     140                 :            : bool IsStandardTx(const CTransaction& tx, const std::optional<unsigned>& max_datacarrier_bytes, bool permit_bare_multisig, const CFeeRate& dust_relay_fee, std::string& reason);
     141                 :            : /**
     142                 :            : * Check for standard transaction types
     143                 :            : * @param[in] mapInputs       Map of previous transactions that have outputs we're spending
     144                 :            : * @return True if all inputs (scriptSigs) use only standard transaction forms
     145                 :            : */
     146                 :            : bool AreInputsStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs);
     147                 :            : /**
     148                 :            : * Check if the transaction is over standard P2WSH resources limit:
     149                 :            : * 3600bytes witnessScript size, 80bytes per witness stack element, 100 witness stack elements
     150                 :            : * These limits are adequate for multisignatures up to n-of-100 using OP_CHECKSIG, OP_ADD, and OP_EQUAL.
     151                 :            : *
     152                 :            : * Also enforce a maximum stack item size limit and no annexes for tapscript spends.
     153                 :            : */
     154                 :            : bool IsWitnessStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs);
     155                 :            : 
     156                 :            : /** Compute the virtual transaction size (weight reinterpreted as bytes). */
     157                 :            : int64_t GetVirtualTransactionSize(int64_t nWeight, int64_t nSigOpCost, unsigned int bytes_per_sigop);
     158                 :            : int64_t GetVirtualTransactionSize(const CTransaction& tx, int64_t nSigOpCost, unsigned int bytes_per_sigop);
     159                 :            : int64_t GetVirtualTransactionInputSize(const CTxIn& tx, int64_t nSigOpCost, unsigned int bytes_per_sigop);
     160                 :            : 
     161                 :      24453 : static inline int64_t GetVirtualTransactionSize(const CTransaction& tx)
     162                 :            : {
     163                 :      24453 :     return GetVirtualTransactionSize(tx, 0, 0);
     164                 :            : }
     165                 :            : 
     166                 :          8 : static inline int64_t GetVirtualTransactionInputSize(const CTxIn& tx)
     167                 :            : {
     168                 :          8 :     return GetVirtualTransactionInputSize(tx, 0, 0);
     169                 :            : }
     170                 :            : 
     171                 :            : #endif // BITCOIN_POLICY_POLICY_H