LCOV - code coverage report
Current view: top level - src/policy - policy.h (source / functions) Coverage Total Hit
Test: fuzz_coverage.info Lines: 100.0 % 4 4
Test Date: 2024-12-04 04:00:22 Functions: - 0 0
Branches: 21.4 % 14 3

             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                 :             :  * Maximum number of ephemeral dust outputs allowed.
      82                 :             :  */
      83                 :             : static constexpr unsigned int MAX_DUST_OUTPUTS_PER_TX{1};
      84                 :             : 
      85                 :             : /**
      86                 :             :  * Mandatory script verification flags that all new transactions must comply with for
      87                 :             :  * them to be valid. Failing one of these tests may trigger a DoS ban;
      88                 :             :  * see CheckInputScripts() for details.
      89                 :             :  *
      90                 :             :  * Note that this does not affect consensus validity; see GetBlockScriptFlags()
      91                 :             :  * for that.
      92                 :             :  */
      93                 :             : static constexpr unsigned int MANDATORY_SCRIPT_VERIFY_FLAGS{SCRIPT_VERIFY_P2SH |
      94                 :             :                                                              SCRIPT_VERIFY_DERSIG |
      95                 :             :                                                              SCRIPT_VERIFY_NULLDUMMY |
      96                 :             :                                                              SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY |
      97                 :             :                                                              SCRIPT_VERIFY_CHECKSEQUENCEVERIFY |
      98                 :             :                                                              SCRIPT_VERIFY_WITNESS |
      99                 :             :                                                              SCRIPT_VERIFY_TAPROOT};
     100                 :             : 
     101                 :             : /**
     102                 :             :  * Standard script verification flags that standard transactions will comply
     103                 :             :  * with. However we do not ban/disconnect nodes that forward txs violating
     104                 :             :  * the additional (non-mandatory) rules here, to improve forwards and
     105                 :             :  * backwards compatibility.
     106                 :             :  */
     107                 :             : static constexpr unsigned int STANDARD_SCRIPT_VERIFY_FLAGS{MANDATORY_SCRIPT_VERIFY_FLAGS |
     108                 :             :                                                              SCRIPT_VERIFY_STRICTENC |
     109                 :             :                                                              SCRIPT_VERIFY_MINIMALDATA |
     110                 :             :                                                              SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS |
     111                 :             :                                                              SCRIPT_VERIFY_CLEANSTACK |
     112                 :             :                                                              SCRIPT_VERIFY_MINIMALIF |
     113                 :             :                                                              SCRIPT_VERIFY_NULLFAIL |
     114                 :             :                                                              SCRIPT_VERIFY_LOW_S |
     115                 :             :                                                              SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM |
     116                 :             :                                                              SCRIPT_VERIFY_WITNESS_PUBKEYTYPE |
     117                 :             :                                                              SCRIPT_VERIFY_CONST_SCRIPTCODE |
     118                 :             :                                                              SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_TAPROOT_VERSION |
     119                 :             :                                                              SCRIPT_VERIFY_DISCOURAGE_OP_SUCCESS |
     120                 :             :                                                              SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_PUBKEYTYPE};
     121                 :             : 
     122                 :             : /** For convenience, standard but not mandatory verify flags. */
     123                 :             : static constexpr unsigned int STANDARD_NOT_MANDATORY_VERIFY_FLAGS{STANDARD_SCRIPT_VERIFY_FLAGS & ~MANDATORY_SCRIPT_VERIFY_FLAGS};
     124                 :             : 
     125                 :             : /** Used as the flags parameter to sequence and nLocktime checks in non-consensus code. */
     126                 :             : static constexpr unsigned int STANDARD_LOCKTIME_VERIFY_FLAGS{LOCKTIME_VERIFY_SEQUENCE};
     127                 :             : 
     128                 :             : CAmount GetDustThreshold(const CTxOut& txout, const CFeeRate& dustRelayFee);
     129                 :             : 
     130                 :             : bool IsDust(const CTxOut& txout, const CFeeRate& dustRelayFee);
     131                 :             : 
     132                 :             : bool IsStandard(const CScript& scriptPubKey, const std::optional<unsigned>& max_datacarrier_bytes, TxoutType& whichType);
     133                 :             : 
     134                 :             : /** Get the vout index numbers of all dust outputs */
     135                 :             : std::vector<uint32_t> GetDust(const CTransaction& tx, CFeeRate dust_relay_rate);
     136                 :             : 
     137                 :             : // Changing the default transaction version requires a two step process: first
     138                 :             : // adapting relay policy by bumping TX_MAX_STANDARD_VERSION, and then later
     139                 :             : // allowing the new transaction version in the wallet/RPC.
     140                 :             : static constexpr decltype(CTransaction::version) TX_MAX_STANDARD_VERSION{3};
     141                 :             : 
     142                 :             : /**
     143                 :             : * Check for standard transaction types
     144                 :             : * @return True if all outputs (scriptPubKeys) use only standard transaction forms
     145                 :             : */
     146                 :             : bool IsStandardTx(const CTransaction& tx, const std::optional<unsigned>& max_datacarrier_bytes, bool permit_bare_multisig, const CFeeRate& dust_relay_fee, std::string& reason);
     147                 :             : /**
     148                 :             : * Check for standard transaction types
     149                 :             : * @param[in] mapInputs       Map of previous transactions that have outputs we're spending
     150                 :             : * @return True if all inputs (scriptSigs) use only standard transaction forms
     151                 :             : */
     152                 :             : bool AreInputsStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs);
     153                 :             : /**
     154                 :             : * Check if the transaction is over standard P2WSH resources limit:
     155                 :             : * 3600bytes witnessScript size, 80bytes per witness stack element, 100 witness stack elements
     156                 :             : * These limits are adequate for multisignatures up to n-of-100 using OP_CHECKSIG, OP_ADD, and OP_EQUAL.
     157                 :             : *
     158                 :             : * Also enforce a maximum stack item size limit and no annexes for tapscript spends.
     159                 :             : */
     160                 :             : bool IsWitnessStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs);
     161                 :             : 
     162                 :             : /** Compute the virtual transaction size (weight reinterpreted as bytes). */
     163                 :             : int64_t GetVirtualTransactionSize(int64_t nWeight, int64_t nSigOpCost, unsigned int bytes_per_sigop);
     164                 :             : int64_t GetVirtualTransactionSize(const CTransaction& tx, int64_t nSigOpCost, unsigned int bytes_per_sigop);
     165                 :             : int64_t GetVirtualTransactionInputSize(const CTxIn& tx, int64_t nSigOpCost, unsigned int bytes_per_sigop);
     166                 :             : 
     167                 :      122474 : static inline int64_t GetVirtualTransactionSize(const CTransaction& tx)
     168                 :             : {
     169   [ #  #  #  #  :      122474 :     return GetVirtualTransactionSize(tx, 0, 0);
           #  # ][ +  - ]
           [ -  -  +  - ]
     170                 :             : }
     171                 :             : 
     172                 :          66 : static inline int64_t GetVirtualTransactionInputSize(const CTxIn& tx)
     173                 :             : {
     174         [ +  - ]:          66 :     return GetVirtualTransactionInputSize(tx, 0, 0);
     175                 :             : }
     176                 :             : 
     177                 :             : #endif // BITCOIN_POLICY_POLICY_H
        

Generated by: LCOV version 2.0-1