LCOV - code coverage report
Current view: top level - src/policy - policy.cpp (source / functions) Coverage Total Hit
Test: total_coverage.info Lines: 98.5 % 130 128
Test Date: 2025-08-01 05:08:13 Functions: 100.0 % 11 11
Branches: 86.7 % 150 130

             Branch data     Line data    Source code
       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>
      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/solver.h>
      19                 :             : #include <serialize.h>
      20                 :             : #include <span.h>
      21                 :             : 
      22                 :             : #include <algorithm>
      23                 :             : #include <cstddef>
      24                 :             : #include <vector>
      25                 :             : 
      26                 :      556410 : 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         [ +  + ]:      556410 :     if (txout.scriptPubKey.IsUnspendable())
      43                 :             :         return 0;
      44                 :             : 
      45                 :      546698 :     size_t nSize = GetSerializeSize(txout);
      46                 :      546698 :     int witnessversion = 0;
      47                 :      546698 :     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   [ +  -  +  + ]:      546698 :     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                 :      515804 :         nSize += (32 + 4 + 1 + (107 / WITNESS_SCALE_FACTOR) + 4);
      58                 :             :     } else {
      59                 :       30894 :         nSize += (32 + 4 + 1 + 107 + 4); // the 148 mentioned above
      60                 :             :     }
      61                 :             : 
      62         [ +  - ]:      546698 :     return dustRelayFeeIn.GetFee(nSize);
      63                 :      546698 : }
      64                 :             : 
      65                 :      553034 : bool IsDust(const CTxOut& txout, const CFeeRate& dustRelayFeeIn)
      66                 :             : {
      67                 :      553034 :     return (txout.nValue < GetDustThreshold(txout, dustRelayFeeIn));
      68                 :             : }
      69                 :             : 
      70                 :       66145 : std::vector<uint32_t> GetDust(const CTransaction& tx, CFeeRate dust_relay_rate)
      71                 :             : {
      72                 :       66145 :     std::vector<uint32_t> dust_outputs;
      73         [ +  + ]:      286288 :     for (uint32_t i{0}; i < tx.vout.size(); ++i) {
      74   [ +  -  +  +  :      220143 :         if (IsDust(tx.vout[i], dust_relay_rate)) dust_outputs.push_back(i);
                   +  - ]
      75                 :             :     }
      76                 :       66145 :     return dust_outputs;
      77                 :           0 : }
      78                 :             : 
      79                 :      112028 : bool IsStandard(const CScript& scriptPubKey, TxoutType& whichType)
      80                 :             : {
      81                 :      112028 :     std::vector<std::vector<unsigned char> > vSolutions;
      82         [ +  - ]:      112028 :     whichType = Solver(scriptPubKey, vSolutions);
      83                 :             : 
      84         [ +  + ]:      112028 :     if (whichType == TxoutType::NONSTANDARD) {
      85                 :             :         return false;
      86         [ +  + ]:      112007 :     } else if (whichType == TxoutType::MULTISIG) {
      87         [ +  + ]:          93 :         unsigned char m = vSolutions.front()[0];
      88                 :          93 :         unsigned char n = vSolutions.back()[0];
      89                 :             :         // Support up to x-of-3 multisig txns as standard
      90         [ +  + ]:          93 :         if (n < 1 || n > 3)
      91                 :             :             return false;
      92         [ -  + ]:          92 :         if (m < 1 || m > n)
      93                 :           0 :             return false;
      94                 :             :     }
      95                 :             : 
      96                 :             :     return true;
      97                 :      112028 : }
      98                 :             : 
      99                 :       36998 : bool IsStandardTx(const CTransaction& tx, const std::optional<unsigned>& max_datacarrier_bytes, bool permit_bare_multisig, const CFeeRate& dust_relay_fee, std::string& reason)
     100                 :             : {
     101         [ +  + ]:       36998 :     if (tx.version > TX_MAX_STANDARD_VERSION || tx.version < 1) {
     102                 :        1997 :         reason = "version";
     103                 :        1997 :         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                 :       35001 :     unsigned int sz = GetTransactionWeight(tx);
     111         [ +  + ]:       35001 :     if (sz > MAX_STANDARD_TX_WEIGHT) {
     112                 :           5 :         reason = "tx-size";
     113                 :           5 :         return false;
     114                 :             :     }
     115                 :             : 
     116         [ +  + ]:       97491 :     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.
     126   [ +  +  +  + ]:       62735 :         if (txin.scriptSig.size() > MAX_STANDARD_SCRIPTSIG_SIZE) {
     127                 :           2 :             reason = "scriptsig-size";
     128                 :           2 :             return false;
     129                 :             :         }
     130         [ +  + ]:       62733 :         if (!txin.scriptSig.IsPushOnly()) {
     131                 :         238 :             reason = "scriptsig-not-pushonly";
     132                 :         238 :             return false;
     133                 :             :         }
     134                 :             :     }
     135                 :             : 
     136         [ +  + ]:       34756 :     unsigned int datacarrier_bytes_left = max_datacarrier_bytes.value_or(0);
     137                 :       34756 :     TxoutType whichType;
     138         [ +  + ]:      146745 :     for (const CTxOut& txout : tx.vout) {
     139         [ +  + ]:      112018 :         if (!::IsStandard(txout.scriptPubKey, whichType)) {
     140                 :          15 :             reason = "scriptpubkey";
     141                 :          15 :             return false;
     142                 :             :         }
     143                 :             : 
     144         [ +  + ]:      112003 :         if (whichType == TxoutType::NULL_DATA) {
     145         [ +  + ]:        6077 :             unsigned int size = txout.scriptPubKey.size();
     146         [ +  + ]:        6077 :             if (size > datacarrier_bytes_left) {
     147                 :           9 :                 reason = "datacarrier";
     148                 :           9 :                 return false;
     149                 :             :             }
     150                 :        6068 :             datacarrier_bytes_left -= size;
     151   [ +  +  +  + ]:      105926 :         } else if ((whichType == TxoutType::MULTISIG) && (!permit_bare_multisig)) {
     152                 :           5 :             reason = "bare-multisig";
     153                 :           5 :             return false;
     154                 :             :         }
     155                 :             :     }
     156                 :             : 
     157                 :             :     // Only MAX_DUST_OUTPUTS_PER_TX dust is permitted(on otherwise valid ephemeral dust)
     158         [ +  + ]:       34727 :     if (GetDust(tx, dust_relay_fee).size() > MAX_DUST_OUTPUTS_PER_TX) {
     159                 :          30 :         reason = "dust";
     160                 :          30 :         return false;
     161                 :             :     }
     162                 :             : 
     163                 :             :     return true;
     164                 :             : }
     165                 :             : 
     166                 :             : /**
     167                 :             :  * Check the total number of non-witness sigops across the whole transaction, as per BIP54.
     168                 :             :  */
     169                 :       31545 : static bool CheckSigopsBIP54(const CTransaction& tx, const CCoinsViewCache& inputs)
     170                 :             : {
     171                 :       31545 :     Assert(!tx.IsCoinBase());
     172                 :             : 
     173                 :       31545 :     unsigned int sigops{0};
     174         [ +  + ]:       87206 :     for (const auto& txin: tx.vin) {
     175                 :       55664 :         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                 :       55664 :         sigops += txin.scriptSig.GetSigOpCount(/*fAccurate=*/true);
     185                 :       55664 :         sigops += prev_txo.scriptPubKey.GetSigOpCount(txin.scriptSig);
     186                 :             : 
     187         [ +  + ]:       55664 :         if (sigops > MAX_TX_LEGACY_SIGOPS) {
     188                 :             :             return false;
     189                 :             :         }
     190                 :             :     }
     191                 :             : 
     192                 :             :     return true;
     193                 :             : }
     194                 :             : 
     195                 :             : /**
     196                 :             :  * Check transaction inputs.
     197                 :             :  *
     198                 :             :  * This does three things:
     199                 :             :  *  * Prevents mempool acceptance of spends of future
     200                 :             :  *    segwit versions we don't know how to validate
     201                 :             :  *  * Mitigates a potential denial-of-service attack with
     202                 :             :  *    P2SH scripts with a crazy number of expensive
     203                 :             :  *    CHECKSIG/CHECKMULTISIG operations.
     204                 :             :  *  * Prevents spends of unknown/irregular scriptPubKeys,
     205                 :             :  *    which mitigates potential denial-of-service attacks
     206                 :             :  *    involving expensive scripts and helps reserve them
     207                 :             :  *    as potential new upgrade hooks.
     208                 :             :  *
     209                 :             :  * Note that only the non-witness portion of the transaction is checked here.
     210                 :             :  *
     211                 :             :  * We also check the total number of non-witness sigops across the whole transaction, as per BIP54.
     212                 :             :  */
     213                 :       31545 : bool AreInputsStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs)
     214                 :             : {
     215         [ +  - ]:       31545 :     if (tx.IsCoinBase()) {
     216                 :             :         return true; // Coinbases don't use vin normally
     217                 :             :     }
     218                 :             : 
     219         [ +  + ]:       31545 :     if (!CheckSigopsBIP54(tx, mapInputs)) {
     220                 :             :         return false;
     221                 :             :     }
     222                 :             : 
     223         [ +  + ]:       86418 :     for (unsigned int i = 0; i < tx.vin.size(); i++) {
     224                 :       55028 :         const CTxOut& prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
     225                 :             : 
     226                 :       55028 :         std::vector<std::vector<unsigned char> > vSolutions;
     227         [ +  - ]:       55028 :         TxoutType whichType = Solver(prev.scriptPubKey, vSolutions);
     228         [ +  + ]:       55028 :         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         [ +  + ]:       54878 :         } else if (whichType == TxoutType::SCRIPTHASH) {
     235                 :        2301 :             std::vector<std::vector<unsigned char> > stack;
     236                 :             :             // convert the scriptSig into a stack, so we can inspect the redeemScript
     237   [ +  -  +  - ]:        2301 :             if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker(), SigVersion::BASE))
     238                 :             :                 return false;
     239         [ +  - ]:        2301 :             if (stack.empty())
     240                 :             :                 return false;
     241                 :        2301 :             CScript subscript(stack.back().begin(), stack.back().end());
     242   [ +  -  +  + ]:        2301 :             if (subscript.GetSigOpCount(true) > MAX_P2SH_SIGOPS) {
     243                 :           2 :                 return false;
     244                 :             :             }
     245                 :        2301 :         }
     246                 :       55028 :     }
     247                 :             : 
     248                 :             :     return true;
     249                 :             : }
     250                 :             : 
     251                 :       30339 : bool IsWitnessStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs)
     252                 :             : {
     253         [ +  - ]:       30339 :     if (tx.IsCoinBase())
     254                 :             :         return true; // Coinbases are skipped
     255                 :             : 
     256         [ +  + ]:       81970 :     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         [ +  + ]:       51729 :         if (tx.vin[i].scriptWitness.IsNull())
     261                 :         882 :             continue;
     262                 :             : 
     263                 :       50847 :         const CTxOut &prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
     264                 :             : 
     265                 :             :         // get the scriptPubKey corresponding to this input:
     266                 :       50847 :         CScript prevScript = prev.scriptPubKey;
     267                 :             : 
     268                 :             :         // witness stuffing detected
     269   [ +  -  +  + ]:       50847 :         if (prevScript.IsPayToAnchor()) {
     270                 :             :             return false;
     271                 :             :         }
     272                 :             : 
     273                 :       50846 :         bool p2sh = false;
     274   [ +  -  +  + ]:       50846 :         if (prevScript.IsPayToScriptHash()) {
     275                 :        1379 :             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.
     279   [ +  -  +  - ]:        1379 :             if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker(), SigVersion::BASE))
     280                 :             :                 return false;
     281         [ +  - ]:        1379 :             if (stack.empty())
     282                 :             :                 return false;
     283                 :        1379 :             prevScript = CScript(stack.back().begin(), stack.back().end());
     284                 :        1379 :             p2sh = true;
     285                 :        1379 :         }
     286                 :             : 
     287                 :       50846 :         int witnessversion = 0;
     288                 :       50846 :         std::vector<unsigned char> witnessprogram;
     289                 :             : 
     290                 :             :         // Non-witness program must not be associated with any witness
     291   [ +  -  +  + ]:       50846 :         if (!prevScript.IsWitnessProgram(witnessversion, witnessprogram))
     292                 :             :             return false;
     293                 :             : 
     294                 :             :         // Check P2WSH standard limits
     295   [ +  +  +  + ]:       50844 :         if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE) {
     296         [ +  + ]:         469 :             if (tx.vin[i].scriptWitness.stack.back().size() > MAX_STANDARD_P2WSH_SCRIPT_SIZE)
     297                 :             :                 return false;
     298         [ +  + ]:         467 :             size_t sizeWitnessStack = tx.vin[i].scriptWitness.stack.size() - 1;
     299         [ +  + ]:         467 :             if (sizeWitnessStack > MAX_STANDARD_P2WSH_STACK_ITEMS)
     300                 :             :                 return false;
     301         [ +  + ]:        1236 :             for (unsigned int j = 0; j < sizeWitnessStack; j++) {
     302         [ +  + ]:         773 :                 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   [ +  +  +  +  :       50838 :         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         [ +  + ]:       42083 :             std::span stack{tx.vin[i].scriptWitness.stack};
     313   [ +  +  +  +  :       42083 :             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         [ +  + ]:       42021 :             if (stack.size() >= 2) {
     318                 :             :                 // Script path spend (2 or more stack elements after removing optional annex)
     319                 :       41036 :                 const auto& control_block = SpanPopBack(stack);
     320                 :       41036 :                 SpanPopBack(stack); // Ignore script
     321         [ +  + ]:       41036 :                 if (control_block.empty()) return false; // Empty control block is invalid
     322         [ +  + ]:       41034 :                 if ((control_block[0] & TAPROOT_LEAF_MASK) == TAPROOT_LEAF_TAPSCRIPT) {
     323                 :             :                     // Leaf version 0xc0 (aka Tapscript, see BIP 342)
     324         [ +  + ]:      260629 :                     for (const auto& item : stack) {
     325         [ +  + ]:      220339 :                         if (item.size() > MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE) return false;
     326                 :             :                     }
     327                 :             :                 }
     328         [ +  - ]:         985 :             } 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                 :       50944 :     }
     337                 :             :     return true;
     338                 :             : }
     339                 :             : 
     340                 :   368366588 : int64_t GetVirtualTransactionSize(int64_t nWeight, int64_t nSigOpCost, unsigned int bytes_per_sigop)
     341                 :             : {
     342         [ +  + ]:   368366588 :     return (std::max(nWeight, nSigOpCost * bytes_per_sigop) + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR;
     343                 :             : }
     344                 :             : 
     345                 :       47476 : int64_t GetVirtualTransactionSize(const CTransaction& tx, int64_t nSigOpCost, unsigned int bytes_per_sigop)
     346                 :             : {
     347                 :       47476 :     return GetVirtualTransactionSize(GetTransactionWeight(tx), nSigOpCost, bytes_per_sigop);
     348                 :             : }
     349                 :             : 
     350                 :           2 : int64_t GetVirtualTransactionInputSize(const CTxIn& txin, int64_t nSigOpCost, unsigned int bytes_per_sigop)
     351                 :             : {
     352                 :           2 :     return GetVirtualTransactionSize(GetTransactionInputWeight(txin), nSigOpCost, bytes_per_sigop);
     353                 :             : }
        

Generated by: LCOV version 2.0-1