diff --git a/src/policy/policy.h b/src/policy/policy.h
index acd90b66e..0f9050b88 100644
--- a/src/policy/policy.h
+++ b/src/policy/policy.h
@@ -1,142 +1,153 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_POLICY_POLICY_H
 #define BITCOIN_POLICY_POLICY_H
 
 #include <consensus/consensus.h>
 #include <feerate.h>
 #include <script/standard.h>
 
 #include <string>
 
 class CCoinsViewCache;
 class CTransaction;
 class CTxIn;
 class CTxOut;
 
 /**
  * Default for -blockmaxsize, which controls the maximum size of block the
  * mining code will create.
  */
 static const uint64_t DEFAULT_MAX_GENERATED_BLOCK_SIZE = 2 * ONE_MEGABYTE;
 /**
  * Default for -blockmintxfee, which sets the minimum feerate for a transaction
  * in blocks created by mining code.
  */
 static const Amount DEFAULT_BLOCK_MIN_TX_FEE_PER_KB(1000 * SATOSHI);
 /**
  * The maximum size for transactions we're willing to relay/mine.
  */
 static const unsigned int MAX_STANDARD_TX_SIZE = 100000;
 
 /**
  * Biggest 'standard' txin is a 15-of-15 P2SH multisig with compressed
  * keys (remember the 520 byte limit on redeemScript size). That works
  * out to a (15*(33+1))+3=513 byte redeemScript, 513+1+15*(73+1)+3=1627
  * bytes of scriptSig, which we round off to 1650 bytes for some minor
  * future-proofing. That's also enough to spend a 20-of-20 CHECKMULTISIG
  * scriptPubKey, though such a scriptPubKey is not considered standard.
  */
 static const unsigned int MAX_TX_IN_SCRIPT_SIG_SIZE = 1650;
 
 /**
  * Maximum number of signature check operations in an IsStandard() P2SH script.
  */
 static const unsigned int MAX_P2SH_SIGOPS = 15;
 /**
  * The maximum number of sigops we're willing to relay/mine in a single tx.
  */
 static const unsigned int MAX_STANDARD_TX_SIGOPS = MAX_TX_SIGOPS_COUNT / 5;
 /**
  * Default for -maxmempool, maximum megabytes of mempool memory usage.
  */
 static const unsigned int DEFAULT_MAX_MEMPOOL_SIZE = 300;
 /**
  * Default for -incrementalrelayfee, which sets the minimum feerate increase for
  * mempool limiting or BIP 125 replacement.
  */
 static const CFeeRate MEMPOOL_FULL_FEE_INCREMENT(1000 * SATOSHI);
 /**
  * Default for -bytespersigop .
  */
 static const unsigned int DEFAULT_BYTES_PER_SIGOP =
     1000000 / MAX_BLOCK_SIGOPS_PER_MB;
 /**
  * Min feerate for defining dust. Historically this has been the same as the
  * minRelayTxFee, however changing the dust limit changes which transactions are
  * standard and should be done with care and ideally rarely. It makes sense to
  * only increase the dust limit after prior releases were already not creating
  * outputs below the new threshold.
  */
 static const Amount DUST_RELAY_TX_FEE(1000 * SATOSHI);
 
+/**
+ * When transactions fail script evaluations under standard flags, this flagset
+ * influences the decision of whether to drop them or to also ban the originator
+ * (see CheckInputs).
+ */
+static const uint32_t MANDATORY_SCRIPT_VERIFY_FLAGS =
+    SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC |
+    SCRIPT_ENABLE_SIGHASH_FORKID | SCRIPT_VERIFY_LOW_S |
+    SCRIPT_VERIFY_NULLFAIL | SCRIPT_VERIFY_MINIMALDATA |
+    SCRIPT_ENABLE_SCHNORR_MULTISIG;
+
 /**
  * Standard script verification flags that standard transactions will comply
  * with. However scripts violating these flags may still be present in valid
  * blocks and we must accept those blocks.
  */
 static constexpr uint32_t STANDARD_SCRIPT_VERIFY_FLAGS =
     MANDATORY_SCRIPT_VERIFY_FLAGS | SCRIPT_VERIFY_DERSIG |
     SCRIPT_VERIFY_SIGPUSHONLY | SCRIPT_VERIFY_MINIMALDATA |
     SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS | SCRIPT_VERIFY_CLEANSTACK |
     SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY | SCRIPT_VERIFY_CHECKSEQUENCEVERIFY |
     SCRIPT_VERIFY_CHECKDATASIG_SIGOPS | SCRIPT_DISALLOW_SEGWIT_RECOVERY;
 
 /**
  * For convenience, standard but not mandatory verify flags.
  */
 static constexpr uint32_t STANDARD_NOT_MANDATORY_VERIFY_FLAGS =
     STANDARD_SCRIPT_VERIFY_FLAGS & ~MANDATORY_SCRIPT_VERIFY_FLAGS;
 
 /**
  * Used as the flags parameter to sequence and nLocktime checks in non-consensus
  * code.
  */
 static constexpr uint32_t STANDARD_LOCKTIME_VERIFY_FLAGS =
     LOCKTIME_VERIFY_SEQUENCE | LOCKTIME_MEDIAN_TIME_PAST;
 
 Amount GetDustThreshold(const CTxOut &txout, const CFeeRate &dustRelayFee);
 
 bool IsDust(const CTxOut &txout, const CFeeRate &dustRelayFee);
 
 bool IsStandard(const CScript &scriptPubKey, txnouttype &whichType);
 
 /**
  * Check for standard transaction types
  * @return True if all outputs (scriptPubKeys) use only standard transaction
  * forms
  */
 bool IsStandardTx(const CTransaction &tx, std::string &reason);
 
 /**
  * Check for standard transaction types
  * @param[in] mapInputs    Map of previous transactions that have outputs we're
  * spending
  * @return True if all inputs (scriptSigs) use only standard transaction forms
  */
 bool AreInputsStandard(const CTransaction &tx,
                        const CCoinsViewCache &mapInputs);
 
 extern CFeeRate dustRelayFee;
 extern uint32_t nBytesPerSigOp;
 
 /**
  * Compute the virtual transaction size (size, or more if sigops are too
  * dense).
  */
 int64_t GetVirtualTransactionSize(int64_t nSize, int64_t nSigOpCount,
                                   unsigned int bytes_per_sigop);
 int64_t GetVirtualTransactionSize(const CTransaction &tx, int64_t nSigOpCount,
                                   unsigned int bytes_per_sigop);
 int64_t GetVirtualTransactionInputSize(const CTxIn &txin, int64_t nSigOpCount,
                                        unsigned int bytes_per_sigop);
 
 static inline int64_t GetVirtualTransactionSize(int64_t nSize,
                                                 int64_t nSigOpCount) {
     return GetVirtualTransactionSize(nSize, nSigOpCount, ::nBytesPerSigOp);
 }
 
 #endif // BITCOIN_POLICY_POLICY_H
diff --git a/src/script/standard.h b/src/script/standard.h
index 7cefb98d7..3cfe53175 100644
--- a/src/script/standard.h
+++ b/src/script/standard.h
@@ -1,142 +1,131 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_SCRIPT_STANDARD_H
 #define BITCOIN_SCRIPT_STANDARD_H
 
 #include <amount.h>
 #include <pubkey.h>
 #include <script/script_flags.h>
 #include <uint256.h>
 
 #include <boost/variant.hpp>
 
 #include <cstdint>
 
 static const bool DEFAULT_ACCEPT_DATACARRIER = true;
 
 class CKeyID;
 class CScript;
 
 /** A reference to a CScript: the Hash160 of its serialization (see script.h) */
 class CScriptID : public uint160 {
 public:
     CScriptID() : uint160() {}
     explicit CScriptID(const CScript &in);
     CScriptID(const uint160 &in) : uint160(in) {}
 };
 
 /**
  * Default setting for nMaxDatacarrierBytes. 220 bytes of data, +1 for
  * OP_RETURN, +2 for the pushdata opcodes.
  */
 static const unsigned int MAX_OP_RETURN_RELAY = 223;
 
 /**
  * A data carrying output is an unspendable output containing data. The script
  * type is designated as TX_NULL_DATA.
  */
 extern bool fAcceptDatacarrier;
 
-/**
- * When transactions fail script evaluations under standard flags, this flagset
- * influences the decision of whether to drop them or to also ban the originator
- * (see CheckInputs).
- */
-static const uint32_t MANDATORY_SCRIPT_VERIFY_FLAGS =
-    SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC |
-    SCRIPT_ENABLE_SIGHASH_FORKID | SCRIPT_VERIFY_LOW_S |
-    SCRIPT_VERIFY_NULLFAIL | SCRIPT_VERIFY_MINIMALDATA |
-    SCRIPT_ENABLE_SCHNORR_MULTISIG;
-
 enum txnouttype {
     TX_NONSTANDARD,
     // 'standard' transaction types:
     TX_PUBKEY,
     TX_PUBKEYHASH,
     TX_SCRIPTHASH,
     TX_MULTISIG,
     // unspendable OP_RETURN script that carries data
     TX_NULL_DATA,
 };
 
 class CNoDestination {
 public:
     friend bool operator==(const CNoDestination &a, const CNoDestination &b) {
         return true;
     }
     friend bool operator<(const CNoDestination &a, const CNoDestination &b) {
         return true;
     }
 };
 
 /**
  * A txout script template with a specific destination. It is either:
  *  * CNoDestination: no destination set
  *  * CKeyID: TX_PUBKEYHASH destination
  *  * CScriptID: TX_SCRIPTHASH destination
  *  A CTxDestination is the internal data type encoded in a bitcoin address
  */
 typedef boost::variant<CNoDestination, CKeyID, CScriptID> CTxDestination;
 
 /** Check whether a CTxDestination is a CNoDestination. */
 bool IsValidDestination(const CTxDestination &dest);
 
 /** Get the name of a txnouttype as a C string, or nullptr if unknown. */
 const char *GetTxnOutputType(txnouttype t);
 
 /**
  * Parse a scriptPubKey and identify script type for standard scripts. If
  * successful, returns script type and parsed pubkeys or hashes, depending on
  * the type. For example, for a P2SH script, vSolutionsRet will contain the
  * script hash, for P2PKH it will contain the key hash, etc.
  *
  * @param[in]   scriptPubKey   Script to parse
  * @param[out]  typeRet        The script type
  * @param[out]  vSolutionsRet  Vector of parsed pubkeys and hashes
  * @return                     True if script matches standard template
  */
 bool Solver(const CScript &scriptPubKey, txnouttype &typeRet,
             std::vector<std::vector<uint8_t>> &vSolutionsRet);
 
 /**
  * Parse a standard scriptPubKey for the destination address. Assigns result to
  * the addressRet parameter and returns true if successful. For multisig
  * scripts, instead use ExtractDestinations. Currently only works for P2PK,
  * P2PKH, and P2SH scripts.
  */
 bool ExtractDestination(const CScript &scriptPubKey,
                         CTxDestination &addressRet);
 
 /**
  * Parse a standard scriptPubKey with one or more destination addresses. For
  * multisig scripts, this populates the addressRet vector with the pubkey IDs
  * and nRequiredRet with the n required to spend. For other destinations,
  * addressRet is populated with a single value and nRequiredRet is set to 1.
  * Returns true if successful. Currently does not extract address from
  * pay-to-witness scripts.
  *
  * Note: this function confuses destinations (a subset of CScripts that are
  * encodable as an address) with key identifiers (of keys involved in a
  * CScript), and its use should be phased out.
  */
 bool ExtractDestinations(const CScript &scriptPubKey, txnouttype &typeRet,
                          std::vector<CTxDestination> &addressRet,
                          int &nRequiredRet);
 
 /**
  * Generate a Bitcoin scriptPubKey for the given CTxDestination. Returns a P2PKH
  * script for a CKeyID destination, a P2SH script for a CScriptID, and an empty
  * script for CNoDestination.
  */
 CScript GetScriptForDestination(const CTxDestination &dest);
 
 /** Generate a P2PK script for the given pubkey. */
 CScript GetScriptForRawPubKey(const CPubKey &pubkey);
 
 /** Generate a multisig script. */
 CScript GetScriptForMultisig(int nRequired, const std::vector<CPubKey> &keys);
 
 #endif // BITCOIN_SCRIPT_STANDARD_H