diff --git a/src/test/checkdatasig_tests.cpp b/src/test/checkdatasig_tests.cpp
index 08415ffd86..97c342e78b 100644
--- a/src/test/checkdatasig_tests.cpp
+++ b/src/test/checkdatasig_tests.cpp
@@ -1,255 +1,262 @@
 // Copyright (c) 2018 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <policy/policy.h>
 #include <script/interpreter.h>
 
 #include <test/lcg.h>
 #include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <array>
 #include <bitset>
 
 typedef std::vector<uint8_t> valtype;
 typedef std::vector<valtype> stacktype;
 
 BOOST_FIXTURE_TEST_SUITE(checkdatasig_tests, BasicTestingSetup)
 
 std::array<uint32_t, 3> flagset{
     {0, STANDARD_SCRIPT_VERIFY_FLAGS, MANDATORY_SCRIPT_VERIFY_FLAGS}};
 
 const uint8_t vchPrivkey[32] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
 
 struct KeyData {
     CKey privkey, privkeyC;
     CPubKey pubkey, pubkeyC, pubkeyH;
 
     KeyData() {
         privkey.Set(vchPrivkey, vchPrivkey + 32, false);
         privkeyC.Set(vchPrivkey, vchPrivkey + 32, true);
         pubkey = privkey.GetPubKey();
         pubkeyH = privkey.GetPubKey();
         pubkeyC = privkeyC.GetPubKey();
         *const_cast<uint8_t *>(&pubkeyH[0]) = 0x06 | (pubkeyH[64] & 1);
     }
 };
 
 static void CheckError(uint32_t flags, const stacktype &original_stack,
                        const CScript &script, ScriptError expected) {
     BaseSignatureChecker sigchecker;
     ScriptError err = SCRIPT_ERR_OK;
     stacktype stack{original_stack};
     bool r = EvalScript(stack, script, flags, sigchecker, &err);
     BOOST_CHECK(!r);
     BOOST_CHECK_EQUAL(err, expected);
 }
 
 static void CheckPass(uint32_t flags, const stacktype &original_stack,
                       const CScript &script, const stacktype &expected) {
     BaseSignatureChecker sigchecker;
     ScriptError err = SCRIPT_ERR_OK;
     stacktype stack{original_stack};
     bool r = EvalScript(stack, script, flags, sigchecker, &err);
     BOOST_CHECK(r);
     BOOST_CHECK_EQUAL(err, SCRIPT_ERR_OK);
     BOOST_CHECK(stack == expected);
 }
 
 /**
  * General utility functions to check for script passing/failing.
  */
 static void CheckTestResultForAllFlags(const stacktype &original_stack,
                                        const CScript &script,
                                        const stacktype &expected) {
     for (uint32_t flags : flagset) {
         // Make sure that we get a bad opcode when the activation flag is not
         // passed.
-        CheckError(flags, original_stack, script, SCRIPT_ERR_BAD_OPCODE);
+        CheckError(flags & ~SCRIPT_ENABLE_CHECKDATASIG, original_stack, script,
+                   SCRIPT_ERR_BAD_OPCODE);
 
         // The script execute as expected if the opcodes are activated.
         CheckPass(flags | SCRIPT_ENABLE_CHECKDATASIG, original_stack, script,
                   expected);
     }
 }
 
 static void CheckErrorForAllFlags(const stacktype &original_stack,
                                   const CScript &script, ScriptError expected) {
     for (uint32_t flags : flagset) {
         // Make sure that we get a bad opcode when the activation flag is not
         // passed.
-        CheckError(flags, original_stack, script, SCRIPT_ERR_BAD_OPCODE);
+        CheckError(flags & ~SCRIPT_ENABLE_CHECKDATASIG, original_stack, script,
+                   SCRIPT_ERR_BAD_OPCODE);
 
         // The script generates the proper error if the opcodes are activated.
         CheckError(flags | SCRIPT_ENABLE_CHECKDATASIG, original_stack, script,
                    expected);
     }
 }
 
 BOOST_AUTO_TEST_CASE(checkdatasig_test) {
     // Empty stack.
     CheckErrorForAllFlags({}, CScript() << OP_CHECKDATASIG,
                           SCRIPT_ERR_INVALID_STACK_OPERATION);
     CheckErrorForAllFlags({{0x00}}, CScript() << OP_CHECKDATASIG,
                           SCRIPT_ERR_INVALID_STACK_OPERATION);
     CheckErrorForAllFlags({{0x00}, {0x00}}, CScript() << OP_CHECKDATASIG,
                           SCRIPT_ERR_INVALID_STACK_OPERATION);
     CheckErrorForAllFlags({}, CScript() << OP_CHECKDATASIGVERIFY,
                           SCRIPT_ERR_INVALID_STACK_OPERATION);
     CheckErrorForAllFlags({{0x00}}, CScript() << OP_CHECKDATASIGVERIFY,
                           SCRIPT_ERR_INVALID_STACK_OPERATION);
     CheckErrorForAllFlags({{0x00}, {0x00}}, CScript() << OP_CHECKDATASIGVERIFY,
                           SCRIPT_ERR_INVALID_STACK_OPERATION);
 
     // Check various pubkey encoding.
     const valtype message{};
     valtype vchHash(32);
     CSHA256().Write(message.data(), message.size()).Finalize(vchHash.data());
     uint256 messageHash(vchHash);
 
     KeyData kd;
     valtype pubkey = ToByteVector(kd.pubkey);
     valtype pubkeyC = ToByteVector(kd.pubkeyC);
     valtype pubkeyH = ToByteVector(kd.pubkeyH);
 
     CheckTestResultForAllFlags({{}, message, pubkey},
                                CScript() << OP_CHECKDATASIG, {{}});
     CheckTestResultForAllFlags({{}, message, pubkeyC},
                                CScript() << OP_CHECKDATASIG, {{}});
     CheckErrorForAllFlags({{}, message, pubkey},
                           CScript() << OP_CHECKDATASIGVERIFY,
                           SCRIPT_ERR_CHECKDATASIGVERIFY);
     CheckErrorForAllFlags({{}, message, pubkeyC},
                           CScript() << OP_CHECKDATASIGVERIFY,
                           SCRIPT_ERR_CHECKDATASIGVERIFY);
 
     // Flags dependent checks.
     const CScript script = CScript() << OP_CHECKDATASIG << OP_NOT << OP_VERIFY;
     const CScript scriptverify = CScript() << OP_CHECKDATASIGVERIFY;
 
     // Check valid signatures (as in the signature format is valid).
     valtype validsig;
     kd.privkey.SignECDSA(messageHash, validsig);
 
     CheckTestResultForAllFlags({validsig, message, pubkey},
                                CScript() << OP_CHECKDATASIG, {{0x01}});
     CheckTestResultForAllFlags({validsig, message, pubkey},
                                CScript() << OP_CHECKDATASIGVERIFY, {});
 
     const valtype minimalsig{0x30, 0x06, 0x02, 0x01, 0x01, 0x02, 0x01, 0x01};
     const valtype nondersig{0x30, 0x80, 0x06, 0x02, 0x01,
                             0x01, 0x02, 0x01, 0x01};
     const valtype highSSig{
         0x30, 0x45, 0x02, 0x20, 0x3e, 0x45, 0x16, 0xda, 0x72, 0x53, 0xcf, 0x06,
         0x8e, 0xff, 0xec, 0x6b, 0x95, 0xc4, 0x12, 0x21, 0xc0, 0xcf, 0x3a, 0x8e,
         0x6c, 0xcb, 0x8c, 0xbf, 0x17, 0x25, 0xb5, 0x62, 0xe9, 0xaf, 0xde, 0x2c,
         0x02, 0x21, 0x00, 0xab, 0x1e, 0x3d, 0xa7, 0x3d, 0x67, 0xe3, 0x20, 0x45,
         0xa2, 0x0e, 0x0b, 0x99, 0x9e, 0x04, 0x99, 0x78, 0xea, 0x8d, 0x6e, 0xe5,
         0x48, 0x0d, 0x48, 0x5f, 0xcf, 0x2c, 0xe0, 0xd0, 0x3b, 0x2e, 0xf0};
 
     MMIXLinearCongruentialGenerator lcg;
     for (int i = 0; i < 4096; i++) {
         uint32_t flags = lcg.next() | SCRIPT_ENABLE_CHECKDATASIG;
 
         if (flags & SCRIPT_VERIFY_STRICTENC) {
             // When strict encoding is enforced, hybrid keys are invalid.
             CheckError(flags, {{}, message, pubkeyH}, script,
                        SCRIPT_ERR_PUBKEYTYPE);
             CheckError(flags, {{}, message, pubkeyH}, scriptverify,
                        SCRIPT_ERR_PUBKEYTYPE);
         } else if (flags & SCRIPT_VERIFY_COMPRESSED_PUBKEYTYPE) {
             // When compressed-only is enforced, hybrid keys are invalid.
             CheckError(flags, {{}, message, pubkeyH}, script,
                        SCRIPT_ERR_NONCOMPRESSED_PUBKEY);
             CheckError(flags, {{}, message, pubkeyH}, scriptverify,
                        SCRIPT_ERR_NONCOMPRESSED_PUBKEY);
         } else {
             // Otherwise, hybrid keys are valid.
             CheckPass(flags, {{}, message, pubkeyH}, script, {});
             CheckError(flags, {{}, message, pubkeyH}, scriptverify,
                        SCRIPT_ERR_CHECKDATASIGVERIFY);
         }
 
         if (flags & SCRIPT_VERIFY_COMPRESSED_PUBKEYTYPE) {
             // When compressed-only is enforced, uncompressed keys are invalid.
             CheckError(flags, {{}, message, pubkey}, script,
                        SCRIPT_ERR_NONCOMPRESSED_PUBKEY);
             CheckError(flags, {{}, message, pubkey}, scriptverify,
                        SCRIPT_ERR_NONCOMPRESSED_PUBKEY);
         } else {
             // Otherwise, uncompressed keys are valid.
             CheckPass(flags, {{}, message, pubkey}, script, {});
             CheckError(flags, {{}, message, pubkey}, scriptverify,
                        SCRIPT_ERR_CHECKDATASIGVERIFY);
         }
 
         if (flags & SCRIPT_VERIFY_NULLFAIL) {
             // Invalid signature causes checkdatasig to fail.
             CheckError(flags, {minimalsig, message, pubkeyC}, script,
                        SCRIPT_ERR_SIG_NULLFAIL);
             CheckError(flags, {minimalsig, message, pubkeyC}, scriptverify,
                        SCRIPT_ERR_SIG_NULLFAIL);
 
             // Invalid message causes checkdatasig to fail.
             CheckError(flags, {validsig, {0x01}, pubkeyC}, script,
                        SCRIPT_ERR_SIG_NULLFAIL);
             CheckError(flags, {validsig, {0x01}, pubkeyC}, scriptverify,
                        SCRIPT_ERR_SIG_NULLFAIL);
         } else {
             // When nullfail is not enforced, invalid signature are just false.
             CheckPass(flags, {minimalsig, message, pubkeyC}, script, {});
             CheckError(flags, {minimalsig, message, pubkeyC}, scriptverify,
                        SCRIPT_ERR_CHECKDATASIGVERIFY);
 
             // Invalid message cause checkdatasig to fail.
             CheckPass(flags, {validsig, {0x01}, pubkeyC}, script, {});
             CheckError(flags, {validsig, {0x01}, pubkeyC}, scriptverify,
                        SCRIPT_ERR_CHECKDATASIGVERIFY);
         }
 
         if (flags & SCRIPT_VERIFY_LOW_S) {
             // If we do enforce low S, then high S sigs are rejected.
             CheckError(flags, {highSSig, message, pubkeyC}, script,
                        SCRIPT_ERR_SIG_HIGH_S);
             CheckError(flags, {highSSig, message, pubkeyC}, scriptverify,
                        SCRIPT_ERR_SIG_HIGH_S);
         } else if (flags & SCRIPT_VERIFY_NULLFAIL) {
             // If we do enforce nullfail, these invalid sigs hit this.
             CheckError(flags, {highSSig, message, pubkeyC}, script,
                        SCRIPT_ERR_SIG_NULLFAIL);
             CheckError(flags, {highSSig, message, pubkeyC}, scriptverify,
                        SCRIPT_ERR_SIG_NULLFAIL);
         } else {
             // If we do not enforce low S, then high S sigs are accepted.
             CheckPass(flags, {highSSig, message, pubkeyC}, script, {});
             CheckError(flags, {highSSig, message, pubkeyC}, scriptverify,
                        SCRIPT_ERR_CHECKDATASIGVERIFY);
         }
 
         if (flags & (SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_LOW_S |
                      SCRIPT_VERIFY_STRICTENC)) {
             // If we get any of the dersig flags, the non canonical dersig
             // signature fails.
             CheckError(flags, {nondersig, message, pubkeyC}, script,
                        SCRIPT_ERR_SIG_DER);
             CheckError(flags, {nondersig, message, pubkeyC}, scriptverify,
                        SCRIPT_ERR_SIG_DER);
         } else if (flags & SCRIPT_VERIFY_NULLFAIL) {
             // If we do enforce nullfail, these invalid sigs hit this.
             CheckError(flags, {nondersig, message, pubkeyC}, script,
                        SCRIPT_ERR_SIG_NULLFAIL);
             CheckError(flags, {nondersig, message, pubkeyC}, scriptverify,
                        SCRIPT_ERR_SIG_NULLFAIL);
         } else {
             // If we do not check, then it is accepted.
             CheckPass(flags, {nondersig, message, pubkeyC}, script, {});
             CheckError(flags, {nondersig, message, pubkeyC}, scriptverify,
                        SCRIPT_ERR_CHECKDATASIGVERIFY);
         }
     }
 }
 
+BOOST_AUTO_TEST_CASE(checkdatasig_inclusion_in_standard_and_mandatory_flags) {
+    BOOST_CHECK(!(STANDARD_SCRIPT_VERIFY_FLAGS & SCRIPT_ENABLE_CHECKDATASIG));
+    BOOST_CHECK(!(MANDATORY_SCRIPT_VERIFY_FLAGS & SCRIPT_ENABLE_CHECKDATASIG));
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/sigopcount_tests.cpp b/src/test/sigopcount_tests.cpp
index 3553a3f9ac..634f65da99 100644
--- a/src/test/sigopcount_tests.cpp
+++ b/src/test/sigopcount_tests.cpp
@@ -1,280 +1,290 @@
 // Copyright (c) 2012-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.
 
 #include <consensus/consensus.h>
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
 #include <key.h>
-#include <policy/policy.h> // For STANDARD_CHECKDATASIG_VERIFY_FLAGS.
+#include <policy/policy.h>
 #include <pubkey.h>
 #include <script/interpreter.h>
 #include <script/script.h>
 #include <script/standard.h>
 #include <uint256.h>
 
 #include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <limits>
 #include <vector>
 
 // Helpers:
 static std::vector<uint8_t> Serialize(const CScript &s) {
     std::vector<uint8_t> sSerialized(s.begin(), s.end());
     return sSerialized;
 }
 
 BOOST_FIXTURE_TEST_SUITE(sigopcount_tests, BasicTestingSetup)
 
 void CheckScriptSigOps(const CScript &script, uint32_t accurate_sigops,
                        uint32_t inaccurate_sigops, uint32_t datasigops) {
-    const uint32_t stdflags = STANDARD_SCRIPT_VERIFY_FLAGS;
-    const uint32_t datasigflags = STANDARD_CHECKDATASIG_VERIFY_FLAGS;
+    const uint32_t nodatasigflags =
+        STANDARD_SCRIPT_VERIFY_FLAGS & ~SCRIPT_ENABLE_CHECKDATASIG;
+    const uint32_t datasigflags =
+        STANDARD_SCRIPT_VERIFY_FLAGS | SCRIPT_ENABLE_CHECKDATASIG;
 
-    BOOST_CHECK_EQUAL(script.GetSigOpCount(stdflags, false), inaccurate_sigops);
+    BOOST_CHECK_EQUAL(script.GetSigOpCount(nodatasigflags, false),
+                      inaccurate_sigops);
     BOOST_CHECK_EQUAL(script.GetSigOpCount(datasigflags, false),
                       inaccurate_sigops + datasigops);
-    BOOST_CHECK_EQUAL(script.GetSigOpCount(stdflags, true), accurate_sigops);
+    BOOST_CHECK_EQUAL(script.GetSigOpCount(nodatasigflags, true),
+                      accurate_sigops);
     BOOST_CHECK_EQUAL(script.GetSigOpCount(datasigflags, true),
                       accurate_sigops + datasigops);
 
     const CScript p2sh = GetScriptForDestination(CScriptID(script));
     const CScript scriptSig = CScript() << OP_0 << Serialize(script);
-    BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(stdflags, scriptSig), accurate_sigops);
+    BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(nodatasigflags, scriptSig),
+                      accurate_sigops);
     BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(datasigflags, scriptSig),
                       accurate_sigops + datasigops);
 
     // Check that GetSigOpCount do not report sigops in the P2SH script when the
     // P2SH flags isn't passed in.
     BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(SCRIPT_VERIFY_NONE, scriptSig), 0U);
 
     // Check that GetSigOpCount report the exact count when not passed a P2SH.
-    BOOST_CHECK_EQUAL(script.GetSigOpCount(stdflags, p2sh), accurate_sigops);
+    BOOST_CHECK_EQUAL(script.GetSigOpCount(nodatasigflags, p2sh),
+                      accurate_sigops);
     BOOST_CHECK_EQUAL(script.GetSigOpCount(datasigflags, p2sh),
                       accurate_sigops + datasigops);
     BOOST_CHECK_EQUAL(script.GetSigOpCount(SCRIPT_VERIFY_NONE, p2sh),
                       accurate_sigops);
 }
 
 BOOST_AUTO_TEST_CASE(GetSigOpCount) {
     // Test CScript::GetSigOpCount()
     CheckScriptSigOps(CScript(), 0, 0, 0);
 
     uint160 dummy;
     const CScript s1 = CScript()
                        << OP_1 << ToByteVector(dummy) << ToByteVector(dummy)
                        << OP_2 << OP_CHECKMULTISIG;
     CheckScriptSigOps(s1, 2, 20, 0);
 
     const CScript s2 = CScript(s1) << OP_IF << OP_CHECKSIG << OP_ENDIF;
     CheckScriptSigOps(s2, 3, 21, 0);
 
     std::vector<CPubKey> keys;
     for (int i = 0; i < 3; i++) {
         CKey k;
         k.MakeNewKey(true);
         keys.push_back(k.GetPubKey());
     }
 
     const CScript s3 = GetScriptForMultisig(1, keys);
     CheckScriptSigOps(s3, 3, 20, 0);
 
     const CScript p2sh = GetScriptForDestination(CScriptID(s3));
     CheckScriptSigOps(p2sh, 0, 0, 0);
 
     CScript scriptSig2;
     scriptSig2 << OP_1 << ToByteVector(dummy) << ToByteVector(dummy)
                << Serialize(s3);
-    BOOST_CHECK_EQUAL(
-        p2sh.GetSigOpCount(STANDARD_SCRIPT_VERIFY_FLAGS, scriptSig2), 3U);
-    BOOST_CHECK_EQUAL(
-        p2sh.GetSigOpCount(STANDARD_CHECKDATASIG_VERIFY_FLAGS, scriptSig2), 3U);
+    BOOST_CHECK_EQUAL(p2sh.GetSigOpCount((STANDARD_SCRIPT_VERIFY_FLAGS &
+                                          ~SCRIPT_ENABLE_CHECKDATASIG),
+                                         scriptSig2),
+                      3U);
+    BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(STANDARD_SCRIPT_VERIFY_FLAGS |
+                                             SCRIPT_ENABLE_CHECKDATASIG,
+                                         scriptSig2),
+                      3U);
     BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(SCRIPT_VERIFY_NONE, scriptSig2), 0U);
 
     const CScript s4 = CScript(s1) << OP_IF << OP_CHECKDATASIG << OP_ENDIF;
     CheckScriptSigOps(s4, 2, 20, 1);
 
     const CScript s5 = CScript(s4) << OP_CHECKDATASIGVERIFY;
     CheckScriptSigOps(s5, 2, 20, 2);
 }
 
 /**
  * Verifies script execution of the zeroth scriptPubKey of tx output and zeroth
  * scriptSig and witness of tx input.
  */
 ScriptError VerifyWithFlag(const CTransaction &output,
                            const CMutableTransaction &input, int flags) {
     ScriptError error;
     CTransaction inputi(input);
     bool ret = VerifyScript(
         inputi.vin[0].scriptSig, output.vout[0].scriptPubKey, flags,
         TransactionSignatureChecker(&inputi, 0, output.vout[0].nValue), &error);
     BOOST_CHECK_EQUAL((ret == true), (error == SCRIPT_ERR_OK));
 
     return error;
 }
 
 /**
  * Builds a creationTx from scriptPubKey and a spendingTx from scriptSig and
  * witness such that spendingTx spends output zero of creationTx. Also inserts
  * creationTx's output into the coins view.
  */
 void BuildTxs(CMutableTransaction &spendingTx, CCoinsViewCache &coins,
               CMutableTransaction &creationTx, const CScript &scriptPubKey,
               const CScript &scriptSig) {
     creationTx.nVersion = 1;
     creationTx.vin.resize(1);
     creationTx.vin[0].prevout = COutPoint();
     creationTx.vin[0].scriptSig = CScript();
     creationTx.vout.resize(1);
     creationTx.vout[0].nValue = SATOSHI;
     creationTx.vout[0].scriptPubKey = scriptPubKey;
 
     spendingTx.nVersion = 1;
     spendingTx.vin.resize(1);
     spendingTx.vin[0].prevout = COutPoint(creationTx.GetId(), 0);
     spendingTx.vin[0].scriptSig = scriptSig;
     spendingTx.vout.resize(1);
     spendingTx.vout[0].nValue = SATOSHI;
     spendingTx.vout[0].scriptPubKey = CScript();
 
     AddCoins(coins, CTransaction(creationTx), 0);
 }
 
 BOOST_AUTO_TEST_CASE(GetTxSigOpCost) {
     // Transaction creates outputs
     CMutableTransaction creationTx;
     // Transaction that spends outputs and whose sig op cost is going to be
     // tested
     CMutableTransaction spendingTx;
 
     // Create utxo set
     CCoinsView coinsDummy;
     CCoinsViewCache coins(&coinsDummy);
     // Create key
     CKey key;
     key.MakeNewKey(true);
     CPubKey pubkey = key.GetPubKey();
     // Default flags
     const uint32_t flags = SCRIPT_VERIFY_P2SH;
 
     // Multisig script (legacy counting)
     {
         CScript scriptPubKey = CScript() << 1 << ToByteVector(pubkey)
                                          << ToByteVector(pubkey) << 2
                                          << OP_CHECKMULTISIGVERIFY;
         // Do not use a valid signature to avoid using wallet operations.
         CScript scriptSig = CScript() << OP_0 << OP_0;
 
         BuildTxs(spendingTx, coins, creationTx, scriptPubKey, scriptSig);
 
         // Legacy counting only includes signature operations in scriptSigs and
         // scriptPubKeys of a transaction and does not take the actual executed
         // sig operations into account. spendingTx in itself does not contain a
         // signature operation.
         BOOST_CHECK_EQUAL(
             GetTransactionSigOpCount(CTransaction(spendingTx), coins, flags),
             0);
         // creationTx contains two signature operations in its scriptPubKey, but
         // legacy counting is not accurate.
         BOOST_CHECK_EQUAL(
             GetTransactionSigOpCount(CTransaction(creationTx), coins, flags),
             MAX_PUBKEYS_PER_MULTISIG);
         // Sanity check: script verification fails because of an invalid
         // signature.
         BOOST_CHECK_EQUAL(
             VerifyWithFlag(CTransaction(creationTx), spendingTx, flags),
             SCRIPT_ERR_CHECKMULTISIGVERIFY);
 
         // Make sure non P2SH sigops are counted even if the flag for P2SH is
         // not passed in.
         BOOST_CHECK_EQUAL(GetTransactionSigOpCount(CTransaction(spendingTx),
                                                    coins, SCRIPT_VERIFY_NONE),
                           0);
         BOOST_CHECK_EQUAL(GetTransactionSigOpCount(CTransaction(creationTx),
                                                    coins, SCRIPT_VERIFY_NONE),
                           MAX_PUBKEYS_PER_MULTISIG);
     }
 
     // Multisig nested in P2SH
     {
         CScript redeemScript = CScript() << 1 << ToByteVector(pubkey)
                                          << ToByteVector(pubkey) << 2
                                          << OP_CHECKMULTISIGVERIFY;
         CScript scriptPubKey = GetScriptForDestination(CScriptID(redeemScript));
         CScript scriptSig = CScript()
                             << OP_0 << OP_0 << ToByteVector(redeemScript);
 
         BuildTxs(spendingTx, coins, creationTx, scriptPubKey, scriptSig);
         BOOST_CHECK_EQUAL(
             GetTransactionSigOpCount(CTransaction(spendingTx), coins, flags),
             2);
         BOOST_CHECK_EQUAL(
             VerifyWithFlag(CTransaction(creationTx), spendingTx, flags),
             SCRIPT_ERR_CHECKMULTISIGVERIFY);
 
         // Make sure P2SH sigops are not counted if the flag for P2SH is not
         // passed in.
         BOOST_CHECK_EQUAL(GetTransactionSigOpCount(CTransaction(spendingTx),
                                                    coins, SCRIPT_VERIFY_NONE),
                           0);
     }
 }
 
 BOOST_AUTO_TEST_CASE(test_consensus_sigops_limit) {
     BOOST_CHECK_EQUAL(GetMaxBlockSigOpsCount(1), MAX_BLOCK_SIGOPS_PER_MB);
     BOOST_CHECK_EQUAL(GetMaxBlockSigOpsCount(123456), MAX_BLOCK_SIGOPS_PER_MB);
     BOOST_CHECK_EQUAL(GetMaxBlockSigOpsCount(1000000), MAX_BLOCK_SIGOPS_PER_MB);
     BOOST_CHECK_EQUAL(GetMaxBlockSigOpsCount(1000001),
                       2 * MAX_BLOCK_SIGOPS_PER_MB);
     BOOST_CHECK_EQUAL(GetMaxBlockSigOpsCount(1348592),
                       2 * MAX_BLOCK_SIGOPS_PER_MB);
     BOOST_CHECK_EQUAL(GetMaxBlockSigOpsCount(2000000),
                       2 * MAX_BLOCK_SIGOPS_PER_MB);
     BOOST_CHECK_EQUAL(GetMaxBlockSigOpsCount(2000001),
                       3 * MAX_BLOCK_SIGOPS_PER_MB);
     BOOST_CHECK_EQUAL(GetMaxBlockSigOpsCount(2654321),
                       3 * MAX_BLOCK_SIGOPS_PER_MB);
     BOOST_CHECK_EQUAL(
         GetMaxBlockSigOpsCount(std::numeric_limits<uint32_t>::max()),
         4295 * MAX_BLOCK_SIGOPS_PER_MB);
 }
 
 BOOST_AUTO_TEST_CASE(test_max_sigops_per_tx) {
     CMutableTransaction tx;
     tx.nVersion = 1;
     tx.vin.resize(1);
     tx.vin[0].prevout = COutPoint(InsecureRand256(), 0);
     tx.vin[0].scriptSig = CScript();
     tx.vout.resize(1);
     tx.vout[0].nValue = SATOSHI;
     tx.vout[0].scriptPubKey = CScript();
 
     {
         CValidationState state;
         BOOST_CHECK(CheckRegularTransaction(CTransaction(tx), state));
     }
 
     // Get just before the limit.
     for (size_t i = 0; i < MAX_TX_SIGOPS_COUNT; i++) {
         tx.vout[0].scriptPubKey << OP_CHECKSIG;
     }
 
     {
         CValidationState state;
         BOOST_CHECK(CheckRegularTransaction(CTransaction(tx), state));
     }
 
     // And go over.
     tx.vout[0].scriptPubKey << OP_CHECKSIG;
 
     {
         CValidationState state;
         BOOST_CHECK(!CheckRegularTransaction(CTransaction(tx), state));
         BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-txn-sigops");
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()