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           0 : static inline int64_t GetVirtualTransactionSize(const CTransaction& tx)
     162             : {
     163           0 :     return GetVirtualTransactionSize(tx, 0, 0);
     164             : }
     165             : 
     166           0 : static inline int64_t GetVirtualTransactionInputSize(const CTxIn& tx)
     167             : {
     168           0 :     return GetVirtualTransactionInputSize(tx, 0, 0);
     169             : }
     170             : 
     171             : #endif // BITCOIN_POLICY_POLICY_H