diff --git a/src/Makefile.test.include b/src/Makefile.test.include
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -174,7 +174,6 @@
   test/sighash_tests.cpp \
   test/sighashtype_tests.cpp \
   test/sigcheckcount_tests.cpp \
-  test/sigopcount_tests.cpp \
   test/sigutil.h \
   test/skiplist_tests.cpp \
   test/streams_tests.cpp \
diff --git a/src/script/script.cpp b/src/script/script.cpp
--- a/src/script/script.cpp
+++ b/src/script/script.cpp
@@ -371,47 +371,7 @@
 }
 
 uint32_t CScript::GetSigOpCount(uint32_t flags, bool fAccurate) const {
-    if (flags & SCRIPT_ZERO_SIGOPS) {
-        return 0;
-    }
-    uint32_t n = 0;
-    const_iterator pc = begin();
-    opcodetype lastOpcode = OP_INVALIDOPCODE;
-    while (pc < end()) {
-        opcodetype opcode;
-        if (!GetOp(pc, opcode)) {
-            break;
-        }
-
-        switch (opcode) {
-            case OP_CHECKSIG:
-            case OP_CHECKSIGVERIFY:
-                n++;
-                break;
-
-            case OP_CHECKDATASIG:
-            case OP_CHECKDATASIGVERIFY:
-                if (flags & SCRIPT_VERIFY_CHECKDATASIG_SIGOPS) {
-                    n++;
-                }
-                break;
-
-            case OP_CHECKMULTISIG:
-            case OP_CHECKMULTISIGVERIFY:
-                if (fAccurate && lastOpcode >= OP_1 && lastOpcode <= OP_16) {
-                    n += DecodeOP_N(lastOpcode);
-                } else {
-                    n += MAX_PUBKEYS_PER_MULTISIG;
-                }
-                break;
-            default:
-                break;
-        }
-
-        lastOpcode = opcode;
-    }
-
-    return n;
+    return 0;
 }
 
 uint32_t CScript::GetSigOpCount(uint32_t flags,
diff --git a/src/script/script_flags.h b/src/script/script_flags.h
--- a/src/script/script_flags.h
+++ b/src/script/script_flags.h
@@ -110,11 +110,6 @@
     // Whether the new OP_REVERSEBYTES opcode can be used.
     SCRIPT_ENABLE_OP_REVERSEBYTES = (1U << 23),
 
-    // Setting this flag zeroes sigops counting and thus results in the removal
-    // of all sigop limits. This flag only affects sigops counting, and will be
-    // removed during cleanup of the SigChecks upgrade.
-    SCRIPT_ZERO_SIGOPS = (1U << 30),
-
     // A utility flag to decide whether VerifyScript should output the correct
     // sigchecks value or to report zero.
     // This has no effect on script success / failure, and will be removed
diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -175,7 +175,6 @@
 		sighash_tests.cpp
 		sighashtype_tests.cpp
 		sigcheckcount_tests.cpp
-		sigopcount_tests.cpp
 		skiplist_tests.cpp
 		streams_tests.cpp
 		sync_tests.cpp
diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp
--- a/src/test/miner_tests.cpp
+++ b/src/test/miner_tests.cpp
@@ -331,55 +331,8 @@
     const Amount HIGHFEE = COIN;
     const Amount HIGHERFEE = 4 * COIN;
 
-    // block sigops > limit: 1000 CHECKMULTISIG + 1
-    tx.vin.resize(1);
-    // NOTE: OP_NOP is used to force 20 SigOps for the CHECKMULTISIG
-    tx.vin[0].scriptSig = CScript() << OP_0 << OP_0 << OP_0 << OP_NOP
-                                    << OP_CHECKMULTISIG << OP_1;
-    tx.vin[0].prevout = COutPoint(txFirst[0]->GetId(), 0);
-    tx.vout.resize(1);
-    tx.vout[0].nValue = BLOCKSUBSIDY;
-    for (unsigned int i = 0; i < 1001; ++i) {
-        tx.vout[0].nValue -= LOWFEE;
-        const TxId txid = tx.GetId();
-        // Only first tx spends coinbase.
-        bool spendsCoinbase = i == 0;
-        // If we don't set the # of sig ops in the CTxMemPoolEntry, template
-        // creation fails.
-        g_mempool.addUnchecked(entry.Fee(LOWFEE)
-                                   .Time(GetTime())
-                                   .SpendsCoinbase(spendsCoinbase)
-                                   .FromTx(tx));
-        tx.vin[0].prevout = COutPoint(txid, 0);
-    }
-
-    BOOST_CHECK_EXCEPTION(
-        AssemblerForTest(chainparams, g_mempool).CreateNewBlock(scriptPubKey),
-        std::runtime_error, HasReason("bad-blk-sigops"));
-    g_mempool.clear();
-
-    tx.vin[0].prevout = COutPoint(txFirst[0]->GetId(), 0);
-    tx.vout[0].nValue = BLOCKSUBSIDY;
-    for (unsigned int i = 0; i < 1001; ++i) {
-        tx.vout[0].nValue -= LOWFEE;
-        const TxId txid = tx.GetId();
-        // Only first tx spends coinbase.
-        bool spendsCoinbase = i == 0;
-        // If we do set the # of sig ops in the CTxMemPoolEntry, template
-        // creation passes.
-        g_mempool.addUnchecked(entry.Fee(LOWFEE)
-                                   .Time(GetTime())
-                                   .SpendsCoinbase(spendsCoinbase)
-                                   .SigOpCount(20)
-                                   .FromTx(tx));
-        tx.vin[0].prevout = COutPoint(txid, 0);
-    }
-
-    BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams, g_mempool)
-                                     .CreateNewBlock(scriptPubKey));
-    g_mempool.clear();
-
     // block size > limit
+    tx.vin.resize(1);
     tx.vin[0].scriptSig = CScript();
     // 18 * (520char + DROP) + OP_1 = 9433 bytes
     std::vector<uint8_t> vchData(520);
@@ -389,6 +342,7 @@
 
     tx.vin[0].scriptSig << OP_1;
     tx.vin[0].prevout = COutPoint(txFirst[0]->GetId(), 0);
+    tx.vout.resize(1);
     tx.vout[0].nValue = BLOCKSUBSIDY;
     for (unsigned int i = 0; i < 128; ++i) {
         tx.vout[0].nValue -= LOWFEE;
diff --git a/src/test/script_p2sh_tests.cpp b/src/test/script_p2sh_tests.cpp
--- a/src/test/script_p2sh_tests.cpp
+++ b/src/test/script_p2sh_tests.cpp
@@ -407,64 +407,6 @@
                               SigHashType().withForkId()));
     BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 2,
                               SigHashType().withForkId()));
-    // SignSignature doesn't know how to sign these. We're not testing
-    // validating signatures, so just create dummy signatures that DO include
-    // the correct P2SH scripts:
-    txTo.vin[3].scriptSig << OP_11 << OP_11
-                          << std::vector<uint8_t>(oneAndTwo.begin(),
-                                                  oneAndTwo.end());
-    txTo.vin[4].scriptSig << std::vector<uint8_t>(fifteenSigops.begin(),
-                                                  fifteenSigops.end());
-
-    BOOST_CHECK(::AreInputsStandard(CTransaction(txTo), coins,
-                                    STANDARD_SCRIPT_VERIFY_FLAGS));
-    // 22 P2SH sigops for all inputs (1 for vin[0], 6 for vin[3], 15 for vin[4]
-    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txTo), coins,
-                                        STANDARD_SCRIPT_VERIFY_FLAGS),
-                      22U);
-    // Check that no sigops show up when P2SH is not activated.
-    BOOST_CHECK_EQUAL(
-        GetP2SHSigOpCount(CTransaction(txTo), coins, SCRIPT_VERIFY_NONE), 0);
-
-    CMutableTransaction txToNonStd1;
-    txToNonStd1.vout.resize(1);
-    txToNonStd1.vout[0].scriptPubKey =
-        GetScriptForDestination(key[1].GetPubKey().GetID());
-    txToNonStd1.vout[0].nValue = 1000 * SATOSHI;
-    txToNonStd1.vin.resize(1);
-    txToNonStd1.vin[0].prevout = COutPoint(txFrom.GetId(), 5);
-    txToNonStd1.vin[0].scriptSig
-        << std::vector<uint8_t>(sixteenSigops.begin(), sixteenSigops.end());
-
-    BOOST_CHECK(!::AreInputsStandard(CTransaction(txToNonStd1), coins,
-                                     STANDARD_SCRIPT_VERIFY_FLAGS));
-    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txToNonStd1), coins,
-                                        STANDARD_SCRIPT_VERIFY_FLAGS),
-                      16U);
-    // Check that no sigops show up when P2SH is not activated.
-    BOOST_CHECK_EQUAL(
-        GetP2SHSigOpCount(CTransaction(txToNonStd1), coins, SCRIPT_VERIFY_NONE),
-        0);
-
-    CMutableTransaction txToNonStd2;
-    txToNonStd2.vout.resize(1);
-    txToNonStd2.vout[0].scriptPubKey =
-        GetScriptForDestination(key[1].GetPubKey().GetID());
-    txToNonStd2.vout[0].nValue = 1000 * SATOSHI;
-    txToNonStd2.vin.resize(1);
-    txToNonStd2.vin[0].prevout = COutPoint(txFrom.GetId(), 6);
-    txToNonStd2.vin[0].scriptSig
-        << std::vector<uint8_t>(twentySigops.begin(), twentySigops.end());
-
-    BOOST_CHECK(!::AreInputsStandard(CTransaction(txToNonStd2), coins,
-                                     STANDARD_SCRIPT_VERIFY_FLAGS));
-    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txToNonStd2), coins,
-                                        STANDARD_SCRIPT_VERIFY_FLAGS),
-                      20U);
-    // Check that no sigops show up when P2SH is not activated.
-    BOOST_CHECK_EQUAL(
-        GetP2SHSigOpCount(CTransaction(txToNonStd2), coins, SCRIPT_VERIFY_NONE),
-        0);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/sigopcount_tests.cpp b/src/test/sigopcount_tests.cpp
deleted file mode 100644
--- a/src/test/sigopcount_tests.cpp
+++ /dev/null
@@ -1,253 +0,0 @@
-// Copyright (c) 2012-2019 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 <coins.h>
-#include <consensus/consensus.h>
-#include <consensus/tx_verify.h>
-#include <key.h>
-#include <policy/policy.h>
-#include <pubkey.h>
-#include <script/interpreter.h>
-#include <script/script.h>
-#include <script/standard.h>
-#include <uint256.h>
-
-#include <test/setup_common.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 nodatasigflags =
-        STANDARD_SCRIPT_VERIFY_FLAGS & ~SCRIPT_VERIFY_CHECKDATASIG_SIGOPS;
-    const uint32_t datasigflags =
-        STANDARD_SCRIPT_VERIFY_FLAGS | SCRIPT_VERIFY_CHECKDATASIG_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(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(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(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 &
-                                          ~SCRIPT_VERIFY_CHECKDATASIG_SIGOPS),
-                                         scriptSig2),
-                      3U);
-    BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(STANDARD_SCRIPT_VERIFY_FLAGS |
-                                             SCRIPT_VERIFY_CHECKDATASIG_SIGOPS,
-                                         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 of tx input.
- */
-static 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 == ScriptError::OK));
-
-    return error;
-}
-
-/**
- * Builds a creationTx from scriptPubKey and a spendingTx from scriptSig
- * such that spendingTx spends output zero of creationTx. Also inserts
- * creationTx's output into the coins view.
- */
-static 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(GetTxSigOpCount) {
-    // Transaction creates outputs
-    CMutableTransaction creationTx;
-    // Transaction that spends outputs and whose sig op count 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(VerifyWithFlag(CTransaction(creationTx), spendingTx,
-                                   flags) == ScriptError::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(VerifyWithFlag(CTransaction(creationTx), spendingTx,
-                                   flags) == ScriptError::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_SUITE_END()
diff --git a/src/validation.cpp b/src/validation.cpp
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -1514,7 +1514,6 @@
     if (IsPhononEnabled(params, pindex)) {
         flags |= SCRIPT_ENABLE_OP_REVERSEBYTES;
         flags |= SCRIPT_REPORT_SIGCHECKS;
-        flags |= SCRIPT_ZERO_SIGOPS;
     }
 
     // We make sure this node will have replay protection during the next hard
diff --git a/test/functional/abc-mempool-accept-txn.py b/test/functional/abc-mempool-accept-txn.py
deleted file mode 100755
--- a/test/functional/abc-mempool-accept-txn.py
+++ /dev/null
@@ -1,279 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2017 The Bitcoin developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-"""
-This test checks acceptance of transactions by the mempool
-It is derived from the much more complex p2p-fullblocktest.
-"""
-
-import time
-
-from test_framework.blocktools import (
-    create_block,
-    create_coinbase,
-    create_tx_with_script,
-)
-from test_framework.cdefs import MAX_STANDARD_TX_SIGOPS
-from test_framework.key import ECKey
-from test_framework.messages import (
-    COutPoint,
-    CTransaction,
-    CTxIn,
-    CTxOut,
-    ToHex,
-)
-from test_framework.mininode import (
-    P2PDataStore,
-)
-from test_framework.script import (
-    CScript,
-    hash160,
-    OP_2DUP,
-    OP_CHECKSIG,
-    OP_CHECKSIGVERIFY,
-    OP_DROP,
-    OP_EQUAL,
-    OP_HASH160,
-    OP_TRUE,
-    SIGHASH_ALL,
-    SIGHASH_FORKID,
-    SignatureHashForkId,
-)
-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import assert_equal, assert_raises_rpc_error
-
-# Error for too many sigops in one TX
-RPC_TXNS_TOO_MANY_SIGOPS_ERROR = "bad-txns-too-many-sigops"
-
-# Set test to run with sigops deactivation far in the future.
-SIGOPS_DEACTIVATION_TIME = 2000000000
-
-
-class PreviousSpendableOutput():
-
-    def __init__(self, tx=CTransaction(), n=-1):
-        self.tx = tx
-        # The output we're spending
-        self.n = n
-
-
-class FullBlockTest(BitcoinTestFramework):
-
-    def set_test_params(self):
-        self.num_nodes = 1
-        self.setup_clean_chain = True
-        self.block_heights = {}
-        self.coinbase_key = ECKey()
-        # The test expects uncompressed keys
-        self.coinbase_key.generate(compressed=False)
-        self.coinbase_pubkey = self.coinbase_key.get_pubkey().get_bytes()
-        self.tip = None
-        self.blocks = {}
-        self.extra_args = [
-            ['-phononactivationtime={}'.format(SIGOPS_DEACTIVATION_TIME),
-             '-acceptnonstdtxn=1']]
-
-    def add_options(self, parser):
-        super().add_options(parser)
-        parser.add_argument(
-            "--runbarelyexpensive", dest="runbarelyexpensive", default=True)
-
-    def add_transactions_to_block(self, block, tx_list):
-        [tx.rehash() for tx in tx_list]
-        block.vtx.extend(tx_list)
-        block.vtx = [block.vtx[0]] + \
-            sorted(block.vtx[1:], key=lambda tx: tx.get_id())
-
-    # this is a little handier to use than the version in blocktools.py
-    def create_tx(self, spend_tx, n, value, script=CScript([OP_TRUE])):
-        tx = create_tx_with_script(spend_tx, n, b"", value, script)
-        return tx
-
-    # sign a transaction, using the key we know about
-    # this signs input 0 in tx, which is assumed to be spending output n in
-    # spend_tx
-    def sign_tx(self, tx, spend_tx, n):
-        scriptPubKey = bytearray(spend_tx.vout[n].scriptPubKey)
-        if (scriptPubKey[0] == OP_TRUE):  # an anyone-can-spend
-            tx.vin[0].scriptSig = CScript()
-            return
-        sighash = SignatureHashForkId(
-            spend_tx.vout[n].scriptPubKey, tx, 0, SIGHASH_ALL | SIGHASH_FORKID, spend_tx.vout[n].nValue)
-        tx.vin[0].scriptSig = CScript(
-            [self.coinbase_key.sign_ecdsa(sighash) + bytes(bytearray([SIGHASH_ALL | SIGHASH_FORKID]))])
-
-    def create_and_sign_transaction(
-            self, spend_tx, n, value, script=CScript([OP_TRUE])):
-        tx = self.create_tx(spend_tx, n, value, script)
-        self.sign_tx(tx, spend_tx, n)
-        tx.rehash()
-        return tx
-
-    def next_block(self, number, spend=None,
-                   additional_coinbase_value=0, script=CScript([OP_TRUE])):
-        if self.tip is None:
-            base_block_hash = self.genesis_hash
-            block_time = int(time.time()) + 1
-        else:
-            base_block_hash = self.tip.sha256
-            block_time = self.tip.nTime + 1
-        # First create the coinbase
-        height = self.block_heights[base_block_hash] + 1
-        coinbase = create_coinbase(height, self.coinbase_pubkey)
-        coinbase.vout[0].nValue += additional_coinbase_value
-        coinbase.rehash()
-        if spend is None:
-            block = create_block(base_block_hash, coinbase, block_time)
-        else:
-            # all but one satoshi to fees
-            coinbase.vout[0].nValue += spend.tx.vout[
-                spend.n].nValue - 1
-            coinbase.rehash()
-            block = create_block(base_block_hash, coinbase, block_time)
-            # spend 1 satoshi
-            tx = create_tx_with_script(spend.tx, spend.n, b"", 1, script)
-            self.sign_tx(tx, spend.tx, spend.n)
-            self.add_transactions_to_block(block, [tx])
-            block.hashMerkleRoot = block.calc_merkle_root()
-        # Do PoW, which is very inexpensive on regnet
-        block.solve()
-        self.tip = block
-        self.block_heights[block.sha256] = height
-        assert number not in self.blocks
-        self.blocks[number] = block
-        return block
-
-    def run_test(self):
-        node = self.nodes[0]
-        node.add_p2p_connection(P2PDataStore())
-
-        self.genesis_hash = int(self.nodes[0].getbestblockhash(), 16)
-        self.block_heights[self.genesis_hash] = 0
-        spendable_outputs = []
-
-        # save the current tip so it can be spent by a later block
-        def save_spendable_output():
-            spendable_outputs.append(self.tip)
-
-        # get an output that we previously marked as spendable
-        def get_spendable_output():
-            return PreviousSpendableOutput(spendable_outputs.pop(0).vtx[0], 0)
-
-        # move the tip back to a previous block
-        def tip(number):
-            self.tip = self.blocks[number]
-
-        # adds transactions to the block and updates state
-        def update_block(block_number, new_transactions):
-            block = self.blocks[block_number]
-            self.add_transactions_to_block(block, new_transactions)
-            old_sha256 = block.sha256
-            block.hashMerkleRoot = block.calc_merkle_root()
-            block.solve()
-            # Update the internal state just like in next_block
-            self.tip = block
-            if block.sha256 != old_sha256:
-                self.block_heights[
-                    block.sha256] = self.block_heights[old_sha256]
-                del self.block_heights[old_sha256]
-            self.blocks[block_number] = block
-            return block
-
-        # shorthand for functions
-        block = self.next_block
-
-        # Create a new block
-        block(0)
-        save_spendable_output()
-        node.p2p.send_blocks_and_test([self.tip], node)
-
-        # Now we need that block to mature so we can spend the coinbase.
-        maturity_blocks = []
-        for i in range(99):
-            block(5000 + i)
-            maturity_blocks.append(self.tip)
-            save_spendable_output()
-        node.p2p.send_blocks_and_test(maturity_blocks, node)
-
-        # Collect spendable outputs now to avoid cluttering the code later on
-        out = []
-        for i in range(33):
-            out.append(get_spendable_output())
-
-        # P2SH
-        # Build the redeem script, hash it, use hash to create the p2sh script
-        # Pad with extra bytes to make sure that the scriptsig length will be
-        # >= 198 after signature is added, even if it's a schnorr sig; this
-        # ensures a not-too-high density of sigchecks.
-        redeem_script = CScript([b'X' * 51, OP_DROP, self.coinbase_pubkey] + [
-                                OP_2DUP, OP_CHECKSIGVERIFY] * 5 + [OP_CHECKSIG])
-        # should be this length since coinbase_pubkey is uncompressed.
-        assert_equal(len(redeem_script), 130)
-        redeem_script_hash = hash160(redeem_script)
-        p2sh_script = CScript([OP_HASH160, redeem_script_hash, OP_EQUAL])
-
-        # Creates a new transaction using a p2sh transaction as input
-        def spend_p2sh_tx(p2sh_tx_to_spend, output_script=CScript([OP_TRUE])):
-            # Create the transaction
-            spent_p2sh_tx = CTransaction()
-            spent_p2sh_tx.vin.append(
-                CTxIn(COutPoint(p2sh_tx_to_spend.sha256, 0), b''))
-            spent_p2sh_tx.vout.append(CTxOut(1000, output_script))
-            # Sign the transaction using the redeem script
-            sighash = SignatureHashForkId(
-                redeem_script, spent_p2sh_tx, 0, SIGHASH_ALL | SIGHASH_FORKID, p2sh_tx_to_spend.vout[0].nValue)
-            sig = self.coinbase_key.sign_ecdsa(
-                sighash) + bytes(bytearray([SIGHASH_ALL | SIGHASH_FORKID]))
-            spent_p2sh_tx.vin[0].scriptSig = CScript([sig, redeem_script])
-            assert len(
-                spent_p2sh_tx.vin[0].scriptSig) >= 198, "needs to pass input sigchecks limit"
-            spent_p2sh_tx.rehash()
-            return spent_p2sh_tx
-
-        # P2SH tests
-        # Create a p2sh transaction
-        p2sh_tx = self.create_and_sign_transaction(
-            out[0].tx, out[0].n, 10000, p2sh_script)
-
-        # Add the transaction to the block
-        block(1)
-        update_block(1, [p2sh_tx])
-        node.p2p.send_blocks_and_test([self.tip], node)
-
-        # Sigops p2sh limit for the mempool test
-        p2sh_sigops_limit_mempool = MAX_STANDARD_TX_SIGOPS - \
-            redeem_script.GetSigOpCount(True)
-        # Too many sigops in one p2sh script
-        too_many_p2sh_sigops_mempool = CScript(
-            [OP_CHECKSIG] * (p2sh_sigops_limit_mempool + 1))
-
-        # A transaction with this output script can't get into the mempool
-        assert_raises_rpc_error(-26, RPC_TXNS_TOO_MANY_SIGOPS_ERROR, node.sendrawtransaction,
-                                ToHex(spend_p2sh_tx(p2sh_tx, too_many_p2sh_sigops_mempool)))
-
-        # The transaction is rejected, so the mempool should still be empty
-        assert_equal(set(node.getrawmempool()), set())
-
-        # Max sigops in one p2sh txn
-        max_p2sh_sigops_mempool = CScript(
-            [OP_CHECKSIG] * (p2sh_sigops_limit_mempool))
-
-        # A transaction with this output script can get into the mempool
-        max_p2sh_sigops_txn = spend_p2sh_tx(p2sh_tx, max_p2sh_sigops_mempool)
-        max_p2sh_sigops_txn_id = node.sendrawtransaction(
-            ToHex(max_p2sh_sigops_txn))
-        assert_equal(set(node.getrawmempool()), {max_p2sh_sigops_txn_id})
-
-        # Mine the transaction
-        block(2, spend=out[1])
-        update_block(2, [max_p2sh_sigops_txn])
-        node.p2p.send_blocks_and_test([self.tip], node)
-
-        # The transaction has been mined, it's not in the mempool anymore
-        assert_equal(set(node.getrawmempool()), set())
-
-
-if __name__ == '__main__':
-    FullBlockTest().main()
diff --git a/test/functional/abc-sigops-deactivation.py b/test/functional/abc-sigops-deactivation.py
deleted file mode 100755
--- a/test/functional/abc-sigops-deactivation.py
+++ /dev/null
@@ -1,359 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2020 The Bitcoin Developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-"""
-Test deactivation of sigops counting
-
-based on abc-schnorrmultisig-activation.py (D3736).
-"""
-
-from test_framework.blocktools import (
-    create_block,
-    create_coinbase,
-    make_conform_to_ctor,
-)
-from test_framework.cdefs import (
-    ONE_MEGABYTE,
-)
-from test_framework.messages import (
-    CBlock,
-    COutPoint,
-    CTransaction,
-    CTxIn,
-    CTxOut,
-    FromHex,
-    ToHex,
-)
-from test_framework.mininode import (
-    P2PDataStore,
-)
-from test_framework.script import (
-    CScript,
-    hash160,
-    OP_CHECKMULTISIG,
-    OP_CHECKDATASIG,
-    OP_ENDIF,
-    OP_EQUAL,
-    OP_FALSE,
-    OP_HASH160,
-    OP_IF,
-    OP_RETURN,
-    OP_TRUE,
-)
-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.txtools import pad_tx
-from test_framework.util import (
-    assert_equal,
-    assert_raises_rpc_error,
-    sync_blocks,
-)
-from decimal import Decimal
-from collections import deque
-
-SATOSHI = Decimal('0.00000001')
-
-# Set test to run with sigops deactivation far in the future.
-SIGOPS_DEACTIVATION_TIME = 2000000000
-
-# If we don't do this, autoreplay protection will activate before graviton and
-# all our sigs will mysteriously fail.
-REPLAY_PROTECTION_START_TIME = SIGOPS_DEACTIVATION_TIME * 2
-
-# Transactions for mempool with too many sigops give this error:
-MEMPOOL_TXSIGOPS_ERROR = 'bad-txns-too-many-sigops'
-MEMPOOL_P2SH_SIGOPS_ERROR = 'bad-txns-nonstandard-inputs'
-# Blocks that have single txes with too many sigops give this error:
-BLOCK_TXSIGOPS_ERROR = 'bad-txn-sigops'
-# Blocks with too many sigops give this error:
-BLOCK_TOTALSIGOPS_ERROR = 'bad-blk-sigops'
-
-
-def create_transaction(spendfrom, custom_script, amount=None):
-    # Fund and sign a transaction to a given output.
-    # spendfrom should be a CTransaction with first output to OP_TRUE.
-
-    # custom output will go on position 1, after position 0 which will be
-    # OP_TRUE (so it can be reused).
-    customout = CTxOut(0, bytes(custom_script))
-    # set output amount to required dust if not given
-    customout.nValue = amount or (len(customout.serialize()) + 148) * 3
-
-    ctx = CTransaction()
-    ctx.vin.append(CTxIn(COutPoint(spendfrom.sha256, 0), b''))
-    ctx.vout.append(
-        CTxOut(0, bytes([OP_TRUE])))
-    ctx.vout.append(customout)
-    pad_tx(ctx)
-
-    fee = len(ctx.serialize())
-    ctx.vout[0].nValue = spendfrom.vout[0].nValue - customout.nValue - fee
-    ctx.rehash()
-
-    return ctx
-
-
-def check_for_ban_on_rejected_tx(node, tx, reject_reason=None):
-    """Check we are disconnected when sending a txn that the node rejects,
-    then reconnect after.
-
-    (Can't actually get banned, since bitcoind won't ban local peers.)"""
-    node.p2p.send_txs_and_test(
-        [tx], node, success=False, expect_disconnect=True, reject_reason=reject_reason)
-    node.disconnect_p2ps()
-    node.add_p2p_connection(P2PDataStore())
-
-
-def check_for_ban_on_rejected_block(node, block, reject_reason=None):
-    """Check we are disconnected when sending a block that the node rejects,
-    then reconnect after.
-
-    (Can't actually get banned, since bitcoind won't ban local peers.)"""
-    node.p2p.send_blocks_and_test(
-        [block], node, success=False, reject_reason=reject_reason, expect_disconnect=True)
-    node.disconnect_p2ps()
-    node.add_p2p_connection(P2PDataStore())
-
-
-def check_for_no_ban_on_rejected_tx(node, tx, reject_reason=None):
-    """Check we are not disconnected when sending a txn that the node rejects."""
-    node.p2p.send_txs_and_test(
-        [tx], node, success=False, reject_reason=reject_reason)
-
-
-class SigopsDeactivationTest(BitcoinTestFramework):
-
-    def set_test_params(self):
-        self.setup_clean_chain = True
-        self.num_nodes = 2
-        self.block_heights = {}
-        timeargs = ["-phononactivationtime={}".format(
-            SIGOPS_DEACTIVATION_TIME),
-            "-replayprotectionactivationtime={}".format(
-            REPLAY_PROTECTION_START_TIME)]
-        # many standardness rules are actually enforced on regtest, except for
-        # P2SH sigops.
-        self.extra_args = [timeargs + ['-acceptnonstdtxn=1'], timeargs]
-
-    def getbestblock(self, node):
-        """Get the best block. Register its height so we can use build_block."""
-        block_height = node.getblockcount()
-        blockhash = node.getblockhash(block_height)
-        block = FromHex(CBlock(), node.getblock(blockhash, 0))
-        block.calc_sha256()
-        self.block_heights[block.sha256] = block_height
-        return block
-
-    def build_block(self, parent, transactions=(),
-                    nTime=None, cbextrascript=None):
-        """Make a new block with an OP_1 coinbase output.
-
-        Requires parent to have its height registered."""
-        parent.calc_sha256()
-        block_height = self.block_heights[parent.sha256] + 1
-        block_time = (parent.nTime + 1) if nTime is None else nTime
-
-        block = create_block(
-            parent.sha256, create_coinbase(block_height), block_time)
-        if cbextrascript is not None:
-            block.vtx[0].vout.append(CTxOut(0, cbextrascript))
-            block.vtx[0].rehash()
-        block.vtx.extend(transactions)
-        make_conform_to_ctor(block)
-        block.hashMerkleRoot = block.calc_merkle_root()
-        block.solve()
-        self.block_heights[block.sha256] = block_height
-        return block
-
-    def run_test(self):
-        (node, std_node) = self.nodes
-        node.add_p2p_connection(P2PDataStore())
-        std_node.add_p2p_connection(P2PDataStore())
-        # Get out of IBD
-        node.generatetoaddress(1, node.get_deterministic_priv_key().address)
-
-        tip = self.getbestblock(node)
-
-        self.log.info("Create some blocks with OP_1 coinbase for spending.")
-        blocks = []
-        for _ in range(20):
-            tip = self.build_block(tip)
-            blocks.append(tip)
-        node.p2p.send_blocks_and_test(blocks, node, success=True)
-        self.spendable_outputs = deque(block.vtx[0] for block in blocks)
-
-        self.log.info("Mature the blocks.")
-        node.generatetoaddress(100, node.get_deterministic_priv_key().address)
-
-        tip = self.getbestblock(node)
-
-        self.log.info("Generating some high-sigop transactions.")
-
-        # Tx with 4001 sigops (valid but non standard)
-        tx_4001 = create_transaction(self.spendable_outputs.popleft(), [
-                                     OP_CHECKMULTISIG] * 200 + [OP_CHECKDATASIG])
-
-        # Tx with 20001 sigops (consensus-invalid)
-        tx_20001 = create_transaction(self.spendable_outputs.popleft(), [
-                                      OP_CHECKMULTISIG] * 1000 + [OP_CHECKDATASIG])
-
-        # P2SH tx with too many sigops (valid but nonstandard for std_node)
-        redeem_script = bytes(
-            [OP_IF, OP_CHECKMULTISIG, OP_ENDIF, OP_TRUE])
-        p2sh_script = CScript([OP_HASH160, hash160(redeem_script), OP_EQUAL])
-        tx_fundp2sh = create_transaction(
-            self.spendable_outputs.popleft(), p2sh_script)
-        tx_spendp2sh = CTransaction()
-        tx_spendp2sh.vin.append(
-            CTxIn(COutPoint(tx_fundp2sh.sha256, 1), CScript([OP_FALSE, redeem_script])))
-        tx_spendp2sh.vout.append(
-            CTxOut(0, CScript([OP_RETURN, b'pad' * 20])))
-        tx_spendp2sh.rehash()
-
-        # Chain of 10 txes with 2000 sigops each.
-        txes_10x2000_sigops = []
-        tx = self.spendable_outputs.popleft()
-        for _ in range(10):
-            tx = create_transaction(tx, [OP_CHECKMULTISIG] * 100)
-            txes_10x2000_sigops.append(tx)
-
-        def make_hightotalsigop_block():
-            # 20001 total sigops
-            return self.build_block(
-                tip, txes_10x2000_sigops, cbextrascript=bytes([OP_CHECKDATASIG]))
-
-        def make_highsigop_coinbase_block():
-            # 60000 sigops in the coinbase
-            return self.build_block(
-                tip, cbextrascript=bytes([OP_CHECKMULTISIG] * 3000))
-
-        self.log.info(
-            "Try various high-sigop transactions in blocks / mempool before upgrade")
-
-        # mempool refuses over 4001.
-        check_for_no_ban_on_rejected_tx(node, tx_4001, MEMPOOL_TXSIGOPS_ERROR)
-        # it used to be that exceeding 20000 would cause a ban, but it's
-        # important that this causes no ban: we want that upgraded nodes
-        # can't get themselves banned by relaying huge-sigops transactions.
-        check_for_no_ban_on_rejected_tx(node, tx_20001, MEMPOOL_TXSIGOPS_ERROR)
-
-        # the 20001 tx can't be mined
-        check_for_ban_on_rejected_block(node, self.build_block(
-            tip, [tx_20001]), BLOCK_TXSIGOPS_ERROR)
-
-        self.log.info(
-            "The P2SH script has too many sigops (20 > 15) for a standard node.")
-        # Mine the P2SH funding first because it's nonstandard.
-        tip = self.build_block(tip, [tx_fundp2sh])
-        std_node.p2p.send_blocks_and_test([tip], node)
-        assert_raises_rpc_error(-26, MEMPOOL_P2SH_SIGOPS_ERROR,
-                                std_node.sendrawtransaction, ToHex(tx_spendp2sh))
-
-        self.log.info(
-            "A bunch of 2000-sigops txes can be put in mempool but not mined all at once.")
-        # Send the 2000-sigop transactions, which are acceptable.
-        for tx in txes_10x2000_sigops:
-            node.sendrawtransaction(ToHex(tx))
-
-        # They can't be mined all at once if the coinbase has a single sigop
-        # (total 20001)
-        check_for_ban_on_rejected_block(
-            node, make_hightotalsigop_block(), BLOCK_TOTALSIGOPS_ERROR)
-
-        # Activation tests
-
-        self.log.info("Approach to just before upgrade activation")
-        # Move our clock to the uprade time so we will accept such
-        # future-timestamped blocks.
-        node.setmocktime(SIGOPS_DEACTIVATION_TIME)
-        std_node.setmocktime(SIGOPS_DEACTIVATION_TIME)
-        # Mine six blocks with timestamp starting at SIGOPS_DEACTIVATION_TIME-1
-        blocks = []
-        for i in range(-1, 5):
-            tip = self.build_block(tip, nTime=SIGOPS_DEACTIVATION_TIME + i)
-            blocks.append(tip)
-        node.p2p.send_blocks_and_test(blocks, node)
-        assert_equal(node.getblockchaininfo()[
-                     'mediantime'], SIGOPS_DEACTIVATION_TIME - 1)
-
-        self.log.info(
-            "The next block will activate, but the activation block itself must follow old rules")
-
-        check_for_ban_on_rejected_block(node, self.build_block(
-            tip, [tx_20001]), BLOCK_TXSIGOPS_ERROR)
-        check_for_ban_on_rejected_block(
-            node, make_hightotalsigop_block(), BLOCK_TOTALSIGOPS_ERROR)
-        check_for_ban_on_rejected_block(
-            node, make_highsigop_coinbase_block(), BLOCK_TXSIGOPS_ERROR)
-
-        self.log.info("Mine the activation block itself")
-        tip = self.build_block(tip)
-        node.p2p.send_blocks_and_test([tip], node)
-        sync_blocks(self.nodes)
-
-        self.log.info("We have activated!")
-        assert_equal(node.getblockchaininfo()[
-                     'mediantime'], SIGOPS_DEACTIVATION_TIME)
-        assert_equal(std_node.getblockchaininfo()[
-                     'mediantime'], SIGOPS_DEACTIVATION_TIME)
-
-        # save this tip for later
-        upgrade_block = tip
-
-        self.log.info(
-            "The mempool is now a free-for-all, and we can get all the high-sigops transactions in")
-        std_node.sendrawtransaction(ToHex(tx_spendp2sh))
-        node.sendrawtransaction(ToHex(tx_spendp2sh))
-        node.sendrawtransaction(ToHex(tx_4001))
-        node.sendrawtransaction(ToHex(tx_20001))
-        # resend the 2000-sigop transactions, which will have expired due to
-        # setmocktime.
-        for tx in txes_10x2000_sigops:
-            node.sendrawtransaction(ToHex(tx))
-
-        alltxes = set(tx.hash for tx in [
-                      tx_spendp2sh, tx_4001, tx_20001] + txes_10x2000_sigops)
-        assert_equal(set(node.getrawmempool()), alltxes)
-
-        self.log.info(
-            "The miner will include all the high-sigops transactions at once, without issue.")
-        node.generatetoaddress(1, node.get_deterministic_priv_key().address)
-        tip = self.getbestblock(node)
-        assert_equal(set(tx.rehash() for tx in tip.vtx[1:]), alltxes)
-        # even though it is far smaller than one megabyte, we got in something
-        # like 44000 sigops
-        assert len(tip.serialize()) < ONE_MEGABYTE
-
-        # save this tip for later
-        postupgrade_block = tip
-
-        # Deactivation tests
-
-        self.log.info(
-            "Invalidating the post-upgrade block returns the transactions to mempool")
-        node.invalidateblock(postupgrade_block.hash)
-        assert_equal(set(node.getrawmempool()), alltxes)
-
-        self.log.info("Test some weird alternative blocks")
-        tip = upgrade_block
-        self.log.info("A 40000-sigop coinbase is acceptable now")
-        tip = make_highsigop_coinbase_block()
-        node.p2p.send_blocks_and_test([tip], node)
-        self.log.info("We can get in our 20001 sigop total block")
-        tip = make_hightotalsigop_block()
-        node.p2p.send_blocks_and_test([tip], node)
-
-        self.log.info(
-            "Invalidating the upgrade block evicts the bad txes")
-        goodtxes = alltxes - {tx_4001.hash, tx_20001.hash}
-        # loose-rules node just evicts the too-many-sigops transactions
-        node.invalidateblock(upgrade_block.hash)
-        assert_equal(set(node.getrawmempool()), goodtxes)
-        # std_node evicts everything as either nonstandard scriptpubkey or p2sh
-        # too-many-sigops.
-        std_node.invalidateblock(upgrade_block.hash)
-        assert_equal(std_node.getrawmempool(), [])
-
-
-if __name__ == '__main__':
-    SigopsDeactivationTest().main()
diff --git a/test/functional/abc-sigops-mempool-mining.py b/test/functional/abc-sigops-mempool-mining.py
deleted file mode 100755
--- a/test/functional/abc-sigops-mempool-mining.py
+++ /dev/null
@@ -1,330 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2014-2019 The Bitcoin Core developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-"""
-Test mempool and mining priorities using high-sigops transactions, probing
-how the virtualsize mechanism behaves.
-
-This test assumes:
- -bytespersigop default is 50
- -blockmintxfee default is 1000
- -minrelaytxfee default is 1000
- -MEMPOOL_FULL_FEE_INCREMENT is 1000
-
-based on mempool_limit.py
-"""
-
-from test_framework.blocktools import (
-    create_block,
-    create_coinbase,
-    make_conform_to_ctor,
-)
-from test_framework.messages import (
-    CBlock,
-    COutPoint,
-    CTransaction,
-    CTxIn,
-    CTxOut,
-    FromHex,
-    ToHex,
-)
-from test_framework.mininode import (
-    P2PDataStore,
-)
-from test_framework.script import (
-    OP_CHECKMULTISIG,
-    OP_RETURN,
-    OP_TRUE,
-)
-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import (
-    assert_equal,
-    assert_raises_rpc_error,
-    JSONRPCException
-)
-
-from decimal import Decimal
-from collections import deque
-
-SATOSHI = Decimal('0.00000001')
-
-# Set test to run with sigops deactivation far in the future.
-SIGOPS_DEACTIVATION_TIME = 2000000000
-
-
-def create_var_transaction(spendfrom, custom_script, size_bytes, fee_sats):
-    # Fund and sign a transaction to a given output, padding it to exactly
-    # size = size_bytes and providing the given fee.
-    # spendfrom should be a CTransaction with first output to OP_TRUE.
-
-    customout = CTxOut(0, custom_script)
-    # set output amount to required dust
-    customout.nValue = (len(customout.serialize()) + 148) * 3
-
-    ctx = CTransaction()
-    ctx.vin.append(CTxIn(COutPoint(spendfrom.sha256, 0), b''))
-    ctx.vout.append(
-        CTxOut(spendfrom.vout[0].nValue - customout.nValue - fee_sats, bytes([OP_TRUE])))
-    ctx.vout.append(customout)
-    # two padding outputs
-    ctx.vout.append(CTxOut(0, b''))
-    ctx.vout.append(CTxOut(0, b''))
-
-    size_without_padding = len(ctx.serialize())
-    padding_needed = size_bytes - size_without_padding
-    assert padding_needed >= 0, (size_bytes, size_without_padding)
-
-    # Now insert padding. We need to be careful due to the flexible
-    # var_int size.
-    if padding_needed > 0xFFFF + 4:
-        # We can fit all padding in one script.
-        # 4 extra bytes will be used for var_int
-        ctx.vout[2].scriptPubKey = bytes(
-            [OP_RETURN]) * (padding_needed - 4)
-        padding_needed = 0
-    elif padding_needed >= 0xFD + 2:
-        # We can pad most (probably all) using a script that is between
-        # 253 and 65535 in length. Probably fit everything in one script.
-        # 2 extra bytes will be used for var_int
-        scriptsize = min(padding_needed - 2, 0xFFFF)
-        ctx.vout[2].scriptPubKey = bytes([OP_RETURN]) * scriptsize
-        padding_needed -= scriptsize + 2
-    elif padding_needed >= 0xFD:
-        # 0xFD or 0xFD+1. We can't pad with just one script, so just
-        # take off some.
-        ctx.vout[2].scriptPubKey = bytes([OP_RETURN]) * 50
-        padding_needed -= 50
-
-    # extra padding on another output is needed if original padding_needed
-    # was <= 0xfd+1, or was 0xffff+3 or 0xffff+4 .
-    assert padding_needed < 0xfd
-    ctx.vout[3].scriptPubKey = bytes([OP_RETURN]) * padding_needed
-
-    ctx.calc_sha256()
-    assert_equal(len(ctx.serialize()), size_bytes)
-    return ctx
-
-
-class MempoolLimitSigopsTest(BitcoinTestFramework):
-
-    def set_test_params(self):
-        self.setup_clean_chain = True
-        self.num_nodes = 1
-        self.extra_args = [
-            ["-maxmempool=5", '-phononactivationtime={}'.format(SIGOPS_DEACTIVATION_TIME),
-                "-acceptnonstdtxn=1"]]
-        self.block_heights = {}
-
-    def skip_test_if_missing_module(self):
-        self.skip_if_no_wallet()
-
-    def getbestblock(self, node):
-        """Get the best block. Register its height so we can use build_block."""
-        block_height = node.getblockcount()
-        blockhash = node.getblockhash(block_height)
-        block = FromHex(CBlock(), node.getblock(blockhash, 0))
-        block.calc_sha256()
-        self.block_heights[block.sha256] = block_height
-        return block
-
-    def build_block(self, parent, transactions=(), nTime=None):
-        """Make a new block with an OP_1 coinbase output.
-
-        Requires parent to have its height registered."""
-        parent.calc_sha256()
-        block_height = self.block_heights[parent.sha256] + 1
-        block_time = (parent.nTime + 1) if nTime is None else nTime
-
-        block = create_block(
-            parent.sha256, create_coinbase(block_height), block_time)
-        block.nVersion = 4
-        block.vtx.extend(transactions)
-        make_conform_to_ctor(block)
-        block.hashMerkleRoot = block.calc_merkle_root()
-        block.solve()
-        self.block_heights[block.sha256] = block_height
-        return block
-
-    def run_test(self):
-        (node,) = self.nodes
-        node.add_p2p_connection(P2PDataStore())
-
-        tip = self.getbestblock(node)
-
-        self.log.info("Create some blocks with OP_1 coinbase for spending.")
-        blocks = []
-        for _ in range(600):
-            tip = self.build_block(tip)
-            blocks.append(tip)
-        node.p2p.send_blocks_and_test(blocks, node, success=True)
-        self.spendable_outputs = deque(block.vtx[0] for block in blocks)
-
-        self.log.info(
-            "Mature the blocks and get out of IBD; also make some coinbases for the node wallet.")
-        node.generate(120)
-
-        tip = self.getbestblock(node)
-
-        self.log.info(
-            'PART 1: testing of priority under congestion (mempool eviction priority and mining priority).')
-
-        self.log.info(
-            "Put a regular transaction in mempool at 1 sat/byte.")
-        txid1 = node.sendtoaddress(node.getnewaddress(), 0.001)
-
-        self.log.info(
-            "Mempool accepts 1 sat/byte txes even with very many sigops")
-        script_4000_sigops = bytes([OP_CHECKMULTISIG] * 200)
-        # vsize = 200000, so 0.0015 sat/vbyte.
-        ctx = create_var_transaction(
-            self.spendable_outputs.popleft(), script_4000_sigops, 300, 300)
-        txid_parent = node.sendrawtransaction(ToHex(ctx))
-
-        self.log.info(
-            "Create a 1 sat/byte compensating child of a high-sigop parent")
-        # package vsize = 200000, so 0.5015 sat/vbyte.
-        ctx_child = create_var_transaction(
-            ctx, b'', 100000, 100000)
-        txid_child = node.sendrawtransaction(ToHex(ctx_child))
-
-        # make one with 270 sat/byte, but only 0.4 sat/vbyte.
-        ctx = create_var_transaction(
-            self.spendable_outputs.popleft(), script_4000_sigops, 300, 80000)
-        txid_highsigops = node.sendrawtransaction(ToHex(ctx))
-
-        self.log.info(
-            "Flood the mempool with 10-kB transactions @ 9.9 sat/byte and 0.495 sat/vbyte, until it is full")
-        # About 500 should fill up our 5 MB mempool.
-        # Note that even starting from an empty pool, somewhat fewer than 500
-        # would be accepted depending on mempool data structure sizes.
-        for i in range(500):
-            spendfrom = self.spendable_outputs.popleft()
-            ctx = create_var_transaction(
-                spendfrom, script_4000_sigops, 10000, 99000)
-            try:
-                node.sendrawtransaction(ToHex(ctx))
-            except JSONRPCException as e:
-                if 'mempool full' in e.error['message'] or 'mempool min fee not met' in e.error['message']:
-                    self.log.info(
-                        "Mempool filled after {} transactions".format(i,))
-                    break
-                raise
-        else:
-            raise RuntimeError("didn't fill mempool")
-
-        self.log.info(
-            'The flooding only caused eviction of lower low sat/vbyte packages')
-
-        mempool_txids = set(node.getrawmempool())
-
-        # The 9.9 sat/byte txes caused the 270 sat/byte tx to get evicted, because
-        # the latter was more dense in sigops.
-        assert txid_highsigops not in mempool_txids
-
-        # Other txes did get kept, including txid_parent which had ultralow
-        # virtual feerate (but its child supplied enough fee).
-        settxids = set([txid1, txid_parent, txid_child])
-        assert_equal(settxids.difference(mempool_txids), set())
-
-        self.log.info('Mempool fee floor has jumped to 1.495 sat/vbyte')
-        # The removed txes have feerate 495 sat/kvbyte and the fee floor jumps by
-        # 1000 sat/kbyte (MEMPOOL_FULL_FEE_INCREMENT) on top of that:
-        assert_equal(node.getmempoolinfo()[
-                     'mempoolminfee'], Decimal('0.00001495'))
-
-        self.log.info(
-            'Broadcasting a regular tx still works, because wallet knows what fee to use.')
-        txid2 = node.sendtoaddress(node.getnewaddress(), 0.001)
-        settxids.add(txid2)
-
-        self.log.info(
-            "But, a regular 1 sat/byte transaction can't get in now.")
-        spendfrom = self.spendable_outputs.popleft()
-        assert_raises_rpc_error(-26, "mempool min fee not met", node.sendrawtransaction,
-                                ToHex(create_var_transaction(spendfrom, b'', 500, 500)))
-
-        self.log.info(
-            "Broadcasting regular transactions will push out the high-sigops txns.")
-        # We can broadcast a bunch of regular txes. They need to pay a bit more
-        # fee (1.5 sat/vbyte) than the floor.
-        for i in range(15):
-            spendfrom = self.spendable_outputs.popleft()
-            ctx = create_var_transaction(spendfrom, b'', 100000, 150000)
-            settxids.add(node.sendrawtransaction(ToHex(ctx)))
-
-        self.log.info("Mining picks all the 'good' txes first")
-        # These slightly higher-fee transactions also have more priority.
-        [lastblockhash, ] = node.generate(1)
-        blocktxes = set(node.getblock(lastblockhash, 1)['tx'])
-        assert_equal(settxids.difference(blocktxes), set())
-        # there are still hundreds of the flooded txes left in mempool.
-        assert len(node.getrawmempool()) > 200
-
-        self.log.info(
-            'PART 2: The following tests focus on mineability according to blockmintxfee.')
-
-        self.log.info('Clear the mempool by mining out everything.')
-        node.generate(100)
-        assert_equal(node.getrawmempool(), [])
-
-        self.log.info(
-            'Reset the mempool fee floor (currently, restarting the node achieves this).')
-        # could also be done by setting mocktime in future (the floor decays
-        # over a period of hours)
-        self.restart_node(0, self.extra_args[0])
-        (node,) = self.nodes
-        node.add_p2p_connection(P2PDataStore())
-        assert_equal(node.getmempoolinfo()[
-                     'mempoolminfee'], Decimal('0.00001000'))
-
-        self.log.info(
-            'Get a 0.998 sat/byte transaction into mempool by having it mined then reorged out.')
-        self.log.info(node.getbestblockhash())
-        tip = self.getbestblock(node)
-        self.log.info(tip.hash)
-        ctx = create_var_transaction(
-            self.spendable_outputs.popleft(), b'', 1000, 998)
-        stucktxid = ctx.hash
-        # check that indeed it can't get in normally:
-        assert_raises_rpc_error(-26, "min relay fee not met",
-                                node.sendrawtransaction, ToHex(ctx))
-        block = self.build_block(tip, [ctx])
-        node.p2p.send_blocks_and_test([block], node, success=True)
-        node.invalidateblock(block.hash)
-        assert stucktxid in node.getrawmempool(), "should be returned to pool"
-
-        self.log.info(
-            "Since blockmintxfee is 1 sat/byte, that 0.998 sat/byte tx won't get mined by default, and is stuck permanently.")
-        node.generate(1)
-        assert stucktxid in node.getrawmempool(), "should be stuck"
-
-        self.log.info(
-            'Get wallet to make an normal tx sending money to 12 people, which is just under 1 sat/vbyte.')
-        txid = node.sendmany(
-            "", {node.getnewaddress(): 0.01 for _ in range(12)})
-
-        # analyze the constructed tx just to make sure it's as expected
-        ctx = FromHex(CTransaction(), node.getrawtransaction(txid))
-        assert len(ctx.vin) == 1, "only a single input should be needed"
-        assert len(ctx.vout) == 13, "12 recipients and 1 change"
-        # tx size should be ~ 599 bytes and fees should be 599 sats.
-        # 13 sigops and 50 sigops / byte = 650 vbytes.
-        txsize = len(ctx.serialize())
-        txvsize = max(txsize, 50 * len(ctx.vout))
-        assert txvsize > txsize, "transactions is dense-sigops"
-        fee_sats = node.getmempoolentry(txid)['fee'] / SATOSHI
-        assert_equal(fee_sats, 599)
-        assert fee_sats / txsize >= 1.0, "just over 1 sat/byte"
-        assert fee_sats / txvsize < 0.95, "just under 1 sat/vbyte"
-
-        self.log.info(
-            "Even though another transaction is stuck permanently, it should not prevent a normal tx from being mined.")
-        [bhash, ] = node.generate(1)
-        blocktxes = set(node.getblock(bhash, 1)['tx'])
-        assert txid in blocktxes, "normal tx is not stuck"
-        assert stucktxid not in blocktxes, "lowfee tx is still stuck"
-
-
-if __name__ == '__main__':
-    MempoolLimitSigopsTest().main()
diff --git a/test/functional/abc_p2p_fullblocktest_sigops.py b/test/functional/abc_p2p_fullblocktest_sigops.py
deleted file mode 100755
--- a/test/functional/abc_p2p_fullblocktest_sigops.py
+++ /dev/null
@@ -1,419 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2015-2016 The Bitcoin Core developers
-# Copyright (c) 2017 The Bitcoin developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-"""
-This test checks simple acceptance of bigger blocks via p2p.
-It is derived from the much more complex p2p-fullblocktest.
-The intention is that small tests can be derived from this one, or
-this one can be extended, to cover the checks done for bigger blocks
-(e.g. sigops limits).
-"""
-
-from collections import deque
-import random
-import time
-
-from test_framework.blocktools import (
-    create_block,
-    create_coinbase,
-    create_tx_with_script,
-    make_conform_to_ctor,
-)
-from test_framework.cdefs import (
-    MAX_BLOCK_SIGOPS_PER_MB,
-    MAX_TX_SIGOPS_COUNT,
-    ONE_MEGABYTE,
-)
-from test_framework.key import ECKey
-from test_framework.messages import (
-    COutPoint,
-    CTransaction,
-    CTxIn,
-    CTxOut,
-    ser_compact_size,
-)
-from test_framework.mininode import P2PDataStore
-from test_framework.script import (
-    CScript,
-    hash160,
-    OP_2DUP,
-    OP_CHECKDATASIG,
-    OP_CHECKMULTISIG,
-    OP_CHECKSIG,
-    OP_CHECKSIGVERIFY,
-    OP_EQUAL,
-    OP_HASH160,
-    OP_RETURN,
-    OP_TRUE,
-    SIGHASH_ALL,
-    SIGHASH_FORKID,
-    SignatureHashForkId,
-)
-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import assert_equal
-
-# Set test to run with sigops deactivation far in the future.
-SIGOPS_DEACTIVATION_TIME = 2000000000
-
-
-class PreviousSpendableOutput():
-
-    def __init__(self, tx=CTransaction(), n=-1):
-        self.tx = tx
-        # the output we're spending
-        self.n = n
-
-
-class FullBlockTest(BitcoinTestFramework):
-
-    def set_test_params(self):
-        self.num_nodes = 1
-        self.setup_clean_chain = True
-        self.block_heights = {}
-        self.tip = None
-        self.blocks = {}
-        self.excessive_block_size = 100 * ONE_MEGABYTE
-        self.extra_args = [['-whitelist=127.0.0.1',
-                            "-excessiveblocksize={}".format(self.excessive_block_size), '-phononactivationtime={}'.format(SIGOPS_DEACTIVATION_TIME)]]
-
-    def add_options(self, parser):
-        super().add_options(parser)
-        parser.add_argument(
-            "--runbarelyexpensive", dest="runbarelyexpensive", default=True)
-
-    def add_transactions_to_block(self, block, tx_list):
-        [tx.rehash() for tx in tx_list]
-        block.vtx.extend(tx_list)
-
-    # this is a little handier to use than the version in blocktools.py
-    def create_tx(self, spend, value, script=CScript([OP_TRUE])):
-        tx = create_tx_with_script(spend.tx, spend.n, b"", value, script)
-        return tx
-
-    def next_block(self, number, spend=None, script=CScript(
-            [OP_TRUE]), block_size=0, extra_sigops=0):
-        if self.tip is None:
-            base_block_hash = self.genesis_hash
-            block_time = int(time.time()) + 1
-        else:
-            base_block_hash = self.tip.sha256
-            block_time = self.tip.nTime + 1
-        # First create the coinbase
-        height = self.block_heights[base_block_hash] + 1
-        coinbase = create_coinbase(height)
-        coinbase.rehash()
-        if spend is None:
-            # We need to have something to spend to fill the block.
-            assert_equal(block_size, 0)
-            block = create_block(base_block_hash, coinbase, block_time)
-        else:
-            # all but one satoshi to fees
-            coinbase.vout[0].nValue += spend.tx.vout[spend.n].nValue - 1
-            coinbase.rehash()
-            block = create_block(base_block_hash, coinbase, block_time)
-
-            # Make sure we have plenty engough to spend going forward.
-            spendable_outputs = deque([spend])
-
-            def get_base_transaction():
-                # Create the new transaction
-                tx = CTransaction()
-                # Spend from one of the spendable outputs
-                spend = spendable_outputs.popleft()
-                tx.vin.append(CTxIn(COutPoint(spend.tx.sha256, spend.n)))
-                # Add spendable outputs
-                for i in range(4):
-                    tx.vout.append(CTxOut(0, CScript([OP_TRUE])))
-                    spendable_outputs.append(PreviousSpendableOutput(tx, i))
-                return tx
-
-            tx = get_base_transaction()
-
-            # Make it the same format as transaction added for padding and save the size.
-            # It's missing the padding output, so we add a constant to account
-            # for it.
-            tx.rehash()
-            base_tx_size = len(tx.serialize()) + 18
-
-            # If a specific script is required, add it.
-            if script is not None:
-                tx.vout.append(CTxOut(1, script))
-
-            # Put some random data into the first transaction of the chain to
-            # randomize ids.
-            tx.vout.append(
-                CTxOut(0, CScript([random.randint(0, 256), OP_RETURN])))
-
-            # Add the transaction to the block
-            self.add_transactions_to_block(block, [tx])
-
-            # If we have a block size requirement, just fill
-            # the block until we get there
-            current_block_size = len(block.serialize())
-            while current_block_size < block_size:
-                # We will add a new transaction. That means the size of
-                # the field enumerating how many transaction go in the block
-                # may change.
-                current_block_size -= len(ser_compact_size(len(block.vtx)))
-                current_block_size += len(ser_compact_size(len(block.vtx) + 1))
-
-                # Create the new transaction
-                tx = get_base_transaction()
-
-                # Add padding to fill the block.
-                script_length = block_size - current_block_size - base_tx_size
-                if script_length > 510000:
-                    if script_length < 1000000:
-                        # Make sure we don't find ourselves in a position where we
-                        # need to generate a transaction smaller than what we
-                        # expected.
-                        script_length = script_length // 2
-                    else:
-                        script_length = 500000
-                tx_sigops = min(extra_sigops, script_length,
-                                MAX_TX_SIGOPS_COUNT)
-                extra_sigops -= tx_sigops
-                script_pad_len = script_length - tx_sigops
-                script_output = CScript(
-                    [b'\x00' * script_pad_len] + [OP_CHECKSIG] * tx_sigops)
-                tx.vout.append(CTxOut(0, script_output))
-
-                # Add the tx to the list of transactions to be included
-                # in the block.
-                self.add_transactions_to_block(block, [tx])
-                current_block_size += len(tx.serialize())
-
-            # Now that we added a bunch of transaction, we need to recompute
-            # the merkle root.
-            make_conform_to_ctor(block)
-            block.hashMerkleRoot = block.calc_merkle_root()
-
-        # Check that the block size is what's expected
-        if block_size > 0:
-            assert_equal(len(block.serialize()), block_size)
-
-        # Do PoW, which is cheap on regnet
-        block.solve()
-        self.tip = block
-        self.block_heights[block.sha256] = height
-        assert number not in self.blocks
-        self.blocks[number] = block
-        return block
-
-    def run_test(self):
-        node = self.nodes[0]
-        node.add_p2p_connection(P2PDataStore())
-
-        # Set the blocksize to 2MB as initial condition
-        node.setexcessiveblock(self.excessive_block_size)
-
-        self.genesis_hash = int(node.getbestblockhash(), 16)
-        self.block_heights[self.genesis_hash] = 0
-        spendable_outputs = []
-
-        # save the current tip so it can be spent by a later block
-        def save_spendable_output():
-            spendable_outputs.append(self.tip)
-
-        # get an output that we previously marked as spendable
-        def get_spendable_output():
-            return PreviousSpendableOutput(spendable_outputs.pop(0).vtx[0], 0)
-
-        # move the tip back to a previous block
-        def tip(number):
-            self.tip = self.blocks[number]
-
-        # adds transactions to the block and updates state
-        def update_block(block_number, new_transactions):
-            block = self.blocks[block_number]
-            self.add_transactions_to_block(block, new_transactions)
-            old_sha256 = block.sha256
-            make_conform_to_ctor(block)
-            block.hashMerkleRoot = block.calc_merkle_root()
-            block.solve()
-            # Update the internal state just like in next_block
-            self.tip = block
-            if block.sha256 != old_sha256:
-                self.block_heights[
-                    block.sha256] = self.block_heights[old_sha256]
-                del self.block_heights[old_sha256]
-            self.blocks[block_number] = block
-            return block
-
-        # shorthand for functions
-        block = self.next_block
-
-        # Create a new block
-        block(0)
-        save_spendable_output()
-        node.p2p.send_blocks_and_test([self.tip], node)
-
-        # Now we need that block to mature so we can spend the coinbase.
-        maturity_blocks = []
-        for i in range(105):
-            block(5000 + i)
-            maturity_blocks.append(self.tip)
-            save_spendable_output()
-        node.p2p.send_blocks_and_test(maturity_blocks, node)
-
-        # collect spendable outputs now to avoid cluttering the code later on
-        out = []
-        for i in range(100):
-            out.append(get_spendable_output())
-
-        # Accept many sigops
-        lots_of_checksigs = CScript(
-            [OP_CHECKSIG] * MAX_BLOCK_SIGOPS_PER_MB)
-        block(19, spend=out[0], script=lots_of_checksigs,
-              block_size=ONE_MEGABYTE)
-        node.p2p.send_blocks_and_test([self.tip], node)
-
-        block(20, spend=out[1], script=lots_of_checksigs,
-              block_size=ONE_MEGABYTE, extra_sigops=1)
-        node.p2p.send_blocks_and_test(
-            [self.tip], node, success=False, reject_reason='bad-blk-sigops')
-
-        # Rewind bad block
-        tip(19)
-
-        # Accept 40k sigops per block > 1MB and <= 2MB
-        block(21, spend=out[1], script=lots_of_checksigs,
-              extra_sigops=MAX_BLOCK_SIGOPS_PER_MB, block_size=ONE_MEGABYTE + 1)
-        node.p2p.send_blocks_and_test([self.tip], node)
-
-        # Accept 40k sigops per block > 1MB and <= 2MB
-        block(22, spend=out[2], script=lots_of_checksigs,
-              extra_sigops=MAX_BLOCK_SIGOPS_PER_MB, block_size=2 * ONE_MEGABYTE)
-        node.p2p.send_blocks_and_test([self.tip], node)
-
-        # Reject more than 40k sigops per block > 1MB and <= 2MB.
-        block(23, spend=out[3], script=lots_of_checksigs,
-              extra_sigops=MAX_BLOCK_SIGOPS_PER_MB + 1, block_size=ONE_MEGABYTE + 1)
-        node.p2p.send_blocks_and_test(
-            [self.tip], node, success=False, reject_reason='bad-blk-sigops')
-
-        # Rewind bad block
-        tip(22)
-
-        # Reject more than 40k sigops per block > 1MB and <= 2MB.
-        block(24, spend=out[3], script=lots_of_checksigs,
-              extra_sigops=MAX_BLOCK_SIGOPS_PER_MB + 1, block_size=2 * ONE_MEGABYTE)
-        node.p2p.send_blocks_and_test(
-            [self.tip], node, success=False, reject_reason='bad-blk-sigops')
-
-        # Rewind bad block
-        tip(22)
-
-        # Accept 60k sigops per block > 2MB and <= 3MB
-        block(25, spend=out[3], script=lots_of_checksigs, extra_sigops=2
-              * MAX_BLOCK_SIGOPS_PER_MB, block_size=2 * ONE_MEGABYTE + 1)
-        node.p2p.send_blocks_and_test([self.tip], node)
-
-        # Accept 60k sigops per block > 2MB and <= 3MB
-        block(26, spend=out[4], script=lots_of_checksigs,
-              extra_sigops=2 * MAX_BLOCK_SIGOPS_PER_MB, block_size=3 * ONE_MEGABYTE)
-        node.p2p.send_blocks_and_test([self.tip], node)
-
-        # Reject more than 40k sigops per block > 1MB and <= 2MB.
-        block(27, spend=out[5], script=lots_of_checksigs, extra_sigops=2
-              * MAX_BLOCK_SIGOPS_PER_MB + 1, block_size=2 * ONE_MEGABYTE + 1)
-        node.p2p.send_blocks_and_test(
-            [self.tip], node, success=False, reject_reason='bad-blk-sigops')
-
-        # Rewind bad block
-        tip(26)
-
-        # Reject more than 40k sigops per block > 1MB and <= 2MB.
-        block(28, spend=out[5], script=lots_of_checksigs, extra_sigops=2
-              * MAX_BLOCK_SIGOPS_PER_MB + 1, block_size=3 * ONE_MEGABYTE)
-        node.p2p.send_blocks_and_test(
-            [self.tip], node, success=False, reject_reason='bad-blk-sigops')
-
-        # Rewind bad block
-        tip(26)
-
-        # Too many sigops in one txn
-        too_many_tx_checksigs = CScript(
-            [OP_CHECKSIG] * (MAX_BLOCK_SIGOPS_PER_MB + 1))
-        block(
-            29, spend=out[6], script=too_many_tx_checksigs, block_size=ONE_MEGABYTE + 1)
-        node.p2p.send_blocks_and_test(
-            [self.tip], node, success=False, reject_reason='bad-txn-sigops')
-
-        # Rewind bad block
-        tip(26)
-
-        # Generate a key pair to test P2SH sigops count
-        private_key = ECKey()
-        private_key.generate()
-        public_key = private_key.get_pubkey().get_bytes()
-
-        # P2SH
-        # Build the redeem script, hash it, use hash to create the p2sh script
-        redeem_script = CScript(
-            [public_key] + [OP_2DUP, OP_CHECKSIGVERIFY] * 5 + [OP_CHECKSIG])
-        redeem_script_hash = hash160(redeem_script)
-        p2sh_script = CScript([OP_HASH160, redeem_script_hash, OP_EQUAL])
-
-        # Create a p2sh transaction
-        p2sh_tx = self.create_tx(out[6], 1, p2sh_script)
-
-        # Add the transaction to the block
-        block(30)
-        update_block(30, [p2sh_tx])
-        node.p2p.send_blocks_and_test([self.tip], node)
-
-        # Creates a new transaction using the p2sh transaction included in the
-        # last block
-        def spend_p2sh_tx(output_script=CScript([OP_TRUE])):
-            # Create the transaction
-            spent_p2sh_tx = CTransaction()
-            spent_p2sh_tx.vin.append(CTxIn(COutPoint(p2sh_tx.sha256, 0), b''))
-            spent_p2sh_tx.vout.append(CTxOut(1, output_script))
-            # Sign the transaction using the redeem script
-            sighash = SignatureHashForkId(
-                redeem_script, spent_p2sh_tx, 0, SIGHASH_ALL | SIGHASH_FORKID, p2sh_tx.vout[0].nValue)
-            sig = private_key.sign_ecdsa(sighash) + \
-                bytes(bytearray([SIGHASH_ALL | SIGHASH_FORKID]))
-            spent_p2sh_tx.vin[0].scriptSig = CScript([sig, redeem_script])
-            spent_p2sh_tx.rehash()
-            return spent_p2sh_tx
-
-        # Sigops p2sh limit
-        p2sh_sigops_limit = MAX_BLOCK_SIGOPS_PER_MB - \
-            redeem_script.GetSigOpCount(True)
-        # Too many sigops in one p2sh txn
-        too_many_p2sh_sigops = CScript([OP_CHECKSIG] * (p2sh_sigops_limit + 1))
-        block(31, spend=out[7], block_size=ONE_MEGABYTE + 1)
-        update_block(31, [spend_p2sh_tx(too_many_p2sh_sigops)])
-        node.p2p.send_blocks_and_test(
-            [self.tip], node, success=False, reject_reason='bad-txn-sigops')
-
-        # Rewind bad block
-        tip(30)
-
-        # Max sigops in one p2sh txn
-        max_p2sh_sigops = CScript([OP_CHECKSIG] * (p2sh_sigops_limit))
-        block(32, spend=out[8], block_size=ONE_MEGABYTE + 1)
-        update_block(32, [spend_p2sh_tx(max_p2sh_sigops)])
-        node.p2p.send_blocks_and_test([self.tip], node)
-
-        # Ensure that a coinbase with too many sigops is forbidden, even if it
-        # doesn't push the total block count over the limit.
-        b33 = block(33, spend=out[9], block_size=2 * ONE_MEGABYTE)
-        # 20001 sigops
-        b33.vtx[0].vout.append(
-            CTxOut(0, CScript([OP_CHECKMULTISIG] * 1000 + [OP_CHECKDATASIG])))
-        update_block(33, [])
-        node.p2p.send_blocks_and_test(
-            [b33], node, success=False, reject_reason='bad-txn-sigops')
-        # 20000 sigops
-        b33.vtx[0].vout[-1].scriptPubKey = CScript([OP_CHECKMULTISIG] * 1000)
-        update_block(33, [])
-        node.p2p.send_blocks_and_test([b33], node)
-
-
-if __name__ == '__main__':
-    FullBlockTest().main()
diff --git a/test/functional/feature_block_sigops.py b/test/functional/feature_block_sigops.py
deleted file mode 100755
--- a/test/functional/feature_block_sigops.py
+++ /dev/null
@@ -1,531 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2015-2017 The Bitcoin Core developers
-# Copyright (c) 2017 The Bitcoin developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-"""Test block processing of sigops.
-
-Split out from feature_block.py . This tests a variety of funky corner cases of
-sigops handling.
-"""
-import time
-
-from test_framework.blocktools import (
-    create_block,
-    create_coinbase,
-    create_tx_with_script,
-    get_legacy_sigopcount_block,
-    make_conform_to_ctor,
-)
-from test_framework.cdefs import LEGACY_MAX_BLOCK_SIZE, MAX_BLOCK_SIGOPS_PER_MB
-from test_framework.key import ECKey
-from test_framework.messages import (
-    COutPoint,
-    CTransaction,
-    CTxIn,
-    CTxOut,
-)
-from test_framework.mininode import P2PDataStore
-from test_framework.script import (
-    CScript,
-    hash160,
-    MAX_SCRIPT_ELEMENT_SIZE,
-    OP_2DUP,
-    OP_CHECKMULTISIG,
-    OP_CHECKMULTISIGVERIFY,
-    OP_CHECKSIG,
-    OP_CHECKSIGVERIFY,
-    OP_EQUAL,
-    OP_HASH160,
-    OP_TRUE,
-    SIGHASH_ALL,
-    SIGHASH_FORKID,
-    SignatureHashForkId,
-)
-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.txtools import pad_tx
-from test_framework.util import assert_equal
-
-# Set test to run with sigops deactivation far in the future.
-SIGOPS_DEACTIVATION_TIME = 2000000000
-
-
-class FullBlockSigOpsTest(BitcoinTestFramework):
-    def set_test_params(self):
-        self.num_nodes = 1
-        self.setup_clean_chain = True
-        self.extra_args = [['-noparkdeepreorg', '-maxreorgdepth=-1',
-                            '-phononactivationtime={}'.format(SIGOPS_DEACTIVATION_TIME)]]
-
-    def run_test(self):
-        self.bootstrap_p2p()  # Add one p2p connection to the node
-
-        self.block_heights = {}
-        self.coinbase_key = ECKey()
-        self.coinbase_key.generate()
-        self.coinbase_pubkey = self.coinbase_key.get_pubkey().get_bytes()
-        self.tip = None
-        self.blocks = {}
-        self.genesis_hash = int(self.nodes[0].getbestblockhash(), 16)
-        self.block_heights[self.genesis_hash] = 0
-        self.spendable_outputs = []
-
-        # Create a new block
-        b0 = self.next_block(0)
-        self.save_spendable_output()
-        self.sync_blocks([b0])
-
-        # Allow the block to mature
-        blocks = []
-        for i in range(129):
-            blocks.append(self.next_block(5000 + i))
-            self.save_spendable_output()
-        self.sync_blocks(blocks)
-
-        # collect spendable outputs now to avoid cluttering the code later on
-        out = []
-        for i in range(33):
-            out.append(self.get_spendable_output())
-
-        # Start by building a block on top.
-        #     setup -> b13 (0)
-        b13 = self.next_block(13, spend=out[0])
-        self.save_spendable_output()
-        self.sync_blocks([b13])
-
-        # Add a block with MAX_BLOCK_SIGOPS_PER_MB and one with one more sigop
-        #     setup -> b13 (0) -> b15 (5) -> b16 (6)
-        self.log.info("Accept a block with lots of checksigs")
-        lots_of_checksigs = CScript(
-            [OP_CHECKSIG] * (MAX_BLOCK_SIGOPS_PER_MB - 1))
-        self.move_tip(13)
-        b15 = self.next_block(15, spend=out[5], script=lots_of_checksigs)
-        self.save_spendable_output()
-        self.sync_blocks([b15], True)
-
-        self.log.info("Reject a block with too many checksigs")
-        too_many_checksigs = CScript([OP_CHECKSIG] * (MAX_BLOCK_SIGOPS_PER_MB))
-        b16 = self.next_block(16, spend=out[6], script=too_many_checksigs)
-        self.sync_blocks([b16], success=False,
-                         reject_reason='bad-blk-sigops', reconnect=True)
-
-        self.move_tip(15)
-
-        # ... skipped feature_block tests ...
-
-        # b31 - b35 - check sigops of OP_CHECKMULTISIG / OP_CHECKMULTISIGVERIFY / OP_CHECKSIGVERIFY
-        #
-        #      setup -> ... b15 (5)   ->  b31 (8) -> b33 (9) -> b35 (10)
-        #                                                                \-> b36 (11)
-        #                                                    \-> b34 (10)
-        #                                         \-> b32 (9)
-        #
-
-        # MULTISIG: each op code counts as 20 sigops.  To create the edge case,
-        # pack another 19 sigops at the end.
-        self.log.info(
-            "Accept a block with the max number of OP_CHECKMULTISIG sigops")
-        lots_of_multisigs = CScript(
-            [OP_CHECKMULTISIG] * ((MAX_BLOCK_SIGOPS_PER_MB - 1) // 20) + [OP_CHECKSIG] * 19)
-        b31 = self.next_block(31, spend=out[8], script=lots_of_multisigs)
-        assert_equal(get_legacy_sigopcount_block(b31), MAX_BLOCK_SIGOPS_PER_MB)
-        self.sync_blocks([b31], True)
-        self.save_spendable_output()
-
-        # this goes over the limit because the coinbase has one sigop
-        self.log.info("Reject a block with too many OP_CHECKMULTISIG sigops")
-        too_many_multisigs = CScript(
-            [OP_CHECKMULTISIG] * (MAX_BLOCK_SIGOPS_PER_MB // 20))
-        b32 = self.next_block(32, spend=out[9], script=too_many_multisigs)
-        assert_equal(get_legacy_sigopcount_block(
-            b32), MAX_BLOCK_SIGOPS_PER_MB + 1)
-        self.sync_blocks([b32], success=False,
-                         reject_reason='bad-blk-sigops', reconnect=True)
-
-        # CHECKMULTISIGVERIFY
-        self.log.info(
-            "Accept a block with the max number of OP_CHECKMULTISIGVERIFY sigops")
-        self.move_tip(31)
-        lots_of_multisigs = CScript(
-            [OP_CHECKMULTISIGVERIFY] * ((MAX_BLOCK_SIGOPS_PER_MB - 1) // 20) + [OP_CHECKSIG] * 19)
-        b33 = self.next_block(33, spend=out[9], script=lots_of_multisigs)
-        self.sync_blocks([b33], True)
-        self.save_spendable_output()
-
-        self.log.info(
-            "Reject a block with too many OP_CHECKMULTISIGVERIFY sigops")
-        too_many_multisigs = CScript(
-            [OP_CHECKMULTISIGVERIFY] * (MAX_BLOCK_SIGOPS_PER_MB // 20))
-        b34 = self.next_block(34, spend=out[10], script=too_many_multisigs)
-        self.sync_blocks([b34], success=False,
-                         reject_reason='bad-blk-sigops', reconnect=True)
-
-        # CHECKSIGVERIFY
-        self.log.info(
-            "Accept a block with the max number of OP_CHECKSIGVERIFY sigops")
-        self.move_tip(33)
-        lots_of_checksigs = CScript(
-            [OP_CHECKSIGVERIFY] * (MAX_BLOCK_SIGOPS_PER_MB - 1))
-        b35 = self.next_block(35, spend=out[10], script=lots_of_checksigs)
-        self.sync_blocks([b35], True)
-        self.save_spendable_output()
-
-        self.log.info("Reject a block with too many OP_CHECKSIGVERIFY sigops")
-        too_many_checksigs = CScript(
-            [OP_CHECKSIGVERIFY] * (MAX_BLOCK_SIGOPS_PER_MB))
-        b36 = self.next_block(36, spend=out[11], script=too_many_checksigs)
-        self.sync_blocks([b36], success=False,
-                         reject_reason='bad-blk-sigops', reconnect=True)
-
-        # ... skipped feature_block tests ...
-
-        # Check P2SH SigOp counting
-        #
-        #
-        #                                       ... -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b41 (12)
-        #                                                                                        \-> b40 (12)
-        #
-        # b39 - create some P2SH outputs that will require 6 sigops to spend:
-        #
-        #           redeem_script = COINBASE_PUBKEY, (OP_2DUP+OP_CHECKSIGVERIFY) * 5, OP_CHECKSIG
-        #           p2sh_script = OP_HASH160, ripemd160(sha256(script)), OP_EQUAL
-        #
-        self.log.info("Check P2SH SIGOPS are correctly counted")
-        self.move_tip(35)
-        b39 = self.next_block(39)
-        b39_outputs = 0
-        b39_sigops_per_output = 6
-
-        # Build the redeem script, hash it, use hash to create the p2sh script
-        redeem_script = CScript([self.coinbase_pubkey] + [
-                                OP_2DUP, OP_CHECKSIGVERIFY] * 5 + [OP_CHECKSIG])
-        redeem_script_hash = hash160(redeem_script)
-        p2sh_script = CScript([OP_HASH160, redeem_script_hash, OP_EQUAL])
-
-        # Create a transaction that spends one satoshi to the p2sh_script, the rest to OP_TRUE
-        # This must be signed because it is spending a coinbase
-        spend = out[11]
-        tx = self.create_tx(spend, 0, 1, p2sh_script)
-        tx.vout.append(CTxOut(spend.vout[0].nValue - 1, CScript([OP_TRUE])))
-        self.sign_tx(tx, spend)
-        tx.rehash()
-        b39 = self.update_block(39, [tx])
-        b39_outputs += 1
-
-        # Until block is full, add tx's with 1 satoshi to p2sh_script, the rest
-        # to OP_TRUE
-        tx_new = None
-        tx_last = tx
-        tx_last_n = len(tx.vout) - 1
-        total_size = len(b39.serialize())
-        while(total_size < LEGACY_MAX_BLOCK_SIZE):
-            tx_new = self.create_tx(tx_last, tx_last_n, 1, p2sh_script)
-            tx_new.vout.append(
-                CTxOut(tx_last.vout[tx_last_n].nValue - 1, CScript([OP_TRUE])))
-            tx_new.rehash()
-            total_size += len(tx_new.serialize())
-            if total_size >= LEGACY_MAX_BLOCK_SIZE:
-                break
-            b39.vtx.append(tx_new)  # add tx to block
-            tx_last = tx_new
-            tx_last_n = len(tx_new.vout) - 1
-            b39_outputs += 1
-
-        b39 = self.update_block(39, [])
-        self.sync_blocks([b39], True)
-        self.save_spendable_output()
-
-        # Test sigops in P2SH redeem scripts
-        #
-        # b40 creates 3333 tx's spending the 6-sigop P2SH outputs from b39 for a total of 19998 sigops.
-        # The first tx has one sigop and then at the end we add 2 more to put us just over the max.
-        #
-        # b41 does the same, less one, so it has the maximum sigops permitted.
-        #
-        self.log.info("Reject a block with too many P2SH sigops")
-        self.move_tip(39)
-        b40 = self.next_block(40, spend=out[12])
-        sigops = get_legacy_sigopcount_block(b40)
-        numTxs = (MAX_BLOCK_SIGOPS_PER_MB - sigops) // b39_sigops_per_output
-        assert_equal(numTxs <= b39_outputs, True)
-
-        lastOutpoint = COutPoint(b40.vtx[1].sha256, 0)
-        lastAmount = b40.vtx[1].vout[0].nValue
-        new_txs = []
-        for i in range(1, numTxs + 1):
-            tx = CTransaction()
-            tx.vout.append(CTxOut(1, CScript([OP_TRUE])))
-            tx.vin.append(CTxIn(lastOutpoint, b''))
-            # second input is corresponding P2SH output from b39
-            tx.vin.append(CTxIn(COutPoint(b39.vtx[i].sha256, 0), b''))
-            # Note: must pass the redeem_script (not p2sh_script) to the
-            # signature hash function
-            sighash = SignatureHashForkId(
-                redeem_script, tx, 1, SIGHASH_ALL | SIGHASH_FORKID,
-                lastAmount)
-            sig = self.coinbase_key.sign_ecdsa(
-                sighash) + bytes(bytearray([SIGHASH_ALL | SIGHASH_FORKID]))
-            scriptSig = CScript([sig, redeem_script])
-
-            tx.vin[1].scriptSig = scriptSig
-            pad_tx(tx)
-            tx.rehash()
-            new_txs.append(tx)
-            lastOutpoint = COutPoint(tx.sha256, 0)
-            lastAmount = tx.vout[0].nValue
-
-        b40_sigops_to_fill = MAX_BLOCK_SIGOPS_PER_MB - \
-            (numTxs * b39_sigops_per_output + sigops) + 1
-        tx = CTransaction()
-        tx.vin.append(CTxIn(lastOutpoint, b''))
-        tx.vout.append(CTxOut(1, CScript([OP_CHECKSIG] * b40_sigops_to_fill)))
-        pad_tx(tx)
-        tx.rehash()
-        new_txs.append(tx)
-        self.update_block(40, new_txs)
-        self.sync_blocks([b40], success=False,
-                         reject_reason='bad-blk-sigops', reconnect=True)
-
-        # same as b40, but one less sigop
-        self.log.info("Accept a block with the max number of P2SH sigops")
-        self.move_tip(39)
-        b41 = self.next_block(41, spend=None)
-        self.update_block(41, [b40tx for b40tx in b40.vtx[1:] if b40tx != tx])
-        b41_sigops_to_fill = b40_sigops_to_fill - 1
-        tx = CTransaction()
-        tx.vin.append(CTxIn(lastOutpoint, b''))
-        tx.vout.append(CTxOut(1, CScript([OP_CHECKSIG] * b41_sigops_to_fill)))
-        pad_tx(tx)
-        self.update_block(41, [tx])
-        self.sync_blocks([b41], True)
-
-        # ... skipped feature_block tests ...
-
-        b72 = self.next_block(72)
-        self.save_spendable_output()
-        self.sync_blocks([b72])
-
-        # Test some invalid scripts and MAX_BLOCK_SIGOPS_PER_MB
-        #
-        #                                                                   ..... -> b72
-        #                                                                                    \-> b** (22)
-        #
-
-        # b73 - tx with excessive sigops that are placed after an excessively large script element.
-        #       The purpose of the test is to make sure those sigops are counted.
-        #
-        #       script is a bytearray of size 20,526
-        #
-        #       bytearray[0-19,998]     : OP_CHECKSIG
-        #       bytearray[19,999]       : OP_PUSHDATA4
-        #       bytearray[20,000-20,003]: 521  (max_script_element_size+1, in little-endian format)
-        #       bytearray[20,004-20,525]: unread data (script_element)
-        # bytearray[20,526]       : OP_CHECKSIG (this puts us over the limit)
-        self.log.info(
-            "Reject a block containing too many sigops after a large script element")
-        self.move_tip(72)
-        b73 = self.next_block(73)
-        size = MAX_BLOCK_SIGOPS_PER_MB - 1 + MAX_SCRIPT_ELEMENT_SIZE + 1 + 5 + 1
-        a = bytearray([OP_CHECKSIG] * size)
-        a[MAX_BLOCK_SIGOPS_PER_MB - 1] = int("4e", 16)  # OP_PUSHDATA4
-
-        element_size = MAX_SCRIPT_ELEMENT_SIZE + 1
-        a[MAX_BLOCK_SIGOPS_PER_MB] = element_size % 256
-        a[MAX_BLOCK_SIGOPS_PER_MB + 1] = element_size // 256
-        a[MAX_BLOCK_SIGOPS_PER_MB + 2] = 0
-        a[MAX_BLOCK_SIGOPS_PER_MB + 3] = 0
-
-        tx = self.create_and_sign_transaction(out[22], 1, CScript(a))
-        b73 = self.update_block(73, [tx])
-        assert_equal(get_legacy_sigopcount_block(
-            b73), MAX_BLOCK_SIGOPS_PER_MB + 1)
-        self.sync_blocks([b73], success=False,
-                         reject_reason='bad-blk-sigops', reconnect=True)
-
-        # b74/75 - if we push an invalid script element, all prevous sigops are counted,
-        #          but sigops after the element are not counted.
-        #
-        #       The invalid script element is that the push_data indicates that
-        #       there will be a large amount of data (0xffffff bytes), but we only
-        #       provide a much smaller number.  These bytes are CHECKSIGS so they would
-        #       cause b75 to fail for excessive sigops, if those bytes were counted.
-        #
-        #       b74 fails because we put MAX_BLOCK_SIGOPS_PER_MB+1 before the element
-        # b75 succeeds because we put MAX_BLOCK_SIGOPS_PER_MB before the
-        # element
-        self.log.info(
-            "Check sigops are counted correctly after an invalid script element")
-        self.move_tip(72)
-        b74 = self.next_block(74)
-        size = MAX_BLOCK_SIGOPS_PER_MB - 1 + \
-            MAX_SCRIPT_ELEMENT_SIZE + 42  # total = 20,561
-        a = bytearray([OP_CHECKSIG] * size)
-        a[MAX_BLOCK_SIGOPS_PER_MB] = 0x4e
-        a[MAX_BLOCK_SIGOPS_PER_MB + 1] = 0xfe
-        a[MAX_BLOCK_SIGOPS_PER_MB + 2] = 0xff
-        a[MAX_BLOCK_SIGOPS_PER_MB + 3] = 0xff
-        a[MAX_BLOCK_SIGOPS_PER_MB + 4] = 0xff
-        tx = self.create_and_sign_transaction(out[22], 1, CScript(a))
-        b74 = self.update_block(74, [tx])
-        self.sync_blocks([b74], success=False,
-                         reject_reason='bad-blk-sigops', reconnect=True)
-
-        self.move_tip(72)
-        b75 = self.next_block(75)
-        size = MAX_BLOCK_SIGOPS_PER_MB - 1 + MAX_SCRIPT_ELEMENT_SIZE + 42
-        a = bytearray([OP_CHECKSIG] * size)
-        a[MAX_BLOCK_SIGOPS_PER_MB - 1] = 0x4e
-        a[MAX_BLOCK_SIGOPS_PER_MB] = 0xff
-        a[MAX_BLOCK_SIGOPS_PER_MB + 1] = 0xff
-        a[MAX_BLOCK_SIGOPS_PER_MB + 2] = 0xff
-        a[MAX_BLOCK_SIGOPS_PER_MB + 3] = 0xff
-        tx = self.create_and_sign_transaction(out[22], 1, CScript(a))
-        b75 = self.update_block(75, [tx])
-        self.sync_blocks([b75], True)
-        self.save_spendable_output()
-
-        # Check that if we push an element filled with CHECKSIGs, they are not
-        # counted
-        self.move_tip(75)
-        b76 = self.next_block(76)
-        size = MAX_BLOCK_SIGOPS_PER_MB - 1 + MAX_SCRIPT_ELEMENT_SIZE + 1 + 5
-        a = bytearray([OP_CHECKSIG] * size)
-        # PUSHDATA4, but leave the following bytes as just checksigs
-        a[MAX_BLOCK_SIGOPS_PER_MB - 1] = 0x4e
-        tx = self.create_and_sign_transaction(out[23], 1, CScript(a))
-        b76 = self.update_block(76, [tx])
-        self.sync_blocks([b76], True)
-        self.save_spendable_output()
-
-    # Helper methods
-    ################
-
-    def add_transactions_to_block(self, block, tx_list):
-        [tx.rehash() for tx in tx_list]
-        block.vtx.extend(tx_list)
-
-    # this is a little handier to use than the version in blocktools.py
-    def create_tx(self, spend_tx, n, value, script=CScript([OP_TRUE])):
-        return create_tx_with_script(
-            spend_tx, n, amount=value, script_pub_key=script)
-
-    # sign a transaction, using the key we know about
-    # this signs input 0 in tx, which is assumed to be spending output n in
-    # spend_tx
-    def sign_tx(self, tx, spend_tx):
-        scriptPubKey = bytearray(spend_tx.vout[0].scriptPubKey)
-        if (scriptPubKey[0] == OP_TRUE):  # an anyone-can-spend
-            tx.vin[0].scriptSig = CScript()
-            return
-        sighash = SignatureHashForkId(
-            spend_tx.vout[0].scriptPubKey, tx, 0, SIGHASH_ALL | SIGHASH_FORKID, spend_tx.vout[0].nValue)
-        tx.vin[0].scriptSig = CScript(
-            [self.coinbase_key.sign_ecdsa(sighash) + bytes(bytearray([SIGHASH_ALL | SIGHASH_FORKID]))])
-
-    def create_and_sign_transaction(
-            self, spend_tx, value, script=CScript([OP_TRUE])):
-        tx = self.create_tx(spend_tx, 0, value, script)
-        self.sign_tx(tx, spend_tx)
-        tx.rehash()
-        return tx
-
-    def next_block(self, number, spend=None, additional_coinbase_value=0,
-                   script=CScript([OP_TRUE]), solve=True):
-        if self.tip is None:
-            base_block_hash = self.genesis_hash
-            block_time = int(time.time()) + 1
-        else:
-            base_block_hash = self.tip.sha256
-            block_time = self.tip.nTime + 1
-        # First create the coinbase
-        height = self.block_heights[base_block_hash] + 1
-        coinbase = create_coinbase(height, self.coinbase_pubkey)
-        coinbase.vout[0].nValue += additional_coinbase_value
-        coinbase.rehash()
-        if spend is None:
-            block = create_block(base_block_hash, coinbase, block_time)
-        else:
-            # all but one satoshi to fees
-            coinbase.vout[0].nValue += spend.vout[0].nValue - 1
-            coinbase.rehash()
-            block = create_block(base_block_hash, coinbase, block_time)
-            # spend 1 satoshi
-            tx = self.create_tx(spend, 0, 1, script)
-            self.sign_tx(tx, spend)
-            self.add_transactions_to_block(block, [tx])
-            block.hashMerkleRoot = block.calc_merkle_root()
-        if solve:
-            block.solve()
-        self.tip = block
-        self.block_heights[block.sha256] = height
-        assert number not in self.blocks
-        self.blocks[number] = block
-        return block
-
-    # save the current tip so it can be spent by a later block
-    def save_spendable_output(self):
-        self.log.debug("saving spendable output {}".format(self.tip.vtx[0]))
-        self.spendable_outputs.append(self.tip)
-
-    # get an output that we previously marked as spendable
-    def get_spendable_output(self):
-        self.log.debug("getting spendable output {}".format(
-            self.spendable_outputs[0].vtx[0]))
-        return self.spendable_outputs.pop(0).vtx[0]
-
-    # move the tip back to a previous block
-    def move_tip(self, number):
-        self.tip = self.blocks[number]
-
-    # adds transactions to the block and updates state
-    def update_block(self, block_number, new_transactions, reorder=True):
-        block = self.blocks[block_number]
-        self.add_transactions_to_block(block, new_transactions)
-        old_sha256 = block.sha256
-        if reorder:
-            make_conform_to_ctor(block)
-        block.hashMerkleRoot = block.calc_merkle_root()
-        block.solve()
-        # Update the internal state just like in next_block
-        self.tip = block
-        if block.sha256 != old_sha256:
-            self.block_heights[block.sha256] = self.block_heights[old_sha256]
-            del self.block_heights[old_sha256]
-        self.blocks[block_number] = block
-        return block
-
-    def bootstrap_p2p(self):
-        """Add a P2P connection to the node.
-
-        Helper to connect and wait for version handshake."""
-        self.nodes[0].add_p2p_connection(P2PDataStore())
-        # We need to wait for the initial getheaders from the peer before we
-        # start populating our blockstore. If we don't, then we may run ahead
-        # to the next subtest before we receive the getheaders. We'd then send
-        # an INV for the next block and receive two getheaders - one for the
-        # IBD and one for the INV. We'd respond to both and could get
-        # unexpectedly disconnected if the DoS score for that error is 50.
-        self.nodes[0].p2p.wait_for_getheaders(timeout=5)
-
-    def reconnect_p2p(self):
-        """Tear down and bootstrap the P2P connection to the node.
-
-        The node gets disconnected several times in this test. This helper
-        method reconnects the p2p and restarts the network thread."""
-        self.nodes[0].disconnect_p2ps()
-        self.bootstrap_p2p()
-
-    def sync_blocks(self, blocks, success=True, reject_reason=None,
-                    request_block=True, reconnect=False, timeout=60):
-        """Sends blocks to test node. Syncs and verifies that tip has advanced to most recent block.
-
-        Call with success = False if the tip shouldn't advance to the most recent block."""
-        self.nodes[0].p2p.send_blocks_and_test(blocks, self.nodes[0], success=success,
-                                               reject_reason=reject_reason, request_block=request_block, timeout=timeout, expect_disconnect=reconnect)
-
-        if reconnect:
-            self.reconnect_p2p()
-
-
-if __name__ == '__main__':
-    FullBlockSigOpsTest().main()
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -657,7 +657,7 @@
 def check_script_prefixes(all_scripts):
     """Check that no more than `EXPECTED_VIOLATION_COUNT` of the
        test scripts don't start with one of the allowed name prefixes."""
-    EXPECTED_VIOLATION_COUNT = 24
+    EXPECTED_VIOLATION_COUNT = 21
 
     # LEEWAY is provided as a transition measure, so that pull-requests
     # that introduce new tests that don't conform with the naming