diff --git a/doc/release-notes.md b/doc/release-notes.md
index 3a56a2cc8..eafb452c1 100644
--- a/doc/release-notes.md
+++ b/doc/release-notes.md
@@ -1,16 +1,26 @@
 Bitcoin ABC version 0.21.5 is now available from:
 
   <https://download.bitcoinabc.org/0.21.5/>
 
 This release includes the following features and fixes:
  - Removed deprecated `getinfo` RPC.
  - Update univalue to 1.0.5
 
+Tests
+-----
+
+- The regression test chain, that can be enabled by the `-regtest` command line
+  flag, now requires transactions to not violate standard policy by default.
+  Making the default the same as for mainnet, makes it easier to test mainnet
+  behavior on regtest. Be reminded that the testnet still allows non-standard
+  txs by default and that the policy can be locally adjusted with the
+  `-acceptnonstdtxn` command line flag for both test chains.
+
 Configuration
 ------------
 
 * An error is issued where previously a warning was issued when a setting in
   the config file was specified in the default section, but not overridden for
   the selected network. This change takes only effect if the selected network
   is not mainnet.
 
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index 78f794baa..2ad785e80 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -1,662 +1,662 @@
 // Copyright (c) 2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017-2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h>
 
 #include <chainparamsconstants.h>
 #include <chainparamsseeds.h>
 #include <consensus/merkle.h>
 #include <tinyformat.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 
 #include <cassert>
 #include <memory>
 
 static CBlock CreateGenesisBlock(const char *pszTimestamp,
                                  const CScript &genesisOutputScript,
                                  uint32_t nTime, uint32_t nNonce,
                                  uint32_t nBits, int32_t nVersion,
                                  const Amount genesisReward) {
     CMutableTransaction txNew;
     txNew.nVersion = 1;
     txNew.vin.resize(1);
     txNew.vout.resize(1);
     txNew.vin[0].scriptSig =
         CScript() << 486604799 << CScriptNum(4)
                   << std::vector<uint8_t>((const uint8_t *)pszTimestamp,
                                           (const uint8_t *)pszTimestamp +
                                               strlen(pszTimestamp));
     txNew.vout[0].nValue = genesisReward;
     txNew.vout[0].scriptPubKey = genesisOutputScript;
 
     CBlock genesis;
     genesis.nTime = nTime;
     genesis.nBits = nBits;
     genesis.nNonce = nNonce;
     genesis.nVersion = nVersion;
     genesis.vtx.push_back(MakeTransactionRef(std::move(txNew)));
     genesis.hashPrevBlock.SetNull();
     genesis.hashMerkleRoot = BlockMerkleRoot(genesis);
     return genesis;
 }
 
 /**
  * Build the genesis block. Note that the output of its generation transaction
  * cannot be spent since it did not originally exist in the database.
  *
  * CBlock(hash=000000000019d6, ver=1, hashPrevBlock=00000000000000,
  * hashMerkleRoot=4a5e1e, nTime=1231006505, nBits=1d00ffff, nNonce=2083236893,
  * vtx=1)
  *   CTransaction(hash=4a5e1e, ver=1, vin.size=1, vout.size=1, nLockTime=0)
  *     CTxIn(COutPoint(000000, -1), coinbase
  * 04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73)
  *     CTxOut(nValue=50.00000000, scriptPubKey=0x5F1DF16B2B704C8A578D0B)
  *   vMerkleTree: 4a5e1e
  */
 CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits,
                           int32_t nVersion, const Amount genesisReward) {
     const char *pszTimestamp =
         "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks";
     const CScript genesisOutputScript =
         CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909"
                               "a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112"
                               "de5c384df7ba0b8d578a4c702b6bf11d5f")
                   << OP_CHECKSIG;
     return CreateGenesisBlock(pszTimestamp, genesisOutputScript, nTime, nNonce,
                               nBits, nVersion, genesisReward);
 }
 
 /**
  * Main network
  */
 class CMainParams : public CChainParams {
 public:
     CMainParams() {
         strNetworkID = CBaseChainParams::MAIN;
         consensus.nSubsidyHalvingInterval = 210000;
         // 00000000000000ce80a7e057163a4db1d5ad7b20fb6f598c9597b9665c8fb0d4 -
         // April 1, 2012
         consensus.BIP16Height = 173805;
         consensus.BIP34Height = 227931;
         consensus.BIP34Hash = BlockHash::fromHex(
             "000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8");
         // 000000000000000004c2b624ed5d7756c508d90fd0da2c7c679febfa6c4735f0
         consensus.BIP65Height = 388381;
         // 00000000000000000379eaa19dce8c9b722d46ae6a57c2f1a988119488b50931
         consensus.BIP66Height = 363725;
         // 000000000000000004a1b34462cb8aeebd5799177f7a29cf28f2d1961716b5b5
         consensus.CSVHeight = 419328;
         consensus.powLimit = uint256S(
             "00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
         // two weeks
         consensus.nPowTargetTimespan = 14 * 24 * 60 * 60;
         consensus.nPowTargetSpacing = 10 * 60;
         consensus.fPowAllowMinDifficultyBlocks = false;
         consensus.fPowNoRetargeting = false;
 
         // nPowTargetTimespan / nPowTargetSpacing
         consensus.nMinerConfirmationWindow = 2016;
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY] = {
             .bit = 28,
             // 95% of 2016
             .nActivationThreshold = 1916,
             // January 1, 2008
             .nStartTime = 1199145601,
             // December 31, 2008
             .nTimeout = 1230767999,
         };
         consensus.vDeployments[Consensus::DEPLOYEMENT_MINER_FUND] = {
             .bit = 0,
             // 66% of 2016
             .nActivationThreshold = 1344,
             // Nov 15, 2019 12:00:00 UTC
             .nStartTime = 1573819200,
             // May 15, 2020 12:00:00 UTC
             .nTimeout = 1589544000,
         };
         consensus.vDeployments[Consensus::DEPLOYEMENT_MINER_FUND_ABC] = {
             .bit = 1,
             // 66% of 2016
             .nActivationThreshold = 1344,
             // Nov 15, 2019 12:00:00 UTC
             .nStartTime = 1573819200,
             // May 15, 2020 12:00:00 UTC
             .nTimeout = 1589544000,
         };
         consensus.vDeployments[Consensus::DEPLOYEMENT_MINER_FUND_BCHD] = {
             .bit = 2,
             // 66% of 2016
             .nActivationThreshold = 1344,
             // Nov 15, 2019 12:00:00 UTC
             .nStartTime = 1573819200,
             // May 15, 2020 12:00:00 UTC
             .nTimeout = 1589544000,
         };
         consensus
             .vDeployments[Consensus::DEPLOYEMENT_MINER_FUND_ELECTRON_CASH] = {
             .bit = 3,
             // 66% of 2016
             .nActivationThreshold = 1344,
             // Nov 15, 2019 12:00:00 UTC
             .nStartTime = 1573819200,
             // May 15, 2020 12:00:00 UTC
             .nTimeout = 1589544000,
         };
 
         // The miner fund is enabled by default on mainnet.
         consensus.enableMinerFund = true;
 
         // The best chain should have at least this much work.
         consensus.nMinimumChainWork =
             ChainParamsConstants::MAINNET_MINIMUM_CHAIN_WORK;
 
         // By default assume that the signatures in ancestors of this block are
         // valid.
         consensus.defaultAssumeValid =
             ChainParamsConstants::MAINNET_DEFAULT_ASSUME_VALID;
 
         // August 1, 2017 hard fork
         consensus.uahfHeight = 478558;
 
         // November 13, 2017 hard fork
         consensus.daaHeight = 504031;
 
         // November 15, 2018 hard fork
         consensus.magneticAnomalyHeight = 556766;
 
         // November 15, 2019 protocol upgrade
         consensus.gravitonHeight = 609135;
 
         // May 15, 2020 12:00:00 UTC protocol upgrade
         consensus.phononActivationTime = 1589544000;
 
         // Nov 15, 2020 12:00:00 UTC protocol upgrade
         consensus.axionActivationTime = 1605441600;
 
         /**
          * The message start string is designed to be unlikely to occur in
          * normal data. The characters are rarely used upper ASCII, not valid as
          * UTF-8, and produce a large 32-bit integer with any alignment.
          */
         diskMagic[0] = 0xf9;
         diskMagic[1] = 0xbe;
         diskMagic[2] = 0xb4;
         diskMagic[3] = 0xd9;
         netMagic[0] = 0xe3;
         netMagic[1] = 0xe1;
         netMagic[2] = 0xf3;
         netMagic[3] = 0xe8;
         nDefaultPort = 8333;
         nPruneAfterHeight = 100000;
         m_assumed_blockchain_size = 200;
         m_assumed_chain_state_size = 3;
 
         genesis = CreateGenesisBlock(1231006505, 2083236893, 0x1d00ffff, 1,
                                      50 * COIN);
         consensus.hashGenesisBlock = genesis.GetHash();
         assert(consensus.hashGenesisBlock ==
                uint256S("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1"
                         "b60a8ce26f"));
         assert(genesis.hashMerkleRoot ==
                uint256S("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b"
                         "7afdeda33b"));
 
         // Note that of those which support the service bits prefix, most only
         // support a subset of possible options. This is fine at runtime as
         // we'll fall back to using them as a oneshot if they don't support the
         // service bits we want, but we should get them updated to support all
         // service bits wanted by any release ASAP to avoid it where possible.
         // Bitcoin ABC seeder
         vSeeds.emplace_back("seed.bitcoinabc.org");
         // bitcoinforks seeders
         vSeeds.emplace_back("seed-abc.bitcoinforks.org");
         // BU backed seeder
         vSeeds.emplace_back("btccash-seeder.bitcoinunlimited.info");
         // Jason B. Cox
         vSeeds.emplace_back("seeder.jasonbcox.com");
         // Amaury SÉCHET
         vSeeds.emplace_back("seed.deadalnix.me");
         // BCHD
         vSeeds.emplace_back("seed.bchd.cash");
 
         base58Prefixes[PUBKEY_ADDRESS] = std::vector<uint8_t>(1, 0);
         base58Prefixes[SCRIPT_ADDRESS] = std::vector<uint8_t>(1, 5);
         base58Prefixes[SECRET_KEY] = std::vector<uint8_t>(1, 128);
         base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E};
         base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4};
         cashaddrPrefix = "bitcoincash";
 
         vFixedSeeds = std::vector<SeedSpec6>(
             pnSeed6_main, pnSeed6_main + ARRAYLEN(pnSeed6_main));
 
         fDefaultConsistencyChecks = false;
         fRequireStandard = true;
-        fMineBlocksOnDemand = false;
+        m_is_test_chain = false;
 
         checkpointData = {
             .mapCheckpoints = {
                 {11111, BlockHash::fromHex("0000000069e244f73d78e8fd29ba2fd2ed6"
                                            "18bd6fa2ee92559f542fdb26e7c1d")},
                 {33333, BlockHash::fromHex("000000002dd5588a74784eaa7ab0507a18a"
                                            "d16a236e7b1ce69f00d7ddfb5d0a6")},
                 {74000, BlockHash::fromHex("0000000000573993a3c9e41ce34471c079d"
                                            "cf5f52a0e824a81e7f953b8661a20")},
                 {105000, BlockHash::fromHex("00000000000291ce28027faea320c8d2b0"
                                             "54b2e0fe44a773f3eefb151d6bdc97")},
                 {134444, BlockHash::fromHex("00000000000005b12ffd4cd315cd34ffd4"
                                             "a594f430ac814c91184a0d42d2b0fe")},
                 {168000, BlockHash::fromHex("000000000000099e61ea72015e79632f21"
                                             "6fe6cb33d7899acb35b75c8303b763")},
                 {193000, BlockHash::fromHex("000000000000059f452a5f7340de6682a9"
                                             "77387c17010ff6e6c3bd83ca8b1317")},
                 {210000, BlockHash::fromHex("000000000000048b95347e83192f69cf03"
                                             "66076336c639f9b7228e9ba171342e")},
                 {216116, BlockHash::fromHex("00000000000001b4f4b433e81ee46494af"
                                             "945cf96014816a4e2370f11b23df4e")},
                 {225430, BlockHash::fromHex("00000000000001c108384350f74090433e"
                                             "7fcf79a606b8e797f065b130575932")},
                 {250000, BlockHash::fromHex("000000000000003887df1f29024b06fc22"
                                             "00b55f8af8f35453d7be294df2d214")},
                 {279000, BlockHash::fromHex("0000000000000001ae8c72a0b0c301f67e"
                                             "3afca10e819efa9041e458e9bd7e40")},
                 {295000, BlockHash::fromHex("00000000000000004d9b4ef50f0f9d686f"
                                             "d69db2e03af35a100370c64632a983")},
                 // UAHF fork block.
                 {478558, BlockHash::fromHex("0000000000000000011865af4122fe3b14"
                                             "4e2cbeea86142e8ff2fb4107352d43")},
                 // Nov, 13 DAA activation block.
                 {504031, BlockHash::fromHex("0000000000000000011ebf65b60d0a3de8"
                                             "0b8175be709d653b4c1a1beeb6ab9c")},
                 // Monolith activation.
                 {530359, BlockHash::fromHex("0000000000000000011ada8bd08f46074f"
                                             "44a8f155396f43e38acf9501c49103")},
                 // Magnetic anomaly activation.
                 {556767, BlockHash::fromHex("0000000000000000004626ff6e3b936941"
                                             "d341c5932ece4357eeccac44e6d56c")},
                 // Great wall activation.
                 {582680, BlockHash::fromHex("000000000000000001b4b8e36aec7d4f96"
                                             "71a47872cb9a74dc16ca398c7dcc18")},
                 // Graviton activation.
                 {609136, BlockHash::fromHex("000000000000000000b48bb207faac5ac6"
                                             "55c313e41ac909322eaa694f5bc5b1")},
             }};
 
         // Data as of block
         // 000000000000000001d2ce557406b017a928be25ee98906397d339c3f68eec5d
         // (height 523992).
         chainTxData = ChainTxData{
             // UNIX timestamp of last known number of transactions.
             1522608016,
             // Total number of transactions between genesis and that timestamp
             // (the tx=... number in the ChainStateFlushed debug.log lines)
             248589038,
             // Estimated number of transactions per second after that timestamp.
             3.2,
         };
     }
 };
 
 /**
  * Testnet (v3)
  */
 class CTestNetParams : public CChainParams {
 public:
     CTestNetParams() {
         strNetworkID = CBaseChainParams::TESTNET;
         consensus.nSubsidyHalvingInterval = 210000;
         // 00000000040b4e986385315e14bee30ad876d8b47f748025b26683116d21aa65
         consensus.BIP16Height = 514;
         consensus.BIP34Height = 21111;
         consensus.BIP34Hash = BlockHash::fromHex(
             "0000000023b3a96d3484e5abb3755c413e7d41500f8e2a5c3f0dd01299cd8ef8");
         // 00000000007f6655f22f98e72ed80d8b06dc761d5da09df0fa1dc4be4f861eb6
         consensus.BIP65Height = 581885;
         // 000000002104c8c45e99a8853285a3b592602a3ccde2b832481da85e9e4ba182
         consensus.BIP66Height = 330776;
         // 00000000025e930139bac5c6c31a403776da130831ab85be56578f3fa75369bb
         consensus.CSVHeight = 770112;
         consensus.powLimit = uint256S(
             "00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
         // two weeks
         consensus.nPowTargetTimespan = 14 * 24 * 60 * 60;
         consensus.nPowTargetSpacing = 10 * 60;
         consensus.fPowAllowMinDifficultyBlocks = true;
         consensus.fPowNoRetargeting = false;
 
         // nPowTargetTimespan / nPowTargetSpacing
         consensus.nMinerConfirmationWindow = 2016;
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY] = {
             .bit = 28,
             // 75% of 2016
             .nActivationThreshold = 1512,
             // January 1, 2008
             .nStartTime = 1199145601,
             // December 31, 2008
             .nTimeout = 1230767999,
         };
         consensus.vDeployments[Consensus::DEPLOYEMENT_MINER_FUND] = {
             .bit = 0,
             // 66% of 2016
             .nActivationThreshold = 1344,
             // Nov 15, 2019 12:00:00 UTC
             .nStartTime = 1573819200,
             // May 15, 2020 12:00:00 UTC
             .nTimeout = 1589544000,
         };
         consensus.vDeployments[Consensus::DEPLOYEMENT_MINER_FUND_ABC] = {
             .bit = 1,
             // 66% of 2016
             .nActivationThreshold = 1344,
             // Nov 15, 2019 12:00:00 UTC
             .nStartTime = 1573819200,
             // May 15, 2020 12:00:00 UTC
             .nTimeout = 1589544000,
         };
         consensus.vDeployments[Consensus::DEPLOYEMENT_MINER_FUND_BCHD] = {
             .bit = 2,
             // 66% of 2016
             .nActivationThreshold = 1344,
             // Nov 15, 2019 12:00:00 UTC
             .nStartTime = 1573819200,
             // May 15, 2020 12:00:00 UTC
             .nTimeout = 1589544000,
         };
         consensus
             .vDeployments[Consensus::DEPLOYEMENT_MINER_FUND_ELECTRON_CASH] = {
             .bit = 3,
             // 66% of 2016
             .nActivationThreshold = 1344,
             // Nov 15, 2019 12:00:00 UTC
             .nStartTime = 1573819200,
             // May 15, 2020 12:00:00 UTC
             .nTimeout = 1589544000,
         };
 
         // The miner fund is disabled by default on testnet.
         consensus.enableMinerFund = false;
 
         // The best chain should have at least this much work.
         consensus.nMinimumChainWork =
             ChainParamsConstants::TESTNET_MINIMUM_CHAIN_WORK;
 
         // By default assume that the signatures in ancestors of this block are
         // valid.
         consensus.defaultAssumeValid =
             ChainParamsConstants::TESTNET_DEFAULT_ASSUME_VALID;
 
         // August 1, 2017 hard fork
         consensus.uahfHeight = 1155875;
 
         // November 13, 2017 hard fork
         consensus.daaHeight = 1188697;
 
         // November 15, 2018 hard fork
         consensus.magneticAnomalyHeight = 1267996;
 
         // November 15, 2019 protocol upgrade
         consensus.gravitonHeight = 1341711;
 
         // May 15, 2020 12:00:00 UTC protocol upgrade
         consensus.phononActivationTime = 1589544000;
 
         // Nov 15, 2020 12:00:00 UTC protocol upgrade
         consensus.axionActivationTime = 1605441600;
 
         diskMagic[0] = 0x0b;
         diskMagic[1] = 0x11;
         diskMagic[2] = 0x09;
         diskMagic[3] = 0x07;
         netMagic[0] = 0xf4;
         netMagic[1] = 0xe5;
         netMagic[2] = 0xf3;
         netMagic[3] = 0xf4;
         nDefaultPort = 18333;
         nPruneAfterHeight = 1000;
         m_assumed_blockchain_size = 20;
         m_assumed_chain_state_size = 2;
 
         genesis =
             CreateGenesisBlock(1296688602, 414098458, 0x1d00ffff, 1, 50 * COIN);
         consensus.hashGenesisBlock = genesis.GetHash();
         assert(consensus.hashGenesisBlock ==
                uint256S("000000000933ea01ad0ee984209779baaec3ced90fa3f408719526"
                         "f8d77f4943"));
         assert(genesis.hashMerkleRoot ==
                uint256S("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b"
                         "7afdeda33b"));
 
         vFixedSeeds.clear();
         vSeeds.clear();
         // nodes with support for servicebits filtering should be at the top
         // Bitcoin ABC seeder
         vSeeds.emplace_back("testnet-seed.bitcoinabc.org");
         // bitcoinforks seeders
         vSeeds.emplace_back("testnet-seed-abc.bitcoinforks.org");
         // Amaury SÉCHET
         vSeeds.emplace_back("testnet-seed.deadalnix.me");
         // BCHD
         vSeeds.emplace_back("testnet-seed.bchd.cash");
 
         base58Prefixes[PUBKEY_ADDRESS] = std::vector<uint8_t>(1, 111);
         base58Prefixes[SCRIPT_ADDRESS] = std::vector<uint8_t>(1, 196);
         base58Prefixes[SECRET_KEY] = std::vector<uint8_t>(1, 239);
         base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
         base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
         cashaddrPrefix = "bchtest";
         vFixedSeeds = std::vector<SeedSpec6>(
             pnSeed6_test, pnSeed6_test + ARRAYLEN(pnSeed6_test));
 
         fDefaultConsistencyChecks = false;
         fRequireStandard = false;
-        fMineBlocksOnDemand = false;
+        m_is_test_chain = true;
 
         checkpointData = {
             .mapCheckpoints = {
                 {546, BlockHash::fromHex("000000002a936ca763904c3c35fce2f3556c5"
                                          "59c0214345d31b1bcebf76acb70")},
                 // UAHF fork block.
                 {1155875,
                  BlockHash::fromHex("00000000f17c850672894b9a75b63a1e72830bbd5f"
                                     "4c8889b5c1a80e7faef138")},
                 // Nov, 13. DAA activation block.
                 {1188697,
                  BlockHash::fromHex("0000000000170ed0918077bde7b4d36cc4c91be69f"
                                     "a09211f748240dabe047fb")},
                 // Great wall activation.
                 {1303885,
                  BlockHash::fromHex("00000000000000479138892ef0e4fa478ccc938fb9"
                                     "4df862ef5bde7e8dee23d3")},
                 // Graviton activation.
                 {1341712,
                  BlockHash::fromHex("00000000fffc44ea2e202bd905a9fbbb9491ef9e9d"
                                     "5a9eed4039079229afa35b")},
             }};
 
         // Data as of block
         // 000000000005b07ecf85563034d13efd81c1a29e47e22b20f4fc6919d5b09cd6
         // (height 1223263)
         chainTxData = ChainTxData{1522608381, 15052068, 0.15};
     }
 };
 
 /**
  * Regression test
  */
 class CRegTestParams : public CChainParams {
 public:
     CRegTestParams() {
         strNetworkID = CBaseChainParams::REGTEST;
         consensus.nSubsidyHalvingInterval = 150;
         // always enforce P2SH BIP16 on regtest
         consensus.BIP16Height = 0;
         // BIP34 has not activated on regtest (far in the future so block v1 are
         // not rejected in tests)
         consensus.BIP34Height = 100000000;
         consensus.BIP34Hash = BlockHash();
         // BIP65 activated on regtest (Used in rpc activation tests)
         consensus.BIP65Height = 1351;
         // BIP66 activated on regtest (Used in rpc activation tests)
         consensus.BIP66Height = 1251;
         // CSV activated on regtest (Used in rpc activation tests)
         consensus.CSVHeight = 576;
         consensus.powLimit = uint256S(
             "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
         // two weeks
         consensus.nPowTargetTimespan = 14 * 24 * 60 * 60;
         consensus.nPowTargetSpacing = 10 * 60;
         consensus.fPowAllowMinDifficultyBlocks = true;
         consensus.fPowNoRetargeting = true;
 
         // Faster than normal for regtest (144 instead of 2016)
         consensus.nMinerConfirmationWindow = 144;
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY] = {
             .bit = 28,
             // 75% of 144
             .nActivationThreshold = 108,
         };
         consensus.vDeployments[Consensus::DEPLOYEMENT_MINER_FUND] = {
             .bit = 0,
             // 66% of 144
             .nActivationThreshold = 96,
             // Nov 15, 2019 12:00:00 UTC
             .nStartTime = 1573819200,
             // May 15, 2020 12:00:00 UTC
             .nTimeout = 1589544000,
         };
         consensus.vDeployments[Consensus::DEPLOYEMENT_MINER_FUND_ABC] = {
             .bit = 1,
             // 66% of 144
             .nActivationThreshold = 96,
             // Nov 15, 2019 12:00:00 UTC
             .nStartTime = 1573819200,
             // May 15, 2020 12:00:00 UTC
             .nTimeout = 1589544000,
         };
         consensus.vDeployments[Consensus::DEPLOYEMENT_MINER_FUND_BCHD] = {
             .bit = 2,
             // 66% of 144
             .nActivationThreshold = 96,
             // Nov 15, 2019 12:00:00 UTC
             .nStartTime = 1573819200,
             // May 15, 2020 12:00:00 UTC
             .nTimeout = 1589544000,
         };
         consensus
             .vDeployments[Consensus::DEPLOYEMENT_MINER_FUND_ELECTRON_CASH] = {
             .bit = 3,
             // 66% of 144
             .nActivationThreshold = 96,
             // Nov 15, 2019 12:00:00 UTC
             .nStartTime = 1573819200,
             // May 15, 2020 12:00:00 UTC
             .nTimeout = 1589544000,
         };
 
         // The miner fund is disabled by default on regnet.
         consensus.enableMinerFund = false;
 
         // The best chain should have at least this much work.
         consensus.nMinimumChainWork = uint256S("0x00");
 
         // By default assume that the signatures in ancestors of this block are
         // valid.
         consensus.defaultAssumeValid = BlockHash();
 
         // UAHF is always enabled on regtest.
         consensus.uahfHeight = 0;
 
         // November 13, 2017 hard fork is always on on regtest.
         consensus.daaHeight = 0;
 
         // November 15, 2018 hard fork is always on on regtest.
         consensus.magneticAnomalyHeight = 0;
 
         // November 15, 2019 protocol upgrade
         consensus.gravitonHeight = 0;
 
         // May 15, 2020 12:00:00 UTC protocol upgrade
         consensus.phononActivationTime = 1589544000;
 
         // Nov 15, 2020 12:00:00 UTC protocol upgrade
         consensus.axionActivationTime = 1605441600;
 
         diskMagic[0] = 0xfa;
         diskMagic[1] = 0xbf;
         diskMagic[2] = 0xb5;
         diskMagic[3] = 0xda;
         netMagic[0] = 0xda;
         netMagic[1] = 0xb5;
         netMagic[2] = 0xbf;
         netMagic[3] = 0xfa;
         nDefaultPort = 18444;
         nPruneAfterHeight = 1000;
         m_assumed_blockchain_size = 0;
         m_assumed_chain_state_size = 0;
 
         genesis = CreateGenesisBlock(1296688602, 2, 0x207fffff, 1, 50 * COIN);
         consensus.hashGenesisBlock = genesis.GetHash();
         assert(consensus.hashGenesisBlock ==
                uint256S("0x0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b"
                         "1a11466e2206"));
         assert(genesis.hashMerkleRoot ==
                uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab212"
                         "7b7afdeda33b"));
 
         //! Regtest mode doesn't have any fixed seeds.
         vFixedSeeds.clear();
         //! Regtest mode doesn't have any DNS seeds.
         vSeeds.clear();
 
         fDefaultConsistencyChecks = true;
-        fRequireStandard = false;
-        fMineBlocksOnDemand = true;
+        fRequireStandard = true;
+        m_is_test_chain = true;
 
         checkpointData = {
             .mapCheckpoints = {
                 {0, BlockHash::fromHex("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb4"
                                        "36012afca590b1a11466e2206")},
             }};
 
         chainTxData = ChainTxData{0, 0, 0};
 
         base58Prefixes[PUBKEY_ADDRESS] = std::vector<uint8_t>(1, 111);
         base58Prefixes[SCRIPT_ADDRESS] = std::vector<uint8_t>(1, 196);
         base58Prefixes[SECRET_KEY] = std::vector<uint8_t>(1, 239);
         base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
         base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
         cashaddrPrefix = "bchreg";
     }
 };
 
 static std::unique_ptr<CChainParams> globalChainParams;
 
 const CChainParams &Params() {
     assert(globalChainParams);
     return *globalChainParams;
 }
 
 std::unique_ptr<CChainParams> CreateChainParams(const std::string &chain) {
     if (chain == CBaseChainParams::MAIN) {
         return std::make_unique<CMainParams>();
     }
 
     if (chain == CBaseChainParams::TESTNET) {
         return std::make_unique<CTestNetParams>();
     }
 
     if (chain == CBaseChainParams::REGTEST) {
         return std::make_unique<CRegTestParams>();
     }
 
     throw std::runtime_error(
         strprintf("%s: Unknown chain %s.", __func__, chain));
 }
 
 void SelectParams(const std::string &network) {
     SelectBaseParams(network);
     globalChainParams = CreateChainParams(network);
 }
diff --git a/src/chainparams.h b/src/chainparams.h
index 693551901..4d4dca176 100644
--- a/src/chainparams.h
+++ b/src/chainparams.h
@@ -1,141 +1,140 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_CHAINPARAMS_H
 #define BITCOIN_CHAINPARAMS_H
 
 #include <chainparamsbase.h>
 #include <consensus/params.h>
 #include <primitives/block.h>
 #include <protocol.h>
 
 #include <memory>
 #include <vector>
 
 struct SeedSpec6 {
     uint8_t addr[16];
     uint16_t port;
 };
 
 typedef std::map<int, BlockHash> MapCheckpoints;
 
 struct CCheckpointData {
     MapCheckpoints mapCheckpoints;
 };
 
 /**
  * Holds various statistics on transactions within a chain. Used to estimate
  * verification progress during chain sync.
  *
  * See also: CChainParams::TxData, GuessVerificationProgress.
  */
 struct ChainTxData {
     int64_t nTime;
     int64_t nTxCount;
     double dTxRate;
 };
 
 /**
  * CChainParams defines various tweakable parameters of a given instance of the
  * Bitcoin system. There are three: the main network on which people trade goods
  * and services, the public test network which gets reset from time to time and
  * a regression test mode which is intended for private networks only. It has
  * minimal difficulty to ensure that blocks can be found instantly.
  */
 class CChainParams {
 public:
     enum Base58Type {
         PUBKEY_ADDRESS,
         SCRIPT_ADDRESS,
         SECRET_KEY,
         EXT_PUBLIC_KEY,
         EXT_SECRET_KEY,
 
         MAX_BASE58_TYPES
     };
 
     const Consensus::Params &GetConsensus() const { return consensus; }
     const CMessageHeader::MessageMagic &DiskMagic() const { return diskMagic; }
     const CMessageHeader::MessageMagic &NetMagic() const { return netMagic; }
     int GetDefaultPort() const { return nDefaultPort; }
 
     const CBlock &GenesisBlock() const { return genesis; }
     /** Default value for -checkmempool and -checkblockindex argument */
     bool DefaultConsistencyChecks() const { return fDefaultConsistencyChecks; }
     /** Policy: Filter transactions that do not match well-defined patterns */
     bool RequireStandard() const { return fRequireStandard; }
+    /** If this is a test chain */
+    bool IsTestChain() const { return m_is_test_chain; }
     uint64_t PruneAfterHeight() const { return nPruneAfterHeight; }
     /** Minimum free space (in GB) needed for data directory */
     uint64_t AssumedBlockchainSize() const { return m_assumed_blockchain_size; }
     /**
      * Minimum free space (in GB) needed for data directory when pruned; Does
      * not include prune target
      */
     uint64_t AssumedChainStateSize() const {
         return m_assumed_chain_state_size;
     }
-    /**
-     * Make miner stop after a block is found. In RPC, don't return until
-     * nGenProcLimit blocks are generated.
-     */
-    bool MineBlocksOnDemand() const { return fMineBlocksOnDemand; }
+    /** Whether it is possible to mine blocks on demand (no retargeting) */
+    bool MineBlocksOnDemand() const { return consensus.fPowNoRetargeting; }
     /** Return the BIP70 network string (main, test or regtest) */
     std::string NetworkIDString() const { return strNetworkID; }
     /** Return the list of hostnames to look up for DNS seeds */
     const std::vector<std::string> &DNSSeeds() const { return vSeeds; }
     const std::vector<uint8_t> &Base58Prefix(Base58Type type) const {
         return base58Prefixes[type];
     }
     const std::string &CashAddrPrefix() const { return cashaddrPrefix; }
     const std::vector<SeedSpec6> &FixedSeeds() const { return vFixedSeeds; }
     const CCheckpointData &Checkpoints() const { return checkpointData; }
     const ChainTxData &TxData() const { return chainTxData; }
 
 protected:
     CChainParams() {}
 
     Consensus::Params consensus;
     CMessageHeader::MessageMagic diskMagic;
     CMessageHeader::MessageMagic netMagic;
     int nDefaultPort;
     uint64_t nPruneAfterHeight;
     uint64_t m_assumed_blockchain_size;
     uint64_t m_assumed_chain_state_size;
     std::vector<std::string> vSeeds;
     std::vector<uint8_t> base58Prefixes[MAX_BASE58_TYPES];
     std::string cashaddrPrefix;
     std::string strNetworkID;
     CBlock genesis;
     std::vector<SeedSpec6> vFixedSeeds;
     bool fDefaultConsistencyChecks;
     bool fRequireStandard;
-    bool fMineBlocksOnDemand;
+    bool m_is_test_chain;
     CCheckpointData checkpointData;
     ChainTxData chainTxData;
 };
 
 /**
  * Creates and returns a std::unique_ptr<CChainParams> of the chosen chain.
  * @returns a CChainParams* of the chosen chain.
  * @throws a std::runtime_error if the chain is not supported.
  */
 std::unique_ptr<CChainParams> CreateChainParams(const std::string &chain);
 
 CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits,
                           int32_t nVersion, const Amount genesisReward);
 
 /**
  * Return the currently selected parameters. This won't change after app
  * startup, except for unit tests.
  */
 const CChainParams &Params();
 
 /**
  * Sets the params returned by Params() to those for the given BIP70 chain name.
  * @throws std::runtime_error when the chain is not supported.
  */
 void SelectParams(const std::string &chain);
 
 #endif // BITCOIN_CHAINPARAMS_H
diff --git a/src/init.cpp b/src/init.cpp
index 560529541..63ff78b31 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -1,2598 +1,2598 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <init.h>
 
 #include <addrman.h>
 #include <amount.h>
 #include <avalanche.h>
 #include <banman.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <checkpoints.h>
 #include <compat/sanity.h>
 #include <config.h>
 #include <consensus/validation.h>
 #include <flatfile.h>
 #include <fs.h>
 #include <httprpc.h>
 #include <httpserver.h>
 #include <index/txindex.h>
 #include <interfaces/chain.h>
 #include <key.h>
 #include <miner.h>
 #include <net.h>
 #include <net_processing.h>
 #include <netbase.h>
 #include <policy/mempool.h>
 #include <policy/policy.h>
 #include <rpc/blockchain.h>
 #include <rpc/register.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <scheduler.h>
 #include <script/scriptcache.h>
 #include <script/sigcache.h>
 #include <script/standard.h>
 #include <shutdown.h>
 #include <timedata.h>
 #include <torcontrol.h>
 #include <txdb.h>
 #include <txmempool.h>
 #include <ui_interface.h>
 #include <util/moneystr.h>
 #include <util/system.h>
 #include <util/threadnames.h>
 #include <validation.h>
 #include <validationinterface.h>
 #include <walletinitinterface.h>
 #include <warnings.h>
 
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/algorithm/string/split.hpp>
 #include <boost/thread.hpp>
 
 #if ENABLE_ZMQ
 #include <zmq/zmqnotificationinterface.h>
 #include <zmq/zmqrpc.h>
 #endif
 
 #ifndef WIN32
 #include <attributes.h>
 #include <cerrno>
 #include <csignal>
 #include <sys/stat.h>
 #endif
 #include <cstdint>
 #include <cstdio>
 #include <memory>
 
 static const bool DEFAULT_PROXYRANDOMIZE = true;
 static const bool DEFAULT_REST_ENABLE = false;
 static const bool DEFAULT_STOPAFTERBLOCKIMPORT = false;
 
 // Dump addresses to banlist.dat every 15 minutes (900s)
 static constexpr int DUMP_BANS_INTERVAL = 60 * 15;
 
 std::unique_ptr<CConnman> g_connman;
 std::unique_ptr<PeerLogicValidation> peerLogic;
 std::unique_ptr<BanMan> g_banman;
 
 #ifdef WIN32
 // Win32 LevelDB doesn't use filedescriptors, and the ones used for accessing
 // block files don't count towards the fd_set size limit anyway.
 #define MIN_CORE_FILEDESCRIPTORS 0
 #else
 #define MIN_CORE_FILEDESCRIPTORS 150
 #endif
 
 /**
  * The PID file facilities.
  */
 static const char *BITCOIN_PID_FILENAME = "bitcoind.pid";
 
 static fs::path GetPidFile() {
     return AbsPathForConfigVal(
         fs::path(gArgs.GetArg("-pid", BITCOIN_PID_FILENAME)));
 }
 
 NODISCARD static bool CreatePidFile() {
     FILE *file = fsbridge::fopen(GetPidFile(), "w");
     if (file) {
 #ifdef WIN32
         fprintf(file, "%d\n", GetCurrentProcessId());
 #else
         fprintf(file, "%d\n", getpid());
 #endif
         fclose(file);
         return true;
     } else {
         return InitError(strprintf(_("Unable to create the PID file '%s': %s"),
                                    GetPidFile().string(),
                                    std::strerror(errno)));
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //
 // Shutdown
 //
 
 //
 // Thread management and startup/shutdown:
 //
 // The network-processing threads are all part of a thread group created by
 // AppInit() or the Qt main() function.
 //
 // A clean exit happens when StartShutdown() or the SIGTERM signal handler sets
 // ShutdownRequested(), which triggers the DetectShutdownThread(), which
 // interrupts the main thread group. DetectShutdownThread() then exits, which
 // causes AppInit() to continue (it .joins the shutdown thread). Shutdown() is
 // then called to clean up database connections, and stop other threads that
 // should only be stopped after the main network-processing threads have exited.
 //
 // Shutdown for Qt is very similar, only it uses a QTimer to detect
 // ShutdownRequested() getting set, and then does the normal Qt shutdown thing.
 //
 
 /**
  * This is a minimally invasive approach to shutdown on LevelDB read errors from
  * the chainstate, while keeping user interface out of the common library, which
  * is shared between bitcoind, and bitcoin-qt and non-server tools.
  */
 class CCoinsViewErrorCatcher final : public CCoinsViewBacked {
 public:
     explicit CCoinsViewErrorCatcher(CCoinsView *view)
         : CCoinsViewBacked(view) {}
     bool GetCoin(const COutPoint &outpoint, Coin &coin) const override {
         try {
             return CCoinsViewBacked::GetCoin(outpoint, coin);
         } catch (const std::runtime_error &e) {
             uiInterface.ThreadSafeMessageBox(
                 _("Error reading from database, shutting down."), "",
                 CClientUIInterface::MSG_ERROR);
             LogPrintf("Error reading from database: %s\n", e.what());
             // Starting the shutdown sequence and returning false to the caller
             // would be interpreted as 'entry not found' (as opposed to unable
             // to read data), and could lead to invalid interpretation. Just
             // exit immediately, as we can't continue anyway, and all writes
             // should be atomic.
             abort();
         }
     }
     // Writes do not need similar protection, as failure to write is handled by
     // the caller.
 };
 
 static std::unique_ptr<CCoinsViewErrorCatcher> pcoinscatcher;
 static std::unique_ptr<ECCVerifyHandle> globalVerifyHandle;
 
 static boost::thread_group threadGroup;
 static CScheduler scheduler;
 
 void Interrupt() {
     InterruptHTTPServer();
     InterruptHTTPRPC();
     InterruptRPC();
     InterruptREST();
     InterruptTorControl();
     InterruptMapPort();
     if (g_avalanche) {
         // Avalanche needs to be stopped before we interrupt the thread group as
         // the scheduler will stop working then.
         g_avalanche->stopEventLoop();
     }
     if (g_connman) {
         g_connman->Interrupt();
     }
     if (g_txindex) {
         g_txindex->Interrupt();
     }
 }
 
 void Shutdown(InitInterfaces &interfaces) {
     LogPrintf("%s: In progress...\n", __func__);
     static CCriticalSection cs_Shutdown;
     TRY_LOCK(cs_Shutdown, lockShutdown);
     if (!lockShutdown) {
         return;
     }
 
     /// Note: Shutdown() must be able to handle cases in which initialization
     /// failed part of the way, for example if the data directory was found to
     /// be locked. Be sure that anything that writes files or flushes caches
     /// only does this if the respective module was initialized.
     util::ThreadRename("shutoff");
     g_mempool.AddTransactionsUpdated(1);
 
     StopHTTPRPC();
     StopREST();
     StopRPC();
     StopHTTPServer();
     for (const auto &client : interfaces.chain_clients) {
         client->flush();
     }
     StopMapPort();
 
     // Because avalanche and the network depend on each other, it is important
     // to shut them down in this order:
     // 1. Stop avalanche event loop.
     // 2. Shutdown network processing.
     // 3. Destroy AvalancheProcessor.
     // 4. Destroy CConnman
     if (g_avalanche) {
         g_avalanche->stopEventLoop();
     }
 
     // Because these depend on each-other, we make sure that neither can be
     // using the other before destroying them.
     if (peerLogic) {
         UnregisterValidationInterface(peerLogic.get());
     }
     if (g_connman) {
         g_connman->Stop();
     }
     if (g_txindex) {
         g_txindex->Stop();
     }
 
     StopTorControl();
 
     // After everything has been shut down, but before things get flushed, stop
     // the CScheduler/checkqueue threadGroup
     threadGroup.interrupt_all();
     threadGroup.join_all();
 
     // After the threads that potentially access these pointers have been
     // stopped, destruct and reset all to nullptr.
     peerLogic.reset();
 
     // Destroy various global instances
     g_avalanche.reset();
     g_connman.reset();
     g_banman.reset();
     g_txindex.reset();
 
     if (::g_mempool.IsLoaded() &&
         gArgs.GetArg("-persistmempool", DEFAULT_PERSIST_MEMPOOL)) {
         DumpMempool(::g_mempool);
     }
 
     // FlushStateToDisk generates a ChainStateFlushed callback, which we should
     // avoid missing
     if (pcoinsTip != nullptr) {
         FlushStateToDisk();
     }
 
     // After there are no more peers/RPC left to give us new data which may
     // generate CValidationInterface callbacks, flush them...
     GetMainSignals().FlushBackgroundCallbacks();
 
     // Any future callbacks will be dropped. This should absolutely be safe - if
     // missing a callback results in an unrecoverable situation, unclean
     // shutdown would too. The only reason to do the above flushes is to let the
     // wallet catch up with our current chain to avoid any strange pruning edge
     // cases and make next startup faster by avoiding rescan.
 
     {
         LOCK(cs_main);
         if (pcoinsTip != nullptr) {
             FlushStateToDisk();
         }
         pcoinsTip.reset();
         pcoinscatcher.reset();
         pcoinsdbview.reset();
         pblocktree.reset();
     }
     for (const auto &client : interfaces.chain_clients) {
         client->stop();
     }
 
 #if ENABLE_ZMQ
     if (g_zmq_notification_interface) {
         UnregisterValidationInterface(g_zmq_notification_interface);
         delete g_zmq_notification_interface;
         g_zmq_notification_interface = nullptr;
     }
 #endif
 
     try {
         if (!fs::remove(GetPidFile())) {
             LogPrintf("%s: Unable to remove PID file: File does not exist\n",
                       __func__);
         }
     } catch (const fs::filesystem_error &e) {
         LogPrintf("%s: Unable to remove PID file: %s\n", __func__,
                   fsbridge::get_filesystem_error_message(e));
     }
     interfaces.chain_clients.clear();
     UnregisterAllValidationInterfaces();
     GetMainSignals().UnregisterBackgroundSignalScheduler();
     GetMainSignals().UnregisterWithMempoolSignals(g_mempool);
     globalVerifyHandle.reset();
     ECC_Stop();
     LogPrintf("%s: done\n", __func__);
 }
 
 /**
  * Signal handlers are very limited in what they are allowed to do.
  * The execution context the handler is invoked in is not guaranteed,
  * so we restrict handler operations to just touching variables:
  */
 #ifndef WIN32
 static void HandleSIGTERM(int) {
     StartShutdown();
 }
 
 static void HandleSIGHUP(int) {
     LogInstance().m_reopen_file = true;
 }
 #else
 static BOOL WINAPI consoleCtrlHandler(DWORD dwCtrlType) {
     StartShutdown();
     Sleep(INFINITE);
     return true;
 }
 #endif
 
 #ifndef WIN32
 static void registerSignalHandler(int signal, void (*handler)(int)) {
     struct sigaction sa;
     sa.sa_handler = handler;
     sigemptyset(&sa.sa_mask);
     sa.sa_flags = 0;
     sigaction(signal, &sa, NULL);
 }
 #endif
 
 static void OnRPCStarted() {
     uiInterface.NotifyBlockTip_connect(&RPCNotifyBlockChange);
 }
 
 static void OnRPCStopped() {
     uiInterface.NotifyBlockTip_disconnect(&RPCNotifyBlockChange);
     RPCNotifyBlockChange(false, nullptr);
     g_best_block_cv.notify_all();
     LogPrint(BCLog::RPC, "RPC stopped.\n");
 }
 
 void SetupServerArgs() {
     const auto defaultBaseParams =
         CreateBaseChainParams(CBaseChainParams::MAIN);
     const auto testnetBaseParams =
         CreateBaseChainParams(CBaseChainParams::TESTNET);
     const auto regtestBaseParams =
         CreateBaseChainParams(CBaseChainParams::REGTEST);
     const auto defaultChainParams = CreateChainParams(CBaseChainParams::MAIN);
     const auto testnetChainParams =
         CreateChainParams(CBaseChainParams::TESTNET);
     const auto regtestChainParams =
         CreateChainParams(CBaseChainParams::REGTEST);
 
     // Hidden Options
     std::vector<std::string> hidden_args = {
         "-h", "-help", "-dbcrashratio", "-forcecompactdb", "-parkdeepreorg",
         "-automaticunparking", "-replayprotectionactivationtime",
         "-enableminerfund",
         // GUI args. These will be overwritten by SetupUIArgs for the GUI
         "-allowselfsignedrootcertificates", "-choosedatadir", "-lang=<lang>",
         "-min", "-resetguisettings", "-rootcertificates=<file>", "-splash",
         "-uiplatform",
         // TODO remove after the May 2020 upgrade
         "-phononactivationtime"};
 
     // Set all of the args and their help
     // When adding new options to the categories, please keep and ensure
     // alphabetical ordering. Do not translate _(...) -help-debug options, Many
     // technical terms, and only a very small audience, so is unnecessary stress
     // to translators.
     gArgs.AddArg("-?", "Print this help message and exit",
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-version", "Print version and exit", ArgsManager::ALLOW_ANY,
                  OptionsCategory::OPTIONS);
     gArgs.AddArg("-alertnotify=<cmd>",
                  "Execute command when a relevant alert is received or we see "
                  "a really long fork (%s in cmd is replaced by message)",
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg(
         "-assumevalid=<hex>",
         strprintf(
             "If this block is in the chain assume that it and its ancestors "
             "are valid and potentially skip their script verification (0 to "
             "verify all, default: %s, testnet: %s)",
             defaultChainParams->GetConsensus().defaultAssumeValid.GetHex(),
             testnetChainParams->GetConsensus().defaultAssumeValid.GetHex()),
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-blocksdir=<dir>",
                  "Specify directory to hold blocks subdirectory for *.dat "
                  "files (default: <datadir>)",
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-blocknotify=<cmd>",
                  "Execute command when the best block changes (%s in cmd is "
                  "replaced by block hash)",
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-blockreconstructionextratxn=<n>",
                  strprintf("Extra transactions to keep in memory for compact "
                            "block reconstructions (default: %u)",
                            DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN),
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg(
         "-blocksonly",
         strprintf("Whether to operate in a blocks only mode (default: %d)",
                   DEFAULT_BLOCKSONLY),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::OPTIONS);
     gArgs.AddArg("-conf=<file>",
                  strprintf("Specify configuration file. Relative paths will be "
                            "prefixed by datadir location. (default: %s)",
                            BITCOIN_CONF_FILENAME),
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-datadir=<dir>", "Specify data directory",
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg(
         "-dbbatchsize",
         strprintf("Maximum database write batch size in bytes (default: %u)",
                   nDefaultDbBatchSize),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::OPTIONS);
     gArgs.AddArg(
         "-dbcache=<n>",
         strprintf(
             "Set database cache size in megabytes (%d to %d, default: %d)",
             nMinDbCache, nMaxDbCache, nDefaultDbCache),
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-debuglogfile=<file>",
                  strprintf("Specify location of debug log file. Relative paths "
                            "will be prefixed by a net-specific datadir "
                            "location. (0 to disable; default: %s)",
                            DEFAULT_DEBUGLOGFILE),
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-feefilter",
                  strprintf("Tell other nodes to filter invs to us by our "
                            "mempool min fee (default: %d)",
                            DEFAULT_FEEFILTER),
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::OPTIONS);
     gArgs.AddArg("-finalizationdelay=<n>",
                  strprintf("Set the minimum amount of time to wait between a "
                            "block header reception and the block finalization. "
                            "Unit is seconds (default: %d)",
                            DEFAULT_MIN_FINALIZATION_DELAY),
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg(
         "-includeconf=<file>",
         "Specify additional configuration file, relative to the -datadir path "
         "(only useable from configuration file, not command line)",
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-maxreorgdepth=<n>",
                  strprintf("Configure at what depth blocks are considered "
                            "final (default: %d). Use -1 to disable.",
                            DEFAULT_MAX_REORG_DEPTH),
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-loadblock=<file>",
                  "Imports blocks from external blk000??.dat file on startup",
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-maxmempool=<n>",
                  strprintf("Keep the transaction memory pool below <n> "
                            "megabytes (default: %u)",
                            DEFAULT_MAX_MEMPOOL_SIZE),
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-maxorphantx=<n>",
                  strprintf("Keep at most <n> unconnectable transactions in "
                            "memory (default: %u)",
                            DEFAULT_MAX_ORPHAN_TRANSACTIONS),
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-mempoolexpiry=<n>",
                  strprintf("Do not keep transactions in the mempool longer "
                            "than <n> hours (default: %u)",
                            DEFAULT_MEMPOOL_EXPIRY),
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg(
         "-minimumchainwork=<hex>",
         strprintf(
             "Minimum work assumed to exist on a valid chain in hex "
             "(default: %s, testnet: %s)",
             defaultChainParams->GetConsensus().nMinimumChainWork.GetHex(),
             testnetChainParams->GetConsensus().nMinimumChainWork.GetHex()),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::OPTIONS);
     gArgs.AddArg(
         "-par=<n>",
         strprintf("Set the number of script verification threads (%u to %d, 0 "
                   "= auto, <0 = leave that many cores free, default: %d)",
                   -GetNumCores(), MAX_SCRIPTCHECK_THREADS,
                   DEFAULT_SCRIPTCHECK_THREADS),
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-persistmempool",
                  strprintf("Whether to save the mempool on shutdown and load "
                            "on restart (default: %u)",
                            DEFAULT_PERSIST_MEMPOOL),
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-pid=<file>",
                  strprintf("Specify pid file. Relative paths will be prefixed "
                            "by a net-specific datadir location. (default: %s)",
                            BITCOIN_PID_FILENAME),
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg(
         "-prune=<n>",
         strprintf("Reduce storage requirements by enabling pruning (deleting) "
                   "of old blocks. This allows the pruneblockchain RPC to be "
                   "called to delete specific blocks, and enables automatic "
                   "pruning of old blocks if a target size in MiB is provided. "
                   "This mode is incompatible with -txindex and -rescan. "
                   "Warning: Reverting this setting requires re-downloading the "
                   "entire blockchain. (default: 0 = disable pruning blocks, 1 "
                   "= allow manual pruning via RPC, >=%u = automatically prune "
                   "block files to stay under the specified target size in MiB)",
                   MIN_DISK_SPACE_FOR_BLOCK_FILES / 1024 / 1024),
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-reindex-chainstate",
                  "Rebuild chain state from the currently indexed blocks. When "
                  "in pruning mode or if blocks on disk might be corrupted, use "
                  "full -reindex instead.",
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg(
         "-reindex",
         "Rebuild chain state and block index from the blk*.dat files on disk",
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 #ifndef WIN32
     gArgs.AddArg(
         "-sysperms",
         "Create new files with system default permissions, instead of umask "
         "077 (only effective with disabled wallet functionality)",
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 #else
     hidden_args.emplace_back("-sysperms");
 #endif
     gArgs.AddArg("-txindex",
                  strprintf("Maintain a full transaction index, used by the "
                            "getrawtransaction rpc call (default: %d)",
                            DEFAULT_TXINDEX),
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-usecashaddr",
                  "Use Cash Address for destination encoding instead of base58 "
                  "(activate by default on Jan, 14)",
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 
     gArgs.AddArg("-addnode=<ip>",
                  "Add a node to connect to and attempt to keep the connection "
                  "open (see the `addnode` RPC command help for more info)",
                  ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY,
                  OptionsCategory::CONNECTION);
     gArgs.AddArg(
         "-banscore=<n>",
         strprintf("Threshold for disconnecting misbehaving peers (default: %u)",
                   DEFAULT_BANSCORE_THRESHOLD),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-bantime=<n>",
                  strprintf("Number of seconds to keep misbehaving peers from "
                            "reconnecting (default: %u)",
                            DEFAULT_MISBEHAVING_BANTIME),
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-bind=<addr>",
                  "Bind to given address and always listen on it. Use "
                  "[host]:port notation for IPv6",
                  ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY,
                  OptionsCategory::CONNECTION);
     gArgs.AddArg(
         "-connect=<ip>",
         "Connect only to the specified node(s); -connect=0 disables automatic "
         "connections (the rules for this peer are the same as for -addnode)",
         ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY,
         OptionsCategory::CONNECTION);
     gArgs.AddArg("-discover",
                  "Discover own IP addresses (default: 1 when listening and no "
                  "-externalip or -proxy)",
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-dns",
                  strprintf("Allow DNS lookups for -addnode, -seednode and "
                            "-connect (default: %d)",
                            DEFAULT_NAME_LOOKUP),
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-dnsseed",
                  "Query for peer addresses via DNS lookup, if low on addresses "
                  "(default: 1 unless -connect used)",
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-enablebip61",
                  strprintf("Send reject messages per BIP61 (default: %u)",
                            DEFAULT_ENABLE_BIP61),
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
 
     gArgs.AddArg("-externalip=<ip>", "Specify your own public address",
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg(
         "-forcednsseed",
         strprintf(
             "Always query for peer addresses via DNS lookup (default: %d)",
             DEFAULT_FORCEDNSSEED),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg(
         "-listen",
         "Accept connections from outside (default: 1 if no -proxy or -connect)",
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg(
         "-listenonion",
         strprintf("Automatically create Tor hidden service (default: %d)",
                   DEFAULT_LISTEN_ONION),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg(
         "-maxconnections=<n>",
         strprintf("Maintain at most <n> connections to peers (default: %u)",
                   DEFAULT_MAX_PEER_CONNECTIONS),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-maxreceivebuffer=<n>",
                  strprintf("Maximum per-connection receive buffer, <n>*1000 "
                            "bytes (default: %u)",
                            DEFAULT_MAXRECEIVEBUFFER),
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg(
         "-maxsendbuffer=<n>",
         strprintf(
             "Maximum per-connection send buffer, <n>*1000 bytes (default: %u)",
             DEFAULT_MAXSENDBUFFER),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg(
         "-maxtimeadjustment",
         strprintf("Maximum allowed median peer time offset adjustment. Local "
                   "perspective of time may be influenced by peers forward or "
                   "backward by this amount. (default: %u seconds)",
                   DEFAULT_MAX_TIME_ADJUSTMENT),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-onion=<ip:port>",
                  strprintf("Use separate SOCKS5 proxy to reach peers via Tor "
                            "hidden services (default: %s)",
                            "-proxy"),
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-onlynet=<net>",
                  "Only connect to nodes in network <net> (ipv4, ipv6 or onion)",
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-peerbloomfilters",
                  strprintf("Support filtering of blocks and transaction with "
                            "bloom filters (default: %d)",
                            DEFAULT_PEERBLOOMFILTERS),
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-permitbaremultisig",
                  strprintf("Relay non-P2SH multisig (default: %d)",
                            DEFAULT_PERMIT_BAREMULTISIG),
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-port=<port>",
                  strprintf("Listen for connections on <port> (default: %u, "
                            "testnet: %u, regtest: %u)",
                            defaultChainParams->GetDefaultPort(),
                            testnetChainParams->GetDefaultPort(),
                            regtestChainParams->GetDefaultPort()),
                  ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY,
                  OptionsCategory::CONNECTION);
     gArgs.AddArg("-proxy=<ip:port>", _("Connect through SOCKS5 proxy"),
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-proxyrandomize",
                  strprintf("Randomize credentials for every proxy connection. "
                            "This enables Tor stream isolation (default: %d)",
                            DEFAULT_PROXYRANDOMIZE),
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-seednode=<ip>",
                  "Connect to a node to retrieve peer addresses, and disconnect",
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-timeout=<n>",
                  strprintf("Specify connection timeout in milliseconds "
                            "(minimum: 1, default: %d)",
                            DEFAULT_CONNECT_TIMEOUT),
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg(
         "-torcontrol=<ip>:<port>",
         strprintf(
             "Tor control port to use if onion listening enabled (default: %s)",
             DEFAULT_TOR_CONTROL),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-torpassword=<pass>",
                  "Tor control port password (default: empty)",
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
 #ifdef USE_UPNP
 #if USE_UPNP
     gArgs.AddArg("-upnp",
                  "Use UPnP to map the listening port (default: 1 when "
                  "listening and no -proxy)",
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
 #else
     gArgs.AddArg(
         "-upnp",
         strprintf("Use UPnP to map the listening port (default: %u)", 0),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
 #endif
 #else
     hidden_args.emplace_back("-upnp");
 #endif
     gArgs.AddArg("-whitebind=<addr>",
                  "Bind to given address and whitelist peers connecting to it. "
                  "Use [host]:port notation for IPv6",
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-whitelist=<IP address or network>",
                  "Whitelist peers connecting from the given IP address (e.g. "
                  "1.2.3.4) or CIDR notated network (e.g. 1.2.3.0/24). Can be "
                  "specified multiple times. "
                  "Whitelisted peers cannot be DoS banned and their "
                  "transactions are always relayed, even if they are already in "
                  "the mempool, useful e.g. for a gateway",
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg(
         "-maxuploadtarget=<n>",
         strprintf("Tries to keep outbound traffic under the given target (in "
                   "MiB per 24h), 0 = no limit (default: %d)",
                   DEFAULT_MAX_UPLOAD_TARGET),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
 
     g_wallet_init_interface.AddWalletOptions();
 
 #if ENABLE_ZMQ
     gArgs.AddArg("-zmqpubhashblock=<address>",
                  "Enable publish hash block in <address>",
                  ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
     gArgs.AddArg("-zmqpubhashtx=<address>",
                  "Enable publish hash transaction in <address>",
                  ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
     gArgs.AddArg("-zmqpubrawblock=<address>",
                  "Enable publish raw block in <address>",
                  ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
     gArgs.AddArg("-zmqpubrawtx=<address>",
                  "Enable publish raw transaction in <address>",
                  ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
 #else
     hidden_args.emplace_back("-zmqpubhashblock=<address>");
     hidden_args.emplace_back("-zmqpubhashtx=<address>");
     hidden_args.emplace_back("-zmqpubrawblock=<address>");
     hidden_args.emplace_back("-zmqpubrawtx=<address>");
 #endif
 
     gArgs.AddArg(
         "-checkblocks=<n>",
         strprintf("How many blocks to check at startup (default: %u, 0 = all)",
                   DEFAULT_CHECKBLOCKS),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-checklevel=<n>",
         strprintf("How thorough the block verification of "
                   "-checkblocks is: "
                   "level 0 reads the blocks from disk, "
                   "level 1 verifies block validity, "
                   "level 2 verifies undo data, "
                   "level 3 checks disconnection of tip blocks, "
                   "and level 4 tries to reconnect the blocks. "
                   "Each level includes the checks of the previous levels "
                   "(0-4, default: %u)",
                   DEFAULT_CHECKLEVEL),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-checkblockindex",
         strprintf("Do a full consistency check for mapBlockIndex, "
                   "setBlockIndexCandidates, ::ChainActive() and "
                   "mapBlocksUnlinked occasionally. (default: %u, regtest: %u)",
                   defaultChainParams->DefaultConsistencyChecks(),
                   regtestChainParams->DefaultConsistencyChecks()),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-checkmempool=<n>",
         strprintf(
             "Run checks every <n> transactions (default: %u, regtest: %u)",
             defaultChainParams->DefaultConsistencyChecks(),
             regtestChainParams->DefaultConsistencyChecks()),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     gArgs.AddArg("-checkpoints",
                  strprintf("Only accept block chain matching built-in "
                            "checkpoints (default: %d)",
                            DEFAULT_CHECKPOINTS_ENABLED),
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::DEBUG_TEST);
     gArgs.AddArg("-deprecatedrpc=<method>",
                  "Allows deprecated RPC method(s) to be used",
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::DEBUG_TEST);
     gArgs.AddArg("-dropmessagestest=<n>",
                  "Randomly drop 1 of every <n> network messages",
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-stopafterblockimport",
         strprintf("Stop running after importing blocks from disk (default: %d)",
                   DEFAULT_STOPAFTERBLOCKIMPORT),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     gArgs.AddArg("-stopatheight",
                  strprintf("Stop running after reaching the given height in "
                            "the main chain (default: %u)",
                            DEFAULT_STOPATHEIGHT),
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::DEBUG_TEST);
     gArgs.AddArg("-limitancestorcount=<n>",
                  strprintf("Do not accept transactions if number of in-mempool "
                            "ancestors is <n> or more (pre-phonon-upgrade "
                            "default: %u, post-phonon-upgrade default: %u)",
                            DEFAULT_ANCESTOR_LIMIT,
                            DEFAULT_ANCESTOR_LIMIT_LONGER),
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-limitancestorsize=<n>",
         strprintf("Do not accept transactions whose size with all in-mempool "
                   "ancestors exceeds <n> kilobytes (default: %u)",
                   DEFAULT_ANCESTOR_SIZE_LIMIT),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-limitdescendantcount=<n>",
         strprintf("Do not accept transactions if any ancestor would have <n> "
                   "or more in-mempool descendants (default pre-phonon-upgrade: "
                   "%u, default post-phonon-upgrade: %u)",
                   DEFAULT_DESCENDANT_LIMIT, DEFAULT_DESCENDANT_LIMIT_LONGER),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-limitdescendantsize=<n>",
         strprintf("Do not accept transactions if any ancestor would have more "
                   "than <n> kilobytes of in-mempool descendants (default: %u).",
                   DEFAULT_DESCENDANT_SIZE_LIMIT),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     gArgs.AddArg("-addrmantest", "Allows to test address relay on localhost",
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::DEBUG_TEST);
 
     gArgs.AddArg("-debug=<category>",
                  strprintf("Output debugging information (default: %u, "
                            "supplying <category> is optional)",
                            0) +
                      ". " +
                      "If <category> is not supplied or if <category> = 1, "
                      "output all debugging information."
                      "<category> can be: " +
                      ListLogCategories() + ".",
                  ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-debugexclude=<category>",
         strprintf("Exclude debugging information for a category. Can be used "
                   "in conjunction with -debug=1 to output debug logs for all "
                   "categories except one or more specified categories."),
         ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
     gArgs.AddArg("-help-debug",
                  "Print help message with debugging options and exit",
                  ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
     gArgs.AddArg("-logips",
                  strprintf("Include IP addresses in debug output (default: %d)",
                            DEFAULT_LOGIPS),
                  ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
     gArgs.AddArg("-logtimestamps",
                  strprintf("Prepend debug output with timestamp (default: %d)",
                            DEFAULT_LOGTIMESTAMPS),
                  ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-logthreadnames",
         strprintf(
             "Prepend debug output with name of the originating thread (only "
             "available on platforms supporting thread_local) (default: %u)",
             DEFAULT_LOGTHREADNAMES),
         ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-logtimemicros",
         strprintf("Add microsecond precision to debug timestamps (default: %d)",
                   DEFAULT_LOGTIMEMICROS),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-mocktime=<n>",
         "Replace actual time with <n> seconds since epoch (default: 0)",
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-maxsigcachesize=<n>",
         strprintf("Limit size of signature cache to <n> MiB (default: %u)",
                   DEFAULT_MAX_SIG_CACHE_SIZE),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-maxscriptcachesize=<n>",
         strprintf("Limit size of script cache to <n> MiB (default: %u)",
                   DEFAULT_MAX_SCRIPT_CACHE_SIZE),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     gArgs.AddArg("-maxtipage=<n>",
                  strprintf("Maximum tip age in seconds to consider node in "
                            "initial block download (default: %u)",
                            DEFAULT_MAX_TIP_AGE),
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::DEBUG_TEST);
 
     gArgs.AddArg(
         "-printtoconsole",
         "Send trace/debug info to console instead of debug.log file (default: "
         "1 when no -daemon. To disable logging to file, set debuglogfile=0)",
         ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
     gArgs.AddArg("-printpriority",
                  strprintf("Log transaction priority and fee per kB when "
                            "mining blocks (default: %d)",
                            DEFAULT_PRINTPRIORITY),
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-shrinkdebugfile",
         "Shrink debug.log file on client startup (default: 1 when no -debug)",
         ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
 
     gArgs.AddArg("-uacomment=<cmt>", "Append comment to the user agent string",
                  ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
 
     SetupChainParamsBaseOptions();
 
     gArgs.AddArg(
         "-acceptnonstdtxn",
         strprintf(
             "Relay and mine \"non-standard\" transactions (%sdefault: %u)",
             "testnet/regtest only; ", defaultChainParams->RequireStandard()),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::NODE_RELAY);
     gArgs.AddArg("-excessiveblocksize=<n>",
                  strprintf("Do not accept blocks larger than this limit, in "
                            "bytes (default: %d)",
                            DEFAULT_MAX_BLOCK_SIZE),
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::NODE_RELAY);
     gArgs.AddArg(
         "-dustrelayfee=<amt>",
         strprintf("Fee rate (in %s/kB) used to defined dust, the value of an "
                   "output such that it will cost about 1/3 of its value in "
                   "fees at this fee rate to spend it. (default: %s)",
                   CURRENCY_UNIT, FormatMoney(DUST_RELAY_TX_FEE)),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::NODE_RELAY);
 
     gArgs.AddArg("-bytespersigop",
                  strprintf("Equivalent bytes per sigop in transactions for "
                            "relay and mining (default: %u)",
                            DEFAULT_BYTES_PER_SIGOP),
                  ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
     gArgs.AddArg(
         "-datacarrier",
         strprintf("Relay and mine data carrier transactions (default: %d)",
                   DEFAULT_ACCEPT_DATACARRIER),
         ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
     gArgs.AddArg("-datacarriersize",
                  strprintf("Maximum size of data in data carrier transactions "
                            "we relay and mine (default: %u)",
                            MAX_OP_RETURN_RELAY),
                  ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
     gArgs.AddArg(
         "-minrelaytxfee=<amt>",
         strprintf("Fees (in %s/kB) smaller than this are rejected for "
                   "relaying, mining and transaction creation (default: %s)",
                   CURRENCY_UNIT, FormatMoney(DEFAULT_MIN_RELAY_TX_FEE_PER_KB)),
         ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
     gArgs.AddArg(
         "-whitelistrelay",
         strprintf(_("Accept relayed transactions received from whitelisted "
                     "peers even when not relaying transactions (default: %d)"),
                   DEFAULT_WHITELISTRELAY),
         ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
     gArgs.AddArg(
         "-whitelistforcerelay",
         strprintf("Force relay of transactions from whitelisted peers even if "
                   "they violate local relay policy (default: %d)",
                   DEFAULT_WHITELISTFORCERELAY),
         ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
 
     // Not sure this really belongs here, but it will do for now.
     // FIXME: This doesn't work anyways.
     gArgs.AddArg("-excessutxocharge=<amt>",
                  strprintf("Fees (in %s/kB) to charge per utxo created for "
                            "relaying, and mining (default: %s)",
                            CURRENCY_UNIT, FormatMoney(DEFAULT_UTXO_FEE)),
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::NODE_RELAY);
 
     gArgs.AddArg("-blockmaxsize=<n>",
                  strprintf("Set maximum block size in bytes (default: %d)",
                            DEFAULT_MAX_GENERATED_BLOCK_SIZE),
                  ArgsManager::ALLOW_ANY, OptionsCategory::BLOCK_CREATION);
     gArgs.AddArg("-blockmintxfee=<amt>",
                  strprintf("Set lowest fee rate (in %s/kB) for transactions to "
                            "be included in block creation. (default: %s)",
                            CURRENCY_UNIT,
                            FormatMoney(DEFAULT_BLOCK_MIN_TX_FEE_PER_KB)),
                  ArgsManager::ALLOW_ANY, OptionsCategory::BLOCK_CREATION);
 
     gArgs.AddArg("-blockversion=<n>",
                  "Override block version to test forking scenarios",
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::BLOCK_CREATION);
 
     gArgs.AddArg("-server", "Accept command line and JSON-RPC commands",
                  ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     gArgs.AddArg("-rest",
                  strprintf("Accept public REST requests (default: %d)",
                            DEFAULT_REST_ENABLE),
                  ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     gArgs.AddArg(
         "-rpcbind=<addr>[:port]",
         "Bind to given address to listen for JSON-RPC connections. This option "
         "is ignored unless -rpcallowip is also passed. Port is optional and "
         "overrides -rpcport. Use [host]:port notation for IPv6. This option "
         "can be specified multiple times (default: 127.0.0.1 and ::1 i.e., "
         "localhost, or if -rpcallowip has been specified, 0.0.0.0 and :: i.e., "
         "all addresses)",
         ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY,
         OptionsCategory::RPC);
     gArgs.AddArg("-rpccookiefile=<loc>",
                  "Location of the auth cookie. Relative paths will be prefixed "
                  "by a net-specific datadir location. (default: data dir)",
                  ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     gArgs.AddArg("-rpcuser=<user>", _("Username for JSON-RPC connections"),
                  ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     gArgs.AddArg("-rpcpassword=<pw>", _("Password for JSON-RPC connections"),
                  ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     gArgs.AddArg(
         "-rpcauth=<userpw>",
         "Username and hashed password for JSON-RPC connections. The field "
         "<userpw> comes in the format: <USERNAME>:<SALT>$<HASH>. A canonical "
         "python script is included in share/rpcauth. The client then connects "
         "normally using the rpcuser=<USERNAME>/rpcpassword=<PASSWORD> pair of "
         "arguments. This option can be specified multiple times",
         ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     gArgs.AddArg("-rpcport=<port>",
                  strprintf("Listen for JSON-RPC connections on <port> "
                            "(default: %u, testnet: %u, regtest: %u)",
                            defaultBaseParams->RPCPort(),
                            testnetBaseParams->RPCPort(),
                            regtestBaseParams->RPCPort()),
                  ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY,
                  OptionsCategory::RPC);
     gArgs.AddArg("-rpcallowip=<ip>",
                  "Allow JSON-RPC connections from specified source. Valid for "
                  "<ip> are a single IP (e.g. 1.2.3.4), a network/netmask (e.g. "
                  "1.2.3.4/255.255.255.0) or a network/CIDR (e.g. 1.2.3.4/24). "
                  "This option can be specified multiple times",
                  ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     gArgs.AddArg(
         "-rpcthreads=<n>",
         strprintf(
             "Set the number of threads to service RPC calls (default: %d)",
             DEFAULT_HTTP_THREADS),
         ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     gArgs.AddArg(
         "-rpccorsdomain=value",
         "Domain from which to accept cross origin requests (browser enforced)",
         ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
 
     gArgs.AddArg("-rpcworkqueue=<n>",
                  strprintf("Set the depth of the work queue to service RPC "
                            "calls (default: %d)",
                            DEFAULT_HTTP_WORKQUEUE),
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::RPC);
     gArgs.AddArg("-rpcservertimeout=<n>",
                  strprintf("Timeout during HTTP requests (default: %d)",
                            DEFAULT_HTTP_SERVER_TIMEOUT),
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::RPC);
 
 #if HAVE_DECL_DAEMON
     gArgs.AddArg("-daemon",
                  _("Run in the background as a daemon and accept commands"),
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 #else
     hidden_args.emplace_back("-daemon");
 #endif
 
     // Avalanche options.
     gArgs.AddArg(
         "-enableavalanche",
         strprintf("Enable avalanche (default: %u)", AVALANCHE_DEFAULT_ENABLED),
         ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
     gArgs.AddArg(
         "-avacooldown",
         strprintf("Mandatory cooldown between two avapoll (default: %u)",
                   AVALANCHE_DEFAULT_COOLDOWN),
         ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
 
     // Add the hidden options
     gArgs.AddHiddenArgs(hidden_args);
 }
 
 std::string LicenseInfo() {
     const std::string URL_SOURCE_CODE =
         "<https://github.com/Bitcoin-ABC/bitcoin-abc>";
     const std::string URL_WEBSITE = "<https://www.bitcoinabc.org>";
 
     return CopyrightHolders(
                strprintf(_("Copyright (C) %i-%i"), 2009, COPYRIGHT_YEAR) +
                " ") +
            "\n" + "\n" +
            strprintf(_("Please contribute if you find %s useful. "
                        "Visit %s for further information about the software."),
                      PACKAGE_NAME, URL_WEBSITE) +
            "\n" +
            strprintf(_("The source code is available from %s."),
                      URL_SOURCE_CODE) +
            "\n" + "\n" + _("This is experimental software.") + "\n" +
            strprintf(_("Distributed under the MIT software license, see the "
                        "accompanying file %s or %s"),
                      "COPYING", "<https://opensource.org/licenses/MIT>") +
            "\n" + "\n" +
            strprintf(_("This product includes software developed by the "
                        "OpenSSL Project for use in the OpenSSL Toolkit %s and "
                        "cryptographic software written by Eric Young and UPnP "
                        "software written by Thomas Bernard."),
                      "<https://www.openssl.org>") +
            "\n";
 }
 
 static void BlockNotifyCallback(bool initialSync,
                                 const CBlockIndex *pBlockIndex) {
     if (initialSync || !pBlockIndex) {
         return;
     }
 
     std::string strCmd = gArgs.GetArg("-blocknotify", "");
     if (!strCmd.empty()) {
         boost::replace_all(strCmd, "%s", pBlockIndex->GetBlockHash().GetHex());
         std::thread t(runCommand, strCmd);
         // thread runs free
         t.detach();
     }
 }
 
 static bool fHaveGenesis = false;
 static Mutex g_genesis_wait_mutex;
 static std::condition_variable g_genesis_wait_cv;
 
 static void BlockNotifyGenesisWait(bool, const CBlockIndex *pBlockIndex) {
     if (pBlockIndex != nullptr) {
         {
             LOCK(g_genesis_wait_mutex);
             fHaveGenesis = true;
         }
         g_genesis_wait_cv.notify_all();
     }
 }
 
 struct CImportingNow {
     CImportingNow() {
         assert(fImporting == false);
         fImporting = true;
     }
 
     ~CImportingNow() {
         assert(fImporting == true);
         fImporting = false;
     }
 };
 
 // If we're using -prune with -reindex, then delete block files that will be
 // ignored by the reindex.  Since reindexing works by starting at block file 0
 // and looping until a blockfile is missing, do the same here to delete any
 // later block files after a gap. Also delete all rev files since they'll be
 // rewritten by the reindex anyway. This ensures that vinfoBlockFile is in sync
 // with what's actually on disk by the time we start downloading, so that
 // pruning works correctly.
 static void CleanupBlockRevFiles() {
     std::map<std::string, fs::path> mapBlockFiles;
 
     // Glob all blk?????.dat and rev?????.dat files from the blocks directory.
     // Remove the rev files immediately and insert the blk file paths into an
     // ordered map keyed by block file index.
     LogPrintf("Removing unusable blk?????.dat and rev?????.dat files for "
               "-reindex with -prune\n");
     const auto directoryIterator = fs::directory_iterator{GetBlocksDir()};
     for (const auto &file : directoryIterator) {
         const auto fileName = file.path().filename().string();
         if (fs::is_regular_file(file) && fileName.length() == 12 &&
             fileName.substr(8, 4) == ".dat") {
             if (fileName.substr(0, 3) == "blk") {
                 mapBlockFiles[fileName.substr(3, 5)] = file.path();
             } else if (fileName.substr(0, 3) == "rev") {
                 remove(file.path());
             }
         }
     }
 
     // Remove all block files that aren't part of a contiguous set starting at
     // zero by walking the ordered map (keys are block file indices) by keeping
     // a separate counter. Once we hit a gap (or if 0 doesn't exist) start
     // removing block files.
     int contiguousCounter = 0;
     for (const auto &item : mapBlockFiles) {
         if (atoi(item.first) == contiguousCounter) {
             contiguousCounter++;
             continue;
         }
         remove(item.second);
     }
 }
 
 static void ThreadImport(const Config &config,
                          std::vector<fs::path> vImportFiles) {
     util::ThreadRename("loadblk");
     ScheduleBatchPriority();
 
     {
         CImportingNow imp;
 
         // -reindex
         if (fReindex) {
             int nFile = 0;
             while (true) {
                 FlatFilePos pos(nFile, 0);
                 if (!fs::exists(GetBlockPosFilename(pos))) {
                     // No block files left to reindex
                     break;
                 }
                 FILE *file = OpenBlockFile(pos, true);
                 if (!file) {
                     // This error is logged in OpenBlockFile
                     break;
                 }
                 LogPrintf("Reindexing block file blk%05u.dat...\n",
                           (unsigned int)nFile);
                 LoadExternalBlockFile(config, file, &pos);
                 nFile++;
             }
             pblocktree->WriteReindexing(false);
             fReindex = false;
             LogPrintf("Reindexing finished\n");
             // To avoid ending up in a situation without genesis block, re-try
             // initializing (no-op if reindexing worked):
             LoadGenesisBlock(config.GetChainParams());
         }
 
         // hardcoded $DATADIR/bootstrap.dat
         fs::path pathBootstrap = GetDataDir() / "bootstrap.dat";
         if (fs::exists(pathBootstrap)) {
             FILE *file = fsbridge::fopen(pathBootstrap, "rb");
             if (file) {
                 fs::path pathBootstrapOld = GetDataDir() / "bootstrap.dat.old";
                 LogPrintf("Importing bootstrap.dat...\n");
                 LoadExternalBlockFile(config, file);
                 RenameOver(pathBootstrap, pathBootstrapOld);
             } else {
                 LogPrintf("Warning: Could not open bootstrap file %s\n",
                           pathBootstrap.string());
             }
         }
 
         // -loadblock=
         for (const fs::path &path : vImportFiles) {
             FILE *file = fsbridge::fopen(path, "rb");
             if (file) {
                 LogPrintf("Importing blocks file %s...\n", path.string());
                 LoadExternalBlockFile(config, file);
             } else {
                 LogPrintf("Warning: Could not open blocks file %s\n",
                           path.string());
             }
         }
 
         // scan for better chains in the block chain database, that are not yet
         // connected in the active best chain
         CValidationState state;
         if (!ActivateBestChain(config, state)) {
             LogPrintf("Failed to connect best block (%s)\n",
                       FormatStateMessage(state));
             StartShutdown();
             return;
         }
 
         if (gArgs.GetBoolArg("-stopafterblockimport",
                              DEFAULT_STOPAFTERBLOCKIMPORT)) {
             LogPrintf("Stopping after block import\n");
             StartShutdown();
             return;
         }
     } // End scope of CImportingNow
     if (gArgs.GetArg("-persistmempool", DEFAULT_PERSIST_MEMPOOL)) {
         LoadMempool(config, ::g_mempool);
     }
     ::g_mempool.SetIsLoaded(!ShutdownRequested());
 }
 
 /** Sanity checks
  *  Ensure that Bitcoin is running in a usable environment with all
  *  necessary library support.
  */
 static bool InitSanityCheck() {
     if (!ECC_InitSanityCheck()) {
         InitError(
             "Elliptic curve cryptography sanity check failure. Aborting.");
         return false;
     }
 
     if (!glibc_sanity_test() || !glibcxx_sanity_test()) {
         return false;
     }
 
     if (!Random_SanityCheck()) {
         InitError("OS cryptographic RNG sanity check failure. Aborting.");
         return false;
     }
 
     return true;
 }
 
 static bool AppInitServers(Config &config,
                            HTTPRPCRequestProcessor &httpRPCRequestProcessor) {
     RPCServerSignals::OnStarted(&OnRPCStarted);
     RPCServerSignals::OnStopped(&OnRPCStopped);
     if (!InitHTTPServer(config)) {
         return false;
     }
 
     StartRPC();
 
     if (!StartHTTPRPC(config, httpRPCRequestProcessor)) {
         return false;
     }
     if (gArgs.GetBoolArg("-rest", DEFAULT_REST_ENABLE)) {
         StartREST();
     }
 
     StartHTTPServer();
     return true;
 }
 
 // Parameter interaction based on rules
 void InitParameterInteraction() {
     // when specifying an explicit binding address, you want to listen on it
     // even when -connect or -proxy is specified.
     if (gArgs.IsArgSet("-bind")) {
         if (gArgs.SoftSetBoolArg("-listen", true)) {
             LogPrintf(
                 "%s: parameter interaction: -bind set -> setting -listen=1\n",
                 __func__);
         }
     }
     if (gArgs.IsArgSet("-whitebind")) {
         if (gArgs.SoftSetBoolArg("-listen", true)) {
             LogPrintf("%s: parameter interaction: -whitebind set -> setting "
                       "-listen=1\n",
                       __func__);
         }
     }
 
     if (gArgs.IsArgSet("-connect")) {
         // when only connecting to trusted nodes, do not seed via DNS, or listen
         // by default.
         if (gArgs.SoftSetBoolArg("-dnsseed", false)) {
             LogPrintf("%s: parameter interaction: -connect set -> setting "
                       "-dnsseed=0\n",
                       __func__);
         }
         if (gArgs.SoftSetBoolArg("-listen", false)) {
             LogPrintf("%s: parameter interaction: -connect set -> setting "
                       "-listen=0\n",
                       __func__);
         }
     }
 
     if (gArgs.IsArgSet("-proxy")) {
         // to protect privacy, do not listen by default if a default proxy
         // server is specified.
         if (gArgs.SoftSetBoolArg("-listen", false)) {
             LogPrintf(
                 "%s: parameter interaction: -proxy set -> setting -listen=0\n",
                 __func__);
         }
         // to protect privacy, do not use UPNP when a proxy is set. The user may
         // still specify -listen=1 to listen locally, so don't rely on this
         // happening through -listen below.
         if (gArgs.SoftSetBoolArg("-upnp", false)) {
             LogPrintf(
                 "%s: parameter interaction: -proxy set -> setting -upnp=0\n",
                 __func__);
         }
         // to protect privacy, do not discover addresses by default
         if (gArgs.SoftSetBoolArg("-discover", false)) {
             LogPrintf("%s: parameter interaction: -proxy set -> setting "
                       "-discover=0\n",
                       __func__);
         }
     }
 
     if (!gArgs.GetBoolArg("-listen", DEFAULT_LISTEN)) {
         // do not map ports or try to retrieve public IP when not listening
         // (pointless)
         if (gArgs.SoftSetBoolArg("-upnp", false)) {
             LogPrintf(
                 "%s: parameter interaction: -listen=0 -> setting -upnp=0\n",
                 __func__);
         }
         if (gArgs.SoftSetBoolArg("-discover", false)) {
             LogPrintf(
                 "%s: parameter interaction: -listen=0 -> setting -discover=0\n",
                 __func__);
         }
         if (gArgs.SoftSetBoolArg("-listenonion", false)) {
             LogPrintf("%s: parameter interaction: -listen=0 -> setting "
                       "-listenonion=0\n",
                       __func__);
         }
     }
 
     if (gArgs.IsArgSet("-externalip")) {
         // if an explicit public IP is specified, do not try to find others
         if (gArgs.SoftSetBoolArg("-discover", false)) {
             LogPrintf("%s: parameter interaction: -externalip set -> setting "
                       "-discover=0\n",
                       __func__);
         }
     }
 
     // disable whitelistrelay in blocksonly mode
     if (gArgs.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY)) {
         if (gArgs.SoftSetBoolArg("-whitelistrelay", false)) {
             LogPrintf("%s: parameter interaction: -blocksonly=1 -> setting "
                       "-whitelistrelay=0\n",
                       __func__);
         }
     }
 
     // Forcing relay from whitelisted hosts implies we will accept relays from
     // them in the first place.
     if (gArgs.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY)) {
         if (gArgs.SoftSetBoolArg("-whitelistrelay", true)) {
             LogPrintf("%s: parameter interaction: -whitelistforcerelay=1 -> "
                       "setting -whitelistrelay=1\n",
                       __func__);
         }
     }
 }
 
 static std::string ResolveErrMsg(const char *const optname,
                                  const std::string &strBind) {
     return strprintf(_("Cannot resolve -%s address: '%s'"), optname, strBind);
 }
 
 /**
  * Initialize global loggers.
  *
  * Note that this is called very early in the process lifetime, so you should be
  * careful about what global state you rely on here.
  */
 void InitLogging() {
     LogInstance().m_print_to_file = !gArgs.IsArgNegated("-debuglogfile");
     LogInstance().m_file_path = AbsPathForConfigVal(
         gArgs.GetArg("-debuglogfile", DEFAULT_DEBUGLOGFILE));
 
     LogInstance().m_print_to_console = gArgs.GetBoolArg(
         "-printtoconsole", !gArgs.GetBoolArg("-daemon", false));
     LogInstance().m_log_timestamps =
         gArgs.GetBoolArg("-logtimestamps", DEFAULT_LOGTIMESTAMPS);
     LogInstance().m_log_time_micros =
         gArgs.GetBoolArg("-logtimemicros", DEFAULT_LOGTIMEMICROS);
     LogInstance().m_log_threadnames =
         gArgs.GetBoolArg("-logthreadnames", DEFAULT_LOGTHREADNAMES);
 
     fLogIPs = gArgs.GetBoolArg("-logips", DEFAULT_LOGIPS);
 
     std::string version_string = FormatFullVersion();
 #ifdef DEBUG
     version_string += " (debug build)";
 #else
     version_string += " (release build)";
 #endif
     LogPrintf("%s version %s\n", CLIENT_NAME, version_string);
 }
 
 namespace { // Variables internal to initialization process only
 
 int nMaxConnections;
 int nUserMaxConnections;
 int nFD;
 ServiceFlags nLocalServices = ServiceFlags(NODE_NETWORK | NODE_NETWORK_LIMITED);
 } // namespace
 
 [[noreturn]] static void new_handler_terminate() {
     // Rather than throwing std::bad-alloc if allocation fails, terminate
     // immediately to (try to) avoid chain corruption. Since LogPrintf may
     // itself allocate memory, set the handler directly to terminate first.
     std::set_new_handler(std::terminate);
     LogPrintf("Error: Out of memory. Terminating.\n");
 
     // The log was successful, terminate now.
     std::terminate();
 };
 
 bool AppInitBasicSetup() {
 // Step 1: setup
 #ifdef _MSC_VER
     // Turn off Microsoft heap dump noise
     _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
     _CrtSetReportFile(_CRT_WARN, CreateFileA("NUL", GENERIC_WRITE, 0, nullptr,
                                              OPEN_EXISTING, 0, 0));
     // Disable confusing "helpful" text message on abort, Ctrl-C
     _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
 #endif
 #ifdef WIN32
 // Enable Data Execution Prevention (DEP)
 // Minimum supported OS versions: WinXP SP3, WinVista >= SP1, Win Server 2008
 // A failure is non-critical and needs no further attention!
 #ifndef PROCESS_DEP_ENABLE
 // We define this here, because GCCs winbase.h limits this to _WIN32_WINNT >=
 // 0x0601 (Windows 7), which is not correct. Can be removed, when GCCs winbase.h
 // is fixed!
 #define PROCESS_DEP_ENABLE 0x00000001
 #endif
     typedef BOOL(WINAPI * PSETPROCDEPPOL)(DWORD);
     PSETPROCDEPPOL setProcDEPPol = (PSETPROCDEPPOL)GetProcAddress(
         GetModuleHandleA("Kernel32.dll"), "SetProcessDEPPolicy");
     if (setProcDEPPol != nullptr) {
         setProcDEPPol(PROCESS_DEP_ENABLE);
     }
 #endif
 
     if (!SetupNetworking()) {
         return InitError("Initializing networking failed");
     }
 
 #ifndef WIN32
     if (!gArgs.GetBoolArg("-sysperms", false)) {
         umask(077);
     }
 
     // Clean shutdown on SIGTERM
     registerSignalHandler(SIGTERM, HandleSIGTERM);
     registerSignalHandler(SIGINT, HandleSIGTERM);
 
     // Reopen debug.log on SIGHUP
     registerSignalHandler(SIGHUP, HandleSIGHUP);
 
     // Ignore SIGPIPE, otherwise it will bring the daemon down if the client
     // closes unexpectedly
     signal(SIGPIPE, SIG_IGN);
 #else
     SetConsoleCtrlHandler(consoleCtrlHandler, true);
 #endif
 
     std::set_new_handler(new_handler_terminate);
 
     return true;
 }
 
 bool AppInitParameterInteraction(Config &config) {
     const CChainParams &chainparams = config.GetChainParams();
     // Step 2: parameter interactions
 
     // also see: InitParameterInteraction()
 
     // Warn if network-specific options (-addnode, -connect, etc) are
     // specified in default section of config file, but not overridden
     // on the command line or in this network's section of the config file.
     std::string network = gArgs.GetChainName();
     for (const auto &arg : gArgs.GetUnsuitableSectionOnlyArgs()) {
         return InitError(strprintf(_("Config setting for %s only applied on %s "
                                      "network when in [%s] section."),
                                    arg, network, network));
     }
 
     // Warn if unrecognized section name are present in the config file.
     for (const auto &section : gArgs.GetUnrecognizedSections()) {
         InitWarning(strprintf("%s:%i " + _("Section [%s] is not recognized."),
                               section.m_file, section.m_line, section.m_name));
     }
 
     if (!fs::is_directory(GetBlocksDir())) {
         return InitError(
             strprintf(_("Specified blocks directory \"%s\" does not exist."),
                       gArgs.GetArg("-blocksdir", "").c_str()));
     }
 
     // if using block pruning, then disallow txindex
     if (gArgs.GetArg("-prune", 0)) {
         if (gArgs.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
             return InitError(_("Prune mode is incompatible with -txindex."));
         }
     }
 
     // -bind and -whitebind can't be set when not listening
     size_t nUserBind =
         gArgs.GetArgs("-bind").size() + gArgs.GetArgs("-whitebind").size();
     if (nUserBind != 0 && !gArgs.GetBoolArg("-listen", DEFAULT_LISTEN)) {
         return InitError(
             "Cannot set -bind or -whitebind together with -listen=0");
     }
 
     // Make sure enough file descriptors are available
     int nBind = std::max(nUserBind, size_t(1));
     nUserMaxConnections =
         gArgs.GetArg("-maxconnections", DEFAULT_MAX_PEER_CONNECTIONS);
     nMaxConnections = std::max(nUserMaxConnections, 0);
 
     // Trim requested connection counts, to fit into system limitations
     nMaxConnections =
         std::max(std::min(nMaxConnections, FD_SETSIZE - nBind -
                                                MIN_CORE_FILEDESCRIPTORS -
                                                MAX_ADDNODE_CONNECTIONS),
                  0);
     nFD = RaiseFileDescriptorLimit(nMaxConnections + MIN_CORE_FILEDESCRIPTORS +
                                    MAX_ADDNODE_CONNECTIONS);
     if (nFD < MIN_CORE_FILEDESCRIPTORS) {
         return InitError(_("Not enough file descriptors available."));
     }
     nMaxConnections =
         std::min(nFD - MIN_CORE_FILEDESCRIPTORS - MAX_ADDNODE_CONNECTIONS,
                  nMaxConnections);
 
     if (nMaxConnections < nUserMaxConnections) {
         InitWarning(strprintf(_("Reducing -maxconnections from %d to %d, "
                                 "because of system limitations."),
                               nUserMaxConnections, nMaxConnections));
     }
 
     // Step 3: parameter-to-internal-flags
     if (gArgs.IsArgSet("-debug")) {
         // Special-case: if -debug=0/-nodebug is set, turn off debugging
         // messages
         const std::vector<std::string> &categories = gArgs.GetArgs("-debug");
         if (std::none_of(
                 categories.begin(), categories.end(),
                 [](std::string cat) { return cat == "0" || cat == "none"; })) {
             for (const auto &cat : categories) {
                 if (!LogInstance().EnableCategory(cat)) {
                     InitWarning(
                         strprintf(_("Unsupported logging category %s=%s."),
                                   "-debug", cat));
                 }
             }
         }
     }
 
     // Now remove the logging categories which were explicitly excluded
     for (const std::string &cat : gArgs.GetArgs("-debugexclude")) {
         if (!LogInstance().DisableCategory(cat)) {
             InitWarning(strprintf(_("Unsupported logging category %s=%s."),
                                   "-debugexclude", cat));
         }
     }
 
     // Checkmempool and checkblockindex default to true in regtest mode
     int ratio = std::min<int>(
         std::max<int>(
             gArgs.GetArg("-checkmempool",
                          chainparams.DefaultConsistencyChecks() ? 1 : 0),
             0),
         1000000);
     if (ratio != 0) {
         g_mempool.setSanityCheck(1.0 / ratio);
     }
     fCheckBlockIndex = gArgs.GetBoolArg("-checkblockindex",
                                         chainparams.DefaultConsistencyChecks());
     fCheckpointsEnabled =
         gArgs.GetBoolArg("-checkpoints", DEFAULT_CHECKPOINTS_ENABLED);
     if (fCheckpointsEnabled) {
         LogPrintf("Checkpoints will be verified.\n");
     } else {
         LogPrintf("Skipping checkpoint verification.\n");
     }
 
     hashAssumeValid = BlockHash::fromHex(
         gArgs.GetArg("-assumevalid",
                      chainparams.GetConsensus().defaultAssumeValid.GetHex()));
     if (!hashAssumeValid.IsNull()) {
         LogPrintf("Assuming ancestors of block %s have valid signatures.\n",
                   hashAssumeValid.GetHex());
     } else {
         LogPrintf("Validating signatures for all blocks.\n");
     }
 
     if (gArgs.IsArgSet("-minimumchainwork")) {
         const std::string minChainWorkStr =
             gArgs.GetArg("-minimumchainwork", "");
         if (!IsHexNumber(minChainWorkStr)) {
             return InitError(strprintf(
                 "Invalid non-hex (%s) minimum chain work value specified",
                 minChainWorkStr));
         }
         nMinimumChainWork = UintToArith256(uint256S(minChainWorkStr));
     } else {
         nMinimumChainWork =
             UintToArith256(chainparams.GetConsensus().nMinimumChainWork);
     }
     LogPrintf("Setting nMinimumChainWork=%s\n", nMinimumChainWork.GetHex());
     if (nMinimumChainWork <
         UintToArith256(chainparams.GetConsensus().nMinimumChainWork)) {
         LogPrintf("Warning: nMinimumChainWork set below default value of %s\n",
                   chainparams.GetConsensus().nMinimumChainWork.GetHex());
     }
 
     // mempool limits
     int64_t nMempoolSizeMax =
         gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000;
     int64_t nMempoolSizeMin =
         gArgs.GetArg("-limitdescendantsize", DEFAULT_DESCENDANT_SIZE_LIMIT) *
         1000 * 40;
     if (nMempoolSizeMax < 0 || nMempoolSizeMax < nMempoolSizeMin) {
         return InitError(strprintf(_("-maxmempool must be at least %d MB"),
                                    std::ceil(nMempoolSizeMin / 1000000.0)));
     }
 
     // -par=0 means autodetect, but nScriptCheckThreads==0 means no concurrency
     nScriptCheckThreads = gArgs.GetArg("-par", DEFAULT_SCRIPTCHECK_THREADS);
     if (nScriptCheckThreads <= 0) {
         nScriptCheckThreads += GetNumCores();
     }
     if (nScriptCheckThreads <= 1) {
         nScriptCheckThreads = 0;
     } else if (nScriptCheckThreads > MAX_SCRIPTCHECK_THREADS) {
         nScriptCheckThreads = MAX_SCRIPTCHECK_THREADS;
     }
 
     // Configure excessive block size.
     const uint64_t nProposedExcessiveBlockSize =
         gArgs.GetArg("-excessiveblocksize", DEFAULT_MAX_BLOCK_SIZE);
     if (!config.SetMaxBlockSize(nProposedExcessiveBlockSize)) {
         return InitError(
             _("Excessive block size must be > 1,000,000 bytes (1MB)"));
     }
 
     // Check blockmaxsize does not exceed maximum accepted block size.
     const uint64_t nProposedMaxGeneratedBlockSize =
         gArgs.GetArg("-blockmaxsize", DEFAULT_MAX_GENERATED_BLOCK_SIZE);
     if (nProposedMaxGeneratedBlockSize > config.GetMaxBlockSize()) {
         auto msg = _("Max generated block size (blockmaxsize) cannot exceed "
                      "the excessive block size (excessiveblocksize)");
         return InitError(msg);
     }
 
     // block pruning; get the amount of disk space (in MiB) to allot for block &
     // undo files
     int64_t nPruneArg = gArgs.GetArg("-prune", 0);
     if (nPruneArg < 0) {
         return InitError(
             _("Prune cannot be configured with a negative value."));
     }
     nPruneTarget = (uint64_t)nPruneArg * 1024 * 1024;
     if (nPruneArg == 1) {
         // manual pruning: -prune=1
         LogPrintf("Block pruning enabled.  Use RPC call "
                   "pruneblockchain(height) to manually prune block and undo "
                   "files.\n");
         nPruneTarget = std::numeric_limits<uint64_t>::max();
         fPruneMode = true;
     } else if (nPruneTarget) {
         if (nPruneTarget < MIN_DISK_SPACE_FOR_BLOCK_FILES) {
             return InitError(
                 strprintf(_("Prune configured below the minimum of %d MiB.  "
                             "Please use a higher number."),
                           MIN_DISK_SPACE_FOR_BLOCK_FILES / 1024 / 1024));
         }
         LogPrintf("Prune configured to target %uMiB on disk for block and undo "
                   "files.\n",
                   nPruneTarget / 1024 / 1024);
         fPruneMode = true;
     }
 
     nConnectTimeout = gArgs.GetArg("-timeout", DEFAULT_CONNECT_TIMEOUT);
     if (nConnectTimeout <= 0) {
         nConnectTimeout = DEFAULT_CONNECT_TIMEOUT;
     }
 
     // Obtain the amount to charge excess UTXO
     if (gArgs.IsArgSet("-excessutxocharge")) {
         Amount n = Amount::zero();
         auto parsed = ParseMoney(gArgs.GetArg("-excessutxocharge", ""), n);
         if (!parsed || Amount::zero() > n) {
             return InitError(AmountErrMsg(
                 "excessutxocharge", gArgs.GetArg("-excessutxocharge", "")));
         }
         config.SetExcessUTXOCharge(n);
     } else {
         config.SetExcessUTXOCharge(DEFAULT_UTXO_FEE);
     }
 
     if (gArgs.IsArgSet("-minrelaytxfee")) {
         Amount n = Amount::zero();
         auto parsed = ParseMoney(gArgs.GetArg("-minrelaytxfee", ""), n);
         if (!parsed || n == Amount::zero()) {
             return InitError(AmountErrMsg("minrelaytxfee",
                                           gArgs.GetArg("-minrelaytxfee", "")));
         }
         // High fee check is done afterward in WalletParameterInteraction()
         ::minRelayTxFee = CFeeRate(n);
     }
 
     // Sanity check argument for min fee for including tx in block
     // TODO: Harmonize which arguments need sanity checking and where that
     // happens.
     if (gArgs.IsArgSet("-blockmintxfee")) {
         Amount n = Amount::zero();
         if (!ParseMoney(gArgs.GetArg("-blockmintxfee", ""), n)) {
             return InitError(AmountErrMsg("blockmintxfee",
                                           gArgs.GetArg("-blockmintxfee", "")));
         }
     }
 
     // Feerate used to define dust.  Shouldn't be changed lightly as old
     // implementations may inadvertently create non-standard transactions.
     if (gArgs.IsArgSet("-dustrelayfee")) {
         Amount n = Amount::zero();
         auto parsed = ParseMoney(gArgs.GetArg("-dustrelayfee", ""), n);
         if (!parsed || Amount::zero() == n) {
             return InitError(AmountErrMsg("dustrelayfee",
                                           gArgs.GetArg("-dustrelayfee", "")));
         }
         dustRelayFee = CFeeRate(n);
     }
 
     fRequireStandard =
         !gArgs.GetBoolArg("-acceptnonstdtxn", !chainparams.RequireStandard());
-    if (chainparams.RequireStandard() && !fRequireStandard) {
+    if (!chainparams.IsTestChain() && !fRequireStandard) {
         return InitError(
             strprintf("acceptnonstdtxn is not currently supported for %s chain",
                       chainparams.NetworkIDString()));
     }
     nBytesPerSigOp = gArgs.GetArg("-bytespersigop", nBytesPerSigOp);
 
     if (!g_wallet_init_interface.ParameterInteraction()) {
         return false;
     }
 
     fIsBareMultisigStd =
         gArgs.GetBoolArg("-permitbaremultisig", DEFAULT_PERMIT_BAREMULTISIG);
     fAcceptDatacarrier =
         gArgs.GetBoolArg("-datacarrier", DEFAULT_ACCEPT_DATACARRIER);
 
     // Option to startup with mocktime set (used for regression testing):
     SetMockTime(gArgs.GetArg("-mocktime", 0)); // SetMockTime(0) is a no-op
 
     if (gArgs.GetBoolArg("-peerbloomfilters", DEFAULT_PEERBLOOMFILTERS)) {
         nLocalServices = ServiceFlags(nLocalServices | NODE_BLOOM);
     }
 
     // Signal Bitcoin Cash support.
     // TODO: remove some time after the hardfork when no longer needed
     // to differentiate the network nodes.
     nLocalServices = ServiceFlags(nLocalServices | NODE_BITCOIN_CASH);
 
     nMaxTipAge = gArgs.GetArg("-maxtipage", DEFAULT_MAX_TIP_AGE);
 
     return true;
 }
 
 static bool LockDataDirectory(bool probeOnly) {
     // Make sure only a single Bitcoin process is using the data directory.
     fs::path datadir = GetDataDir();
     if (!DirIsWritable(datadir)) {
         return InitError(strprintf(
             _("Cannot write to data directory '%s'; check permissions."),
             datadir.string()));
     }
     if (!LockDirectory(datadir, ".lock", probeOnly)) {
         return InitError(strprintf(_("Cannot obtain a lock on data directory "
                                      "%s. %s is probably already running."),
                                    datadir.string(), _(PACKAGE_NAME)));
     }
     return true;
 }
 
 bool AppInitSanityChecks() {
     // Step 4: sanity checks
 
     // Initialize elliptic curve code
     std::string sha256_algo = SHA256AutoDetect();
     LogPrintf("Using the '%s' SHA256 implementation\n", sha256_algo);
     RandomInit();
     ECC_Start();
     globalVerifyHandle.reset(new ECCVerifyHandle());
 
     // Sanity check
     if (!InitSanityCheck()) {
         return InitError(strprintf(
             _("Initialization sanity check failed. %s is shutting down."),
             _(PACKAGE_NAME)));
     }
 
     // Probe the data directory lock to give an early error message, if possible
     // We cannot hold the data directory lock here, as the forking for daemon()
     // hasn't yet happened, and a fork will cause weird behavior to it.
     return LockDataDirectory(true);
 }
 
 bool AppInitLockDataDirectory() {
     // After daemonization get the data directory lock again and hold on to it
     // until exit. This creates a slight window for a race condition to happen,
     // however this condition is harmless: it will at most make us exit without
     // printing a message to console.
     if (!LockDataDirectory(false)) {
         // Detailed error printed inside LockDataDirectory
         return false;
     }
     return true;
 }
 
 bool AppInitMain(Config &config, RPCServer &rpcServer,
                  HTTPRPCRequestProcessor &httpRPCRequestProcessor,
                  InitInterfaces &interfaces) {
     // Step 4a: application initialization
     const CChainParams &chainparams = config.GetChainParams();
 
     if (!CreatePidFile()) {
         // Detailed error printed inside CreatePidFile().
         return false;
     }
 
     BCLog::Logger &logger = LogInstance();
     if (logger.m_print_to_file) {
         if (gArgs.GetBoolArg("-shrinkdebugfile",
                              logger.DefaultShrinkDebugFile())) {
             // Do this first since it both loads a bunch of debug.log into
             // memory, and because this needs to happen before any other
             // debug.log printing.
             logger.ShrinkDebugFile();
         }
     }
 
     if (!logger.StartLogging()) {
         return InitError(strprintf("Could not open debug log file %s",
                                    logger.m_file_path.string()));
     }
 
     if (!logger.m_log_timestamps) {
         LogPrintf("Startup time: %s\n", FormatISO8601DateTime(GetTime()));
     }
     LogPrintf("Default data directory %s\n", GetDefaultDataDir().string());
     LogPrintf("Using data directory %s\n", GetDataDir().string());
     LogPrintf(
         "Using config file %s\n",
         GetConfigFile(gArgs.GetArg("-conf", BITCOIN_CONF_FILENAME)).string());
     LogPrintf("Using at most %i automatic connections (%i file descriptors "
               "available)\n",
               nMaxConnections, nFD);
 
     // Warn about relative -datadir path.
     if (gArgs.IsArgSet("-datadir") &&
         !fs::path(gArgs.GetArg("-datadir", "")).is_absolute()) {
         LogPrintf("Warning: relative datadir option '%s' specified, which will "
                   "be interpreted relative to the current working directory "
                   "'%s'. This is fragile, because if bitcoin is started in the "
                   "future from a different location, it will be unable to "
                   "locate the current data files. There could also be data "
                   "loss if bitcoin is started while in a temporary "
                   "directory.\n",
                   gArgs.GetArg("-datadir", ""), fs::current_path().string());
     }
 
     InitSignatureCache();
     InitScriptExecutionCache();
 
     LogPrintf("Using %u threads for script verification\n",
               nScriptCheckThreads);
     if (nScriptCheckThreads) {
         for (int i = 0; i < nScriptCheckThreads - 1; i++) {
             threadGroup.create_thread([i]() { return ThreadScriptCheck(i); });
         }
     }
 
     // Start the lightweight task scheduler thread
     CScheduler::Function serviceLoop =
         std::bind(&CScheduler::serviceQueue, &scheduler);
     threadGroup.create_thread(std::bind(&TraceThread<CScheduler::Function>,
                                         "scheduler", serviceLoop));
 
     GetMainSignals().RegisterBackgroundSignalScheduler(scheduler);
     GetMainSignals().RegisterWithMempoolSignals(g_mempool);
 
     // Create client interfaces for wallets that are supposed to be loaded
     // according to -wallet and -disablewallet options. This only constructs
     // the interfaces, it doesn't load wallet data. Wallets actually get loaded
     // when load() and start() interface methods are called below.
     g_wallet_init_interface.Construct(interfaces);
 
     /**
      * Register RPC commands regardless of -server setting so they will be
      * available in the GUI RPC console even if external calls are disabled.
      */
     RegisterAllRPCCommands(config, rpcServer, tableRPC);
     for (const auto &client : interfaces.chain_clients) {
         client->registerRpcs();
     }
     g_rpc_interfaces = &interfaces;
 #if ENABLE_ZMQ
     RegisterZMQRPCCommands(tableRPC);
 #endif
 
     /**
      * Start the RPC server.  It will be started in "warmup" mode and not
      * process calls yet (but it will verify that the server is there and will
      * be ready later).  Warmup mode will be completed when initialisation is
      * finished.
      */
     if (gArgs.GetBoolArg("-server", false)) {
         uiInterface.InitMessage_connect(SetRPCWarmupStatus);
         if (!AppInitServers(config, httpRPCRequestProcessor)) {
             return InitError(
                 _("Unable to start HTTP server. See debug log for details."));
         }
     }
 
     // Step 5: verify wallet database integrity
     for (const auto &client : interfaces.chain_clients) {
         if (!client->verify(chainparams)) {
             return false;
         }
     }
 
     // Step 6: network initialization
 
     // Note that we absolutely cannot open any actual connections
     // until the very end ("start node") as the UTXO/block state
     // is not yet setup and may end up being set up twice if we
     // need to reindex later.
 
     assert(!g_banman);
     g_banman = std::make_unique<BanMan>(
         GetDataDir() / "banlist.dat", config.GetChainParams(), &uiInterface,
         gArgs.GetArg("-bantime", DEFAULT_MISBEHAVING_BANTIME));
     assert(!g_connman);
     g_connman = std::make_unique<CConnman>(
         config, GetRand(std::numeric_limits<uint64_t>::max()),
         GetRand(std::numeric_limits<uint64_t>::max()));
 
     peerLogic = std::make_unique<PeerLogicValidation>(
         g_connman.get(), g_banman.get(), scheduler,
         gArgs.GetBoolArg("-enablebip61", DEFAULT_ENABLE_BIP61));
     RegisterValidationInterface(peerLogic.get());
 
     // sanitize comments per BIP-0014, format user agent and check total size
     std::vector<std::string> uacomments;
     for (const std::string &cmt : gArgs.GetArgs("-uacomment")) {
         if (cmt != SanitizeString(cmt, SAFE_CHARS_UA_COMMENT)) {
             return InitError(strprintf(
                 _("User Agent comment (%s) contains unsafe characters."), cmt));
         }
         uacomments.push_back(cmt);
     }
     const std::string strSubVersion =
         FormatSubVersion(CLIENT_NAME, CLIENT_VERSION, uacomments);
     if (strSubVersion.size() > MAX_SUBVERSION_LENGTH) {
         return InitError(strprintf(
             _("Total length of network version string (%i) exceeds maximum "
               "length (%i). Reduce the number or size of uacomments."),
             strSubVersion.size(), MAX_SUBVERSION_LENGTH));
     }
 
     if (gArgs.IsArgSet("-onlynet")) {
         std::set<enum Network> nets;
         for (const std::string &snet : gArgs.GetArgs("-onlynet")) {
             enum Network net = ParseNetwork(snet);
             if (net == NET_UNROUTABLE) {
                 return InitError(strprintf(
                     _("Unknown network specified in -onlynet: '%s'"), snet));
             }
             nets.insert(net);
         }
         for (int n = 0; n < NET_MAX; n++) {
             enum Network net = (enum Network)n;
             if (!nets.count(net)) {
                 SetReachable(net, false);
             }
         }
     }
 
     // Check for host lookup allowed before parsing any network related
     // parameters
     fNameLookup = gArgs.GetBoolArg("-dns", DEFAULT_NAME_LOOKUP);
 
     bool proxyRandomize =
         gArgs.GetBoolArg("-proxyrandomize", DEFAULT_PROXYRANDOMIZE);
     // -proxy sets a proxy for all outgoing network traffic
     // -noproxy (or -proxy=0) as well as the empty string can be used to not set
     // a proxy, this is the default
     std::string proxyArg = gArgs.GetArg("-proxy", "");
     SetReachable(NET_ONION, false);
     if (proxyArg != "" && proxyArg != "0") {
         CService proxyAddr;
         if (!Lookup(proxyArg.c_str(), proxyAddr, 9050, fNameLookup)) {
             return InitError(strprintf(
                 _("Invalid -proxy address or hostname: '%s'"), proxyArg));
         }
 
         proxyType addrProxy = proxyType(proxyAddr, proxyRandomize);
         if (!addrProxy.IsValid()) {
             return InitError(strprintf(
                 _("Invalid -proxy address or hostname: '%s'"), proxyArg));
         }
 
         SetProxy(NET_IPV4, addrProxy);
         SetProxy(NET_IPV6, addrProxy);
         SetProxy(NET_ONION, addrProxy);
         SetNameProxy(addrProxy);
         // by default, -proxy sets onion as reachable, unless -noonion later
         SetReachable(NET_ONION, true);
     }
 
     // -onion can be used to set only a proxy for .onion, or override normal
     // proxy for .onion addresses.
     // -noonion (or -onion=0) disables connecting to .onion entirely. An empty
     // string is used to not override the onion proxy (in which case it defaults
     // to -proxy set above, or none)
     std::string onionArg = gArgs.GetArg("-onion", "");
     if (onionArg != "") {
         if (onionArg == "0") {
             // Handle -noonion/-onion=0
             SetReachable(NET_ONION, false);
         } else {
             CService onionProxy;
             if (!Lookup(onionArg.c_str(), onionProxy, 9050, fNameLookup)) {
                 return InitError(strprintf(
                     _("Invalid -onion address or hostname: '%s'"), onionArg));
             }
             proxyType addrOnion = proxyType(onionProxy, proxyRandomize);
             if (!addrOnion.IsValid()) {
                 return InitError(strprintf(
                     _("Invalid -onion address or hostname: '%s'"), onionArg));
             }
             SetProxy(NET_ONION, addrOnion);
             SetReachable(NET_ONION, true);
         }
     }
 
     // see Step 2: parameter interactions for more information about these
     fListen = gArgs.GetBoolArg("-listen", DEFAULT_LISTEN);
     fDiscover = gArgs.GetBoolArg("-discover", true);
     fRelayTxes = !gArgs.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY);
 
     for (const std::string &strAddr : gArgs.GetArgs("-externalip")) {
         CService addrLocal;
         if (Lookup(strAddr.c_str(), addrLocal, GetListenPort(), fNameLookup) &&
             addrLocal.IsValid()) {
             AddLocal(addrLocal, LOCAL_MANUAL);
         } else {
             return InitError(ResolveErrMsg("externalip", strAddr));
         }
     }
 
 #if ENABLE_ZMQ
     g_zmq_notification_interface = CZMQNotificationInterface::Create();
 
     if (g_zmq_notification_interface) {
         RegisterValidationInterface(g_zmq_notification_interface);
     }
 #endif
     // unlimited unless -maxuploadtarget is set
     uint64_t nMaxOutboundLimit = 0;
     uint64_t nMaxOutboundTimeframe = MAX_UPLOAD_TIMEFRAME;
 
     if (gArgs.IsArgSet("-maxuploadtarget")) {
         nMaxOutboundLimit =
             gArgs.GetArg("-maxuploadtarget", DEFAULT_MAX_UPLOAD_TARGET) * 1024 *
             1024;
     }
 
     // Step 6.5 (I guess ?): Initialize Avalanche.
     g_avalanche = std::make_unique<AvalancheProcessor>(g_connman.get());
 
     // Step 7: load block chain
 
     fReindex = gArgs.GetBoolArg("-reindex", false);
     bool fReindexChainState = gArgs.GetBoolArg("-reindex-chainstate", false);
 
     // cache size calculations
     int64_t nTotalCache = (gArgs.GetArg("-dbcache", nDefaultDbCache) << 20);
     // total cache cannot be less than nMinDbCache
     nTotalCache = std::max(nTotalCache, nMinDbCache << 20);
     // total cache cannot be greater than nMaxDbcache
     nTotalCache = std::min(nTotalCache, nMaxDbCache << 20);
     int64_t nBlockTreeDBCache =
         std::min(nTotalCache / 8, nMaxBlockDBCache << 20);
     nTotalCache -= nBlockTreeDBCache;
     int64_t nTxIndexCache =
         std::min(nTotalCache / 8, gArgs.GetBoolArg("-txindex", DEFAULT_TXINDEX)
                                       ? nMaxTxIndexCache << 20
                                       : 0);
     nTotalCache -= nTxIndexCache;
     // use 25%-50% of the remainder for disk cache
     int64_t nCoinDBCache =
         std::min(nTotalCache / 2, (nTotalCache / 4) + (1 << 23));
     // cap total coins db cache
     nCoinDBCache = std::min(nCoinDBCache, nMaxCoinsDBCache << 20);
     nTotalCache -= nCoinDBCache;
     // the rest goes to in-memory cache
     nCoinCacheUsage = nTotalCache;
     int64_t nMempoolSizeMax =
         gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000;
     LogPrintf("Cache configuration:\n");
     LogPrintf("* Using %.1fMiB for block index database\n",
               nBlockTreeDBCache * (1.0 / 1024 / 1024));
     if (gArgs.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
         LogPrintf("* Using %.1fMiB for transaction index database\n",
                   nTxIndexCache * (1.0 / 1024 / 1024));
     }
     LogPrintf("* Using %.1fMiB for chain state database\n",
               nCoinDBCache * (1.0 / 1024 / 1024));
     LogPrintf("* Using %.1fMiB for in-memory UTXO set (plus up to %.1fMiB of "
               "unused mempool space)\n",
               nCoinCacheUsage * (1.0 / 1024 / 1024),
               nMempoolSizeMax * (1.0 / 1024 / 1024));
 
     int64_t nStart = 0;
     bool fLoaded = false;
     while (!fLoaded && !ShutdownRequested()) {
         bool fReset = fReindex;
         std::string strLoadError;
 
         uiInterface.InitMessage(_("Loading block index..."));
         nStart = GetTimeMillis();
         do {
             try {
                 LOCK(cs_main);
                 UnloadBlockIndex();
                 pcoinsTip.reset();
                 pcoinsdbview.reset();
                 pcoinscatcher.reset();
                 pblocktree.reset(
                     new CBlockTreeDB(nBlockTreeDBCache, false, fReset));
 
                 if (fReset) {
                     pblocktree->WriteReindexing(true);
                     // If we're reindexing in prune mode, wipe away unusable
                     // block files and all undo data files
                     if (fPruneMode) {
                         CleanupBlockRevFiles();
                     }
                 }
 
                 if (ShutdownRequested()) {
                     break;
                 }
 
                 // LoadBlockIndex will load fHavePruned if we've ever removed a
                 // block file from disk.
                 // Note that it also sets fReindex based on the disk flag!
                 // From here on out fReindex and fReset mean something
                 // different!
                 if (!LoadBlockIndex(config)) {
                     strLoadError = _("Error loading block database");
                     break;
                 }
 
                 // If the loaded chain has a wrong genesis, bail out immediately
                 // (we're likely using a testnet datadir, or the other way
                 // around).
                 if (!mapBlockIndex.empty() &&
                     !LookupBlockIndex(
                         chainparams.GetConsensus().hashGenesisBlock)) {
                     return InitError(_("Incorrect or no genesis block found. "
                                        "Wrong datadir for network?"));
                 }
 
                 // Check for changed -prune state.  What we are concerned about
                 // is a user who has pruned blocks in the past, but is now
                 // trying to run unpruned.
                 if (fHavePruned && !fPruneMode) {
                     strLoadError =
                         _("You need to rebuild the database using -reindex to "
                           "go back to unpruned mode.  This will redownload the "
                           "entire blockchain");
                     break;
                 }
 
                 // At this point blocktree args are consistent with what's on
                 // disk. If we're not mid-reindex (based on disk + args), add a
                 // genesis block on disk (otherwise we use the one already on
                 // disk).
                 // This is called again in ThreadImport after the reindex
                 // completes.
                 if (!fReindex && !LoadGenesisBlock(chainparams)) {
                     strLoadError = _("Error initializing block database");
                     break;
                 }
 
                 // At this point we're either in reindex or we've loaded a
                 // useful block tree into mapBlockIndex!
 
                 pcoinsdbview.reset(new CCoinsViewDB(
                     nCoinDBCache, false, fReset || fReindexChainState));
                 pcoinscatcher.reset(
                     new CCoinsViewErrorCatcher(pcoinsdbview.get()));
 
                 // If necessary, upgrade from older database format.
                 // This is a no-op if we cleared the coinsviewdb with -reindex
                 // or -reindex-chainstate
                 if (!pcoinsdbview->Upgrade()) {
                     strLoadError = _("Error upgrading chainstate database");
                     break;
                 }
 
                 // ReplayBlocks is a no-op if we cleared the coinsviewdb with
                 // -reindex or -reindex-chainstate
                 if (!ReplayBlocks(chainparams.GetConsensus(),
                                   pcoinsdbview.get())) {
                     strLoadError =
                         _("Unable to replay blocks. You will need to rebuild "
                           "the database using -reindex-chainstate.");
                     break;
                 }
 
                 // The on-disk coinsdb is now in a good state, create the cache
                 pcoinsTip.reset(new CCoinsViewCache(pcoinscatcher.get()));
 
                 bool is_coinsview_empty = fReset || fReindexChainState ||
                                           pcoinsTip->GetBestBlock().IsNull();
                 if (!is_coinsview_empty) {
                     // LoadChainTip sets ::ChainActive() based on pcoinsTip's
                     // best block
                     if (!LoadChainTip(config)) {
                         strLoadError = _("Error initializing block database");
                         break;
                     }
                     assert(::ChainActive().Tip() != nullptr);
 
                     uiInterface.InitMessage(_("Verifying blocks..."));
                     if (fHavePruned &&
                         gArgs.GetArg("-checkblocks", DEFAULT_CHECKBLOCKS) >
                             MIN_BLOCKS_TO_KEEP) {
                         LogPrintf(
                             "Prune: pruned datadir may not have more than %d "
                             "blocks; only checking available blocks\n",
                             MIN_BLOCKS_TO_KEEP);
                     }
 
                     CBlockIndex *tip = ::ChainActive().Tip();
                     RPCNotifyBlockChange(true, tip);
                     if (tip && tip->nTime >
                                    GetAdjustedTime() + MAX_FUTURE_BLOCK_TIME) {
                         strLoadError = _(
                             "The block database contains a block which appears "
                             "to be from the future. This may be due to your "
                             "computer's date and time being set incorrectly. "
                             "Only rebuild the block database if you are sure "
                             "that your computer's date and time are correct");
                         break;
                     }
 
                     if (!CVerifyDB().VerifyDB(
                             config, pcoinsdbview.get(),
                             gArgs.GetArg("-checklevel", DEFAULT_CHECKLEVEL),
                             gArgs.GetArg("-checkblocks",
                                          DEFAULT_CHECKBLOCKS))) {
                         strLoadError = _("Corrupted block database detected");
                         break;
                     }
                 }
             } catch (const std::exception &e) {
                 LogPrintf("%s\n", e.what());
                 strLoadError = _("Error opening block database");
                 break;
             }
 
             fLoaded = true;
         } while (false);
 
         if (!fLoaded && !ShutdownRequested()) {
             // first suggest a reindex
             if (!fReset) {
                 bool fRet = uiInterface.ThreadSafeQuestion(
                     strLoadError + ".\n\n" +
                         _("Do you want to rebuild the block database now?"),
                     strLoadError + ".\nPlease restart with -reindex or "
                                    "-reindex-chainstate to recover.",
                     "",
                     CClientUIInterface::MSG_ERROR |
                         CClientUIInterface::BTN_ABORT);
                 if (fRet) {
                     fReindex = true;
                     AbortShutdown();
                 } else {
                     LogPrintf("Aborted block database rebuild. Exiting.\n");
                     return false;
                 }
             } else {
                 return InitError(strLoadError);
             }
         }
     }
 
     // As LoadBlockIndex can take several minutes, it's possible the user
     // requested to kill the GUI during the last operation. If so, exit.
     // As the program has not fully started yet, Shutdown() is possibly
     // overkill.
     if (ShutdownRequested()) {
         LogPrintf("Shutdown requested. Exiting.\n");
         return false;
     }
     if (fLoaded) {
         LogPrintf(" block index %15dms\n", GetTimeMillis() - nStart);
     }
 
     // Encoded addresses using cashaddr instead of base58.
     // We do this by default to avoid confusion with BTC addresses.
     config.SetCashAddrEncoding(gArgs.GetBoolArg("-usecashaddr", true));
 
     // Step 8: load indexers
     if (gArgs.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
         g_txindex = std::make_unique<TxIndex>(nTxIndexCache, false, fReindex);
         g_txindex->Start();
     }
 
     // Step 9: load wallet
     for (const auto &client : interfaces.chain_clients) {
         if (!client->load(chainparams)) {
             return false;
         }
     }
 
     // Step 10: data directory maintenance
 
     // if pruning, unset the service bit and perform the initial blockstore
     // prune after any wallet rescanning has taken place.
     if (fPruneMode) {
         LogPrintf("Unsetting NODE_NETWORK on prune mode\n");
         nLocalServices = ServiceFlags(nLocalServices & ~NODE_NETWORK);
         if (!fReindex) {
             uiInterface.InitMessage(_("Pruning blockstore..."));
             PruneAndFlush();
         }
     }
 
     // Step 11: import blocks
     if (!CheckDiskSpace(GetDataDir())) {
         InitError(
             strprintf(_("Error: Disk space is low for %s"), GetDataDir()));
         return false;
     }
     if (!CheckDiskSpace(GetBlocksDir())) {
         InitError(
             strprintf(_("Error: Disk space is low for %s"), GetBlocksDir()));
         return false;
     }
 
     // Either install a handler to notify us when genesis activates, or set
     // fHaveGenesis directly.
     // No locking, as this happens before any background thread is started.
     if (::ChainActive().Tip() == nullptr) {
         uiInterface.NotifyBlockTip_connect(BlockNotifyGenesisWait);
     } else {
         fHaveGenesis = true;
     }
 
     if (gArgs.IsArgSet("-blocknotify")) {
         uiInterface.NotifyBlockTip_connect(BlockNotifyCallback);
     }
 
     std::vector<fs::path> vImportFiles;
     for (const std::string &strFile : gArgs.GetArgs("-loadblock")) {
         vImportFiles.push_back(strFile);
     }
 
     threadGroup.create_thread(
         std::bind(&ThreadImport, std::ref(config), vImportFiles));
 
     // Wait for genesis block to be processed
     {
         WAIT_LOCK(g_genesis_wait_mutex, lock);
         // We previously could hang here if StartShutdown() is called prior to
         // ThreadImport getting started, so instead we just wait on a timer to
         // check ShutdownRequested() regularly.
         while (!fHaveGenesis && !ShutdownRequested()) {
             g_genesis_wait_cv.wait_for(lock, std::chrono::milliseconds(500));
         }
         uiInterface.NotifyBlockTip_disconnect(BlockNotifyGenesisWait);
     }
 
     if (ShutdownRequested()) {
         return false;
     }
 
     // Step 12: start node
 
     int chain_active_height;
 
     //// debug print
     {
         LOCK(cs_main);
         LogPrintf("mapBlockIndex.size() = %u\n", mapBlockIndex.size());
         chain_active_height = ::ChainActive().Height();
     }
     LogPrintf("nBestHeight = %d\n", chain_active_height);
 
     if (gArgs.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)) {
         StartTorControl();
     }
 
     Discover();
 
     // Map ports with UPnP
     if (gArgs.GetBoolArg("-upnp", DEFAULT_UPNP)) {
         StartMapPort();
     }
 
     CConnman::Options connOptions;
     connOptions.nLocalServices = nLocalServices;
     connOptions.nMaxConnections = nMaxConnections;
     connOptions.nMaxOutbound =
         std::min(MAX_OUTBOUND_CONNECTIONS, connOptions.nMaxConnections);
     connOptions.nMaxAddnode = MAX_ADDNODE_CONNECTIONS;
     connOptions.nMaxFeeler = 1;
     connOptions.nBestHeight = chain_active_height;
     connOptions.uiInterface = &uiInterface;
     connOptions.m_banman = g_banman.get();
     connOptions.m_msgproc = peerLogic.get();
     connOptions.nSendBufferMaxSize =
         1000 * gArgs.GetArg("-maxsendbuffer", DEFAULT_MAXSENDBUFFER);
     connOptions.nReceiveFloodSize =
         1000 * gArgs.GetArg("-maxreceivebuffer", DEFAULT_MAXRECEIVEBUFFER);
     connOptions.m_added_nodes = gArgs.GetArgs("-addnode");
 
     connOptions.nMaxOutboundTimeframe = nMaxOutboundTimeframe;
     connOptions.nMaxOutboundLimit = nMaxOutboundLimit;
 
     for (const std::string &strBind : gArgs.GetArgs("-bind")) {
         CService addrBind;
         if (!Lookup(strBind.c_str(), addrBind, GetListenPort(), false)) {
             return InitError(ResolveErrMsg("bind", strBind));
         }
         connOptions.vBinds.push_back(addrBind);
     }
 
     for (const std::string &strBind : gArgs.GetArgs("-whitebind")) {
         CService addrBind;
         if (!Lookup(strBind.c_str(), addrBind, 0, false)) {
             return InitError(ResolveErrMsg("whitebind", strBind));
         }
         if (addrBind.GetPort() == 0) {
             return InitError(strprintf(
                 _("Need to specify a port with -whitebind: '%s'"), strBind));
         }
         connOptions.vWhiteBinds.push_back(addrBind);
     }
 
     for (const auto &net : gArgs.GetArgs("-whitelist")) {
         CSubNet subnet;
         LookupSubNet(net.c_str(), subnet);
         if (!subnet.IsValid()) {
             return InitError(strprintf(
                 _("Invalid netmask specified in -whitelist: '%s'"), net));
         }
         connOptions.vWhitelistedRange.push_back(subnet);
     }
 
     connOptions.vSeedNodes = gArgs.GetArgs("-seednode");
 
     // Initiate outbound connections unless connect=0
     connOptions.m_use_addrman_outgoing = !gArgs.IsArgSet("-connect");
     if (!connOptions.m_use_addrman_outgoing) {
         const auto connect = gArgs.GetArgs("-connect");
         if (connect.size() != 1 || connect[0] != "0") {
             connOptions.m_specified_outgoing = connect;
         }
     }
     if (!g_connman->Start(scheduler, connOptions)) {
         return false;
     }
 
     // Step 13: finished
 
     SetRPCWarmupFinished();
     uiInterface.InitMessage(_("Done loading"));
 
     for (const auto &client : interfaces.chain_clients) {
         client->start(scheduler);
     }
 
     scheduler.scheduleEvery(
         [] {
             g_banman->DumpBanlist();
             return true;
         },
         DUMP_BANS_INTERVAL * 1000);
 
     // Start Avalanche's event loop.
     g_avalanche->startEventLoop(scheduler);
 
     return true;
 }
diff --git a/test/functional/abc-block-sigchecks-activation.py b/test/functional/abc-block-sigchecks-activation.py
index 3c7f26fdf..2cce5bccb 100755
--- a/test/functional/abc-block-sigchecks-activation.py
+++ b/test/functional/abc-block-sigchecks-activation.py
@@ -1,438 +1,439 @@
 #!/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 activation of block sigchecks limits
 """
 
 from test_framework.blocktools import (
     create_block,
     create_coinbase,
     make_conform_to_ctor,
 )
 from test_framework.cdefs import (
     BLOCK_MAXBYTES_MAXSIGCHECKS_RATIO
 )
 from test_framework.messages import (
     CBlock,
     COutPoint,
     CTransaction,
     CTxIn,
     CTxOut,
     FromHex,
 )
 from test_framework.mininode import P2PDataStore
 from test_framework.script import (
     CScript,
     OP_CHECKDATASIG,
     OP_CHECKDATASIGVERIFY,
     OP_3DUP,
     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
 from collections import deque
 
 # Set test to run with sigops deactivation far in the future.
 SIGCHECKS_ACTIVATION_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 = SIGCHECKS_ACTIVATION_TIME * 2
 
 # We are going to use a tiny block size so we don't need to waste too much
 # time with making transactions. (note -- minimum block size is 1000000)
 # (just below a multiple, to test edge case)
 MAXBLOCKSIZE = 8000 * BLOCK_MAXBYTES_MAXSIGCHECKS_RATIO - 1
 assert MAXBLOCKSIZE == 1127999
 
 # Blocks with too many sigchecks from cache give this error in log file:
 BLOCK_SIGCHECKS_CACHED_ERROR = "blk-bad-inputs, CheckInputs exceeded SigChecks limit"
 # Blocks with too many sigchecks discovered during parallel checks give
 # this error in log file:
 BLOCK_SIGCHECKS_PARALLEL_ERROR = "blk-bad-inputs, parallel script check failed"
 
 MAX_TX_SIGCHECK = 3000
 
 
 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 BlockSigChecksActivationTest(BitcoinTestFramework):
 
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
         self.block_heights = {}
         self.extra_args = [["-phononactivationtime={}".format(
             SIGCHECKS_ACTIVATION_TIME),
             "-replayprotectionactivationtime={}".format(
             REPLAY_PROTECTION_START_TIME),
             "-excessiveblocksize={}".format(MAXBLOCKSIZE),
-            "-blockmaxsize={}".format(MAXBLOCKSIZE)]]
+            "-blockmaxsize={}".format(MAXBLOCKSIZE),
+            "-acceptnonstdtxn=1"]]
 
     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] = self.nodes
         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)
 
         # To make compact and fast-to-verify transactions, we'll use
         # CHECKDATASIG over and over with the same data.
         # (Using the same stuff over and over again means we get to hit the
         # node's signature cache and don't need to make new signatures every
         # time.)
         cds_message = b''
         # r=1 and s=1 ecdsa, the minimum values.
         cds_signature = bytes.fromhex('3006020101020101')
         # Recovered pubkey
         cds_pubkey = bytes.fromhex(
             '03089b476b570d66fad5a20ae6188ebbaf793a4c2a228c65f3d79ee8111d56c932')
 
         def minefunding2(n):
             """ Mine a block with a bunch of outputs that are very dense
             sigchecks when spent (2 sigchecks each); return the inputs that can
             be used to spend. """
             cds_scriptpubkey = CScript(
                 [cds_message, cds_pubkey, OP_3DUP, OP_CHECKDATASIGVERIFY, OP_CHECKDATASIGVERIFY])
             # The scriptsig is carefully padded to have size 26, which is the
             # shortest allowed for 2 sigchecks for mempool admission.
             # The resulting inputs have size 67 bytes, 33.5 bytes/sigcheck.
             cds_scriptsig = CScript([b'x' * 16, cds_signature])
             assert_equal(len(cds_scriptsig), 26)
 
             self.log.debug("Gen {} with locking script {} unlocking script {} .".format(
                 n, cds_scriptpubkey.hex(), cds_scriptsig.hex()))
 
             tx = self.spendable_outputs.popleft()
             usable_inputs = []
             txes = []
             for _ in range(n):
                 tx = create_transaction(tx, cds_scriptpubkey)
                 txes.append(tx)
                 usable_inputs.append(
                     CTxIn(COutPoint(tx.sha256, 1), cds_scriptsig))
             newtip = self.build_block(tip, txes)
             node.p2p.send_blocks_and_test([newtip], node)
             return usable_inputs, newtip
 
         self.log.info("Funding special coins that have high sigchecks")
 
         # mine 5000 funded outputs (10000 sigchecks)
         # will be used pre-activation and post-activation
         usable_inputs, tip = minefunding2(5000)
         # assemble them into 50 txes with 100 inputs each (200 sigchecks)
         submittxes_1 = []
         while len(usable_inputs) >= 100:
             tx = CTransaction()
             tx.vin = [usable_inputs.pop() for _ in range(100)]
             tx.vout = [CTxOut(0, CScript([OP_RETURN]))]
             tx.rehash()
             submittxes_1.append(tx)
 
         # mine 5000 funded outputs (10000 sigchecks)
         # will be used post-activation
         usable_inputs, tip = minefunding2(5000)
         # assemble them into 50 txes with 100 inputs each (200 sigchecks)
         submittxes_2 = []
         while len(usable_inputs) >= 100:
             tx = CTransaction()
             tx.vin = [usable_inputs.pop() for _ in range(100)]
             tx.vout = [CTxOut(0, CScript([OP_RETURN]))]
             tx.rehash()
             submittxes_2.append(tx)
 
         # Check high sigcheck transactions
         self.log.info("Create transaction that have high sigchecks")
 
         fundings = []
 
         def make_spend(sigcheckcount):
             # Add a funding tx to fundings, and return a tx spending that using
             # scriptsig.
             self.log.debug(
                 "Gen tx with {} sigchecks.".format(sigcheckcount))
 
             def get_script_with_sigcheck(count):
                 return CScript([cds_message,
                                 cds_pubkey] + (count - 1) * [OP_3DUP, OP_CHECKDATASIGVERIFY] + [OP_CHECKDATASIG])
 
             # get funds locked with OP_1
             sourcetx = self.spendable_outputs.popleft()
             # make funding that forwards to scriptpubkey
             last_sigcheck_count = ((sigcheckcount - 1) % 30) + 1
             fundtx = create_transaction(
                 sourcetx, get_script_with_sigcheck(last_sigcheck_count))
 
             fill_sigcheck_script = get_script_with_sigcheck(30)
 
             remaining_sigcheck = sigcheckcount
             while remaining_sigcheck > 30:
                 fundtx.vout[0].nValue -= 1000
                 fundtx.vout.append(CTxOut(100, bytes(fill_sigcheck_script)))
                 remaining_sigcheck -= 30
 
             fundtx.rehash()
             fundings.append(fundtx)
 
             # make the spending
             scriptsig = CScript([cds_signature])
 
             tx = CTransaction()
             tx.vin.append(CTxIn(COutPoint(fundtx.sha256, 1), scriptsig))
 
             input_index = 2
             remaining_sigcheck = sigcheckcount
             while remaining_sigcheck > 30:
                 tx.vin.append(
                     CTxIn(
                         COutPoint(
                             fundtx.sha256,
                             input_index),
                         scriptsig))
                 remaining_sigcheck -= 30
                 input_index += 1
 
             tx.vout.append(CTxOut(0, CScript([OP_RETURN])))
             pad_tx(tx)
             tx.rehash()
             return tx
 
         # Create transactions with many sigchecks.
         good_tx = make_spend(MAX_TX_SIGCHECK)
         bad_tx = make_spend(MAX_TX_SIGCHECK + 1)
 
         tip = self.build_block(tip, fundings)
         node.p2p.send_blocks_and_test([tip], node)
 
         # Both tx are accepted before the activation.
         pre_activation_sigcheck_block = self.build_block(
             tip, [good_tx, bad_tx])
         node.p2p.send_blocks_and_test([pre_activation_sigcheck_block], node)
         node.invalidateblock(pre_activation_sigcheck_block.hash)
 
         # 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(SIGCHECKS_ACTIVATION_TIME + 10)
         # Mine six blocks with timestamp starting at
         # SIGCHECKS_ACTIVATION_TIME-1
         blocks = []
         for i in range(-1, 5):
             tip = self.build_block(tip, nTime=SIGCHECKS_ACTIVATION_TIME + i)
             blocks.append(tip)
         node.p2p.send_blocks_and_test(blocks, node)
         assert_equal(node.getblockchaininfo()[
                      'mediantime'], SIGCHECKS_ACTIVATION_TIME - 1)
 
         self.log.info(
             "The next block will activate, but the activation block itself must follow old rules")
 
         # Send the 50 txes and get the node to mine as many as possible (it should do all)
         # The node is happy mining and validating a 10000 sigcheck block before
         # activation.
         node.p2p.send_txs_and_test(submittxes_1, node)
         [blockhash] = node.generatetoaddress(
             1, node.get_deterministic_priv_key().address)
         assert_equal(set(node.getblock(blockhash, 1)["tx"][1:]), {
                      t.hash for t in submittxes_1})
 
         # We have activated, but let's invalidate that.
         assert_equal(node.getblockchaininfo()[
             'mediantime'], SIGCHECKS_ACTIVATION_TIME)
         node.invalidateblock(blockhash)
 
         # Try again manually and invalidate that too
         goodblock = self.build_block(tip, submittxes_1)
         node.p2p.send_blocks_and_test([goodblock], node)
         node.invalidateblock(goodblock.hash)
 
         # All transactions should be back in mempool.
         assert_equal(set(node.getrawmempool()), {t.hash for t in submittxes_1})
 
         self.log.info("Mine the activation block itself")
         tip = self.build_block(tip)
         node.p2p.send_blocks_and_test([tip], node)
 
         self.log.info("We have activated!")
         assert_equal(node.getblockchaininfo()[
                      'mediantime'], SIGCHECKS_ACTIVATION_TIME)
 
         self.log.info(
             "Try a block with a transaction going over the limit (limit: {})".format(MAX_TX_SIGCHECK))
         bad_tx_block = self.build_block(tip, [bad_tx])
         check_for_ban_on_rejected_block(
             node, bad_tx_block, reject_reason=BLOCK_SIGCHECKS_PARALLEL_ERROR)
 
         self.log.info(
             "Try a block with a transaction just under the limit (limit: {})".format(MAX_TX_SIGCHECK))
         good_tx_block = self.build_block(tip, [good_tx])
         node.p2p.send_blocks_and_test([good_tx_block], node)
         node.invalidateblock(good_tx_block.hash)
 
         # save this tip for later
         # ~ upgrade_block = tip
 
         # Transactions still in pool:
         assert_equal(set(node.getrawmempool()), {t.hash for t in submittxes_1})
 
         self.log.info("Try sending 10000-sigcheck blocks after activation (limit: {})".format(
             MAXBLOCKSIZE // BLOCK_MAXBYTES_MAXSIGCHECKS_RATIO))
         # Send block with same txes we just tried before activation
         badblock = self.build_block(tip, submittxes_1)
         check_for_ban_on_rejected_block(
             node, badblock, reject_reason=BLOCK_SIGCHECKS_CACHED_ERROR)
 
         self.log.info(
             "There are too many sigchecks in mempool to mine in a single block. Make sure the node won't mine invalid blocks.")
         node.generatetoaddress(1, node.get_deterministic_priv_key().address)
         tip = self.getbestblock(node)
         # only 39 txes got mined.
         assert_equal(len(node.getrawmempool()), 11)
 
         self.log.info("Try sending 10000-sigcheck block with fresh transactions after activation (limit: {})".format(
             MAXBLOCKSIZE // BLOCK_MAXBYTES_MAXSIGCHECKS_RATIO))
         # Note: in the following tests we'll be bumping timestamp in order
         # to bypass any kind of 'bad block' cache on the node, and get a
         # fresh evaluation each time.
 
         # Try another block with 10000 sigchecks but all fresh transactions
         badblock = self.build_block(
             tip, submittxes_2, nTime=SIGCHECKS_ACTIVATION_TIME + 5)
         check_for_ban_on_rejected_block(
             node, badblock, reject_reason=BLOCK_SIGCHECKS_PARALLEL_ERROR)
 
         # Send the same txes again with different block hash. Currently we don't
         # cache valid transactions in invalid blocks so nothing changes.
         badblock = self.build_block(
             tip, submittxes_2, nTime=SIGCHECKS_ACTIVATION_TIME + 6)
         check_for_ban_on_rejected_block(
             node, badblock, reject_reason=BLOCK_SIGCHECKS_PARALLEL_ERROR)
 
         # Put all the txes in mempool, in order to get them cached:
         node.p2p.send_txs_and_test(submittxes_2, node)
         # Send them again, the node still doesn't like it. But the log
         # error message has now changed because the txes failed from cache.
         badblock = self.build_block(
             tip, submittxes_2, nTime=SIGCHECKS_ACTIVATION_TIME + 7)
         check_for_ban_on_rejected_block(
             node, badblock, reject_reason=BLOCK_SIGCHECKS_CACHED_ERROR)
 
         self.log.info("Try sending 8000-sigcheck block after activation (limit: {})".format(
             MAXBLOCKSIZE // BLOCK_MAXBYTES_MAXSIGCHECKS_RATIO))
         # redundant, but just to mirror the following test...
         node.setexcessiveblock(MAXBLOCKSIZE)
         badblock = self.build_block(
             tip, submittxes_2[:40], nTime=SIGCHECKS_ACTIVATION_TIME + 5)
         check_for_ban_on_rejected_block(
             node, badblock, reject_reason=BLOCK_SIGCHECKS_CACHED_ERROR)
 
         self.log.info("Bump the excessiveblocksize limit by 1 byte, and send another block with same txes (new sigchecks limit: {})".format(
             (MAXBLOCKSIZE + 1) // BLOCK_MAXBYTES_MAXSIGCHECKS_RATIO))
         node.setexcessiveblock(MAXBLOCKSIZE + 1)
         tip = self.build_block(
             tip, submittxes_2[:40], nTime=SIGCHECKS_ACTIVATION_TIME + 6)
         # It should succeed now since limit should be 8000.
         node.p2p.send_blocks_and_test([tip], node)
 
 
 if __name__ == '__main__':
     BlockSigChecksActivationTest().main()
diff --git a/test/functional/abc-mempool-accept-txn.py b/test/functional/abc-mempool-accept-txn.py
index a371e7a35..eb1ce7b98 100755
--- a/test/functional/abc-mempool-accept-txn.py
+++ b/test/functional/abc-mempool-accept-txn.py
@@ -1,277 +1,278 @@
 #!/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 CECKey
 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 = CECKey()
         self.coinbase_key.set_secretbytes(b"horsebattery")
         self.coinbase_pubkey = self.coinbase_key.get_pubkey()
         self.tip = None
         self.blocks = {}
         self.extra_args = [
-            ['-phononactivationtime={}'.format(SIGOPS_DEACTIVATION_TIME)]]
+            ['-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(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(
                 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-mempool-coherence-on-activations.py b/test/functional/abc-mempool-coherence-on-activations.py
index 2ceb76504..758dc29fd 100755
--- a/test/functional/abc-mempool-coherence-on-activations.py
+++ b/test/functional/abc-mempool-coherence-on-activations.py
@@ -1,377 +1,378 @@
 #!/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 the mempool coherence when changing validation rulesets,
 which happens on (de)activations of network upgrades (forks).
 
 We test the mempool coherence in 3 cases:
 1) on activations, pre-fork-only transactions are evicted from the mempool,
    while always-valid transactions remain.
 2) on deactivations, post-fork-only transactions (unconfirmed or once
    confirmed) are evicted from the mempool, while always-valid transactions
    are reincluded.
 3) on a reorg to a chain that deactivates and reactivates the fork,
    post-fork-only and always-valid transactions (unconfirmed and/or once
    confirmed on the shorter chain) are kept or reincluded in the mempool.
 """
 
 from test_framework.blocktools import (
     create_block,
     create_coinbase,
     create_tx_with_script,
     make_conform_to_ctor,
 )
 from test_framework.key import CECKey
 from test_framework.messages import (
     COIN,
     COutPoint,
     CTransaction,
     CTxIn,
     CTxOut,
     ToHex,
 )
 from test_framework.mininode import P2PDataStore
 from test_framework.script import (
     CScript,
     OP_CHECKSIG,
     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
 
 
 # ---Code specific to the activation used for this test---
 
 # It might change depending on the activation code currently existing in the
 # client software. We use the replay protection activation for this test.
 ACTIVATION_TIME = 2000000000
 EXTRA_ARG = "-replayprotectionactivationtime={}".format(ACTIVATION_TIME)
 
 # simulation starts before activation
 FIRST_BLOCK_TIME = ACTIVATION_TIME - 86400
 
 # Expected RPC error when trying to send an activation specific spend txn.
 RPC_EXPECTED_ERROR = "mandatory-script-verify-flag-failed (Signature must be zero for failed CHECK(MULTI)SIG operation) (code 16)"
 
 
 def create_fund_and_activation_specific_spending_tx(spend, pre_fork_only):
     # Creates 2 transactions:
     # 1) txfund: create outputs to be used by txspend. Must be valid pre-fork.
     # 2) txspend: spending transaction that is specific to the activation
     #    being used and can be pre-fork-only or post-fork-only, depending on the
     #    function parameter.
 
     # This specific implementation uses the replay protection mechanism to
     # create transactions that are only valid before or after the fork.
 
     # Generate a key pair to test
     private_key = CECKey()
     private_key.set_secretbytes(b"replayprotection")
     public_key = private_key.get_pubkey()
 
     # Fund transaction
     script = CScript([public_key, OP_CHECKSIG])
     txfund = create_tx_with_script(
         spend.tx, spend.n, b'', 50 * COIN, script)
     txfund.rehash()
 
     # Activation specific spending tx
     txspend = CTransaction()
     txspend.vout.append(CTxOut(50 * COIN - 1000, CScript([OP_TRUE])))
     txspend.vin.append(CTxIn(COutPoint(txfund.sha256, 0), b''))
 
     # Sign the transaction
     # Use forkvalues that create pre-fork-only or post-fork-only
     # transactions.
     forkvalue = 0 if pre_fork_only else 0xffdead
     sighashtype = (forkvalue << 8) | SIGHASH_ALL | SIGHASH_FORKID
     sighash = SignatureHashForkId(
         script, txspend, 0, sighashtype, 50 * COIN)
     sig = private_key.sign(sighash) + \
         bytes(bytearray([SIGHASH_ALL | SIGHASH_FORKID]))
     txspend.vin[0].scriptSig = CScript([sig])
     txspend.rehash()
 
     return txfund, txspend
 
 
 def create_fund_and_pre_fork_only_tx(spend):
     return create_fund_and_activation_specific_spending_tx(
         spend, pre_fork_only=True)
 
 
 def create_fund_and_post_fork_only_tx(spend):
     return create_fund_and_activation_specific_spending_tx(
         spend, pre_fork_only=False)
 
 
 # ---Mempool coherence on activations test---
 
 
 class PreviousSpendableOutput(object):
 
     def __init__(self, tx=CTransaction(), n=-1):
         self.tx = tx
         self.n = n
 
 
 class MempoolCoherenceOnActivationsTest(BitcoinTestFramework):
 
     def set_test_params(self):
         self.num_nodes = 1
         self.setup_clean_chain = True
         self.block_heights = {}
         self.tip = None
         self.blocks = {}
         self.extra_args = [['-whitelist=127.0.0.1',
-                            EXTRA_ARG]]
+                            EXTRA_ARG,
+                            '-acceptnonstdtxn=1']]
 
     def next_block(self, number):
         if self.tip is None:
             base_block_hash = self.genesis_hash
             block_time = FIRST_BLOCK_TIME
         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()
         block = create_block(base_block_hash, coinbase, block_time)
 
         # 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())
         node.setmocktime(ACTIVATION_TIME)
 
         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]
             block.vtx.extend(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
 
         # send a txn to the mempool and check it was accepted
         def send_transaction_to_mempool(tx):
             tx_id = node.sendrawtransaction(ToHex(tx))
             assert tx_id in node.getrawmempool()
 
         # checks the mempool has exactly the same txns as in the provided list
         def check_mempool_equal(txns):
             assert set(node.getrawmempool()) == set(tx.hash for tx in txns)
 
         # Create an always-valid chained transaction. It spends a
         # scriptPub=OP_TRUE coin into another. Returns the transaction and its
         # spendable output for further chaining.
         def create_always_valid_chained_tx(spend):
             tx = create_tx_with_script(
                 spend.tx, spend.n, b'', spend.tx.vout[0].nValue - 1000, CScript([OP_TRUE]))
             tx.rehash()
             return tx, PreviousSpendableOutput(tx, 0)
 
         # shorthand
         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(110):
             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())
 
         # Create 2 pre-fork-only txns (tx_pre0, tx_pre1). Fund txns are valid
         # pre-fork, so we can mine them right away.
         txfund0, tx_pre0 = create_fund_and_pre_fork_only_tx(out[0])
         txfund1, tx_pre1 = create_fund_and_pre_fork_only_tx(out[1])
 
         # Create 2 post-fork-only txns (tx_post0, tx_post1). Fund txns are
         # valid pre-fork, so we can mine them right away.
         txfund2, tx_post0 = create_fund_and_post_fork_only_tx(out[2])
         txfund3, tx_post1 = create_fund_and_post_fork_only_tx(out[3])
 
         # Create blocks to activate the fork. Mine all funding transactions.
         bfork = block(5555)
         bfork.nTime = ACTIVATION_TIME - 1
         update_block(5555, [txfund0, txfund1, txfund2, txfund3])
         node.p2p.send_blocks_and_test([self.tip], node)
 
         for i in range(5):
             node.p2p.send_blocks_and_test([block(5200 + i)], node)
 
         # Check we are just before the activation time
         assert_equal(
             node.getblockchaininfo()['mediantime'],
             ACTIVATION_TIME - 1)
 
         # We are just before the fork. Pre-fork-only and always-valid chained
         # txns (tx_chain0, tx_chain1) are valid, post-fork-only txns are
         # rejected.
         send_transaction_to_mempool(tx_pre0)
         send_transaction_to_mempool(tx_pre1)
         tx_chain0, last_chained_output = create_always_valid_chained_tx(out[4])
         tx_chain1, last_chained_output = create_always_valid_chained_tx(
             last_chained_output)
         send_transaction_to_mempool(tx_chain0)
         send_transaction_to_mempool(tx_chain1)
         assert_raises_rpc_error(-26, RPC_EXPECTED_ERROR,
                                 node.sendrawtransaction, ToHex(tx_post0))
         assert_raises_rpc_error(-26, RPC_EXPECTED_ERROR,
                                 node.sendrawtransaction, ToHex(tx_post1))
         check_mempool_equal([tx_chain0, tx_chain1, tx_pre0, tx_pre1])
 
         # Activate the fork. Mine the 1st always-valid chained txn and a
         # pre-fork-only txn.
         block(5556)
         update_block(5556, [tx_chain0, tx_pre0])
         node.p2p.send_blocks_and_test([self.tip], node)
         forkblockid = node.getbestblockhash()
 
         # Check we just activated the fork
         assert_equal(node.getblockheader(forkblockid)['mediantime'],
                      ACTIVATION_TIME)
 
         # Check mempool coherence when activating the fork. Pre-fork-only txns
         # were evicted from the mempool, while always-valid txns remain.
         # Evicted: tx_pre1
         check_mempool_equal([tx_chain1])
 
         # Post-fork-only and always-valid txns are accepted, pre-fork-only txn
         # are rejected.
         send_transaction_to_mempool(tx_post0)
         send_transaction_to_mempool(tx_post1)
         tx_chain2, _ = create_always_valid_chained_tx(last_chained_output)
         send_transaction_to_mempool(tx_chain2)
         assert_raises_rpc_error(-26, RPC_EXPECTED_ERROR,
                                 node.sendrawtransaction, ToHex(tx_pre1))
         check_mempool_equal([tx_chain1, tx_chain2, tx_post0, tx_post1])
 
         # Mine the 2nd always-valid chained txn and a post-fork-only txn.
         block(5557)
         update_block(5557, [tx_chain1, tx_post0])
         node.p2p.send_blocks_and_test([self.tip], node)
         postforkblockid = node.getbestblockhash()
         # The mempool contains the 3rd chained txn and a post-fork-only txn.
         check_mempool_equal([tx_chain2, tx_post1])
 
         # In the following we will testing block disconnections and reorgs.
         # - tx_chain2 will always be retained in the mempool since it is always
         #   valid. Its continued presence shows that we are never simply
         #   clearing the entire mempool.
         # - tx_post1 may be evicted from mempool if we land before the fork.
         # - tx_post0 is in a block and if 'de-mined', it will either be evicted
         #   or end up in mempool depending if we land before/after the fork.
         # - tx_pre0 is in a block and if 'de-mined', it will either be evicted
         #   or end up in mempool depending if we land after/before the fork.
 
         # First we do a disconnection of the post-fork block, which is a
         # normal disconnection that merely returns the block contents into
         # the mempool -- nothing is lost.
         node.invalidateblock(postforkblockid)
         # In old mempool: tx_chain2, tx_post1
         # Recovered from blocks: tx_chain1 and tx_post0.
         # Lost from blocks: NONE
         # Retained from old mempool: tx_chain2, tx_post1
         # Evicted from old mempool: NONE
         check_mempool_equal([tx_chain1, tx_chain2, tx_post0, tx_post1])
 
         # Now, disconnect the fork block. This is a special disconnection
         # that requires reprocessing the mempool due to change in rules.
         node.invalidateblock(forkblockid)
         # In old mempool: tx_chain1, tx_chain2, tx_post0, tx_post1
         # Recovered from blocks: tx_chain0, tx_pre0
         # Lost from blocks: NONE
         # Retained from old mempool: tx_chain1, tx_chain2
         # Evicted from old mempool: tx_post0, tx_post1
         check_mempool_equal([tx_chain0, tx_chain1, tx_chain2, tx_pre0])
 
         # Restore state
         node.reconsiderblock(postforkblockid)
         node.reconsiderblock(forkblockid)
         send_transaction_to_mempool(tx_post1)
         check_mempool_equal([tx_chain2, tx_post1])
 
         # Test a reorg that crosses the fork.
 
         # If such a reorg happens, most likely it will both start *and end*
         # after the fork. We will test such a case here and make sure that
         # post-fork-only transactions are not unnecessarily discarded from
         # the mempool in such a reorg. Pre-fork-only transactions however can
         # get lost.
 
         # Set up a longer competing chain that doesn't confirm any of our txns.
         # This starts after 5204, so it contains neither the forkblockid nor
         # the postforkblockid from above.
         tip(5204)
         reorg_blocks = []
         for i in range(3):
             reorg_blocks.append(block(5900 + i))
 
         # Perform the reorg
         node.p2p.send_blocks_and_test(reorg_blocks, node)
         # reorg finishes after the fork
         assert_equal(
             node.getblockchaininfo()['mediantime'],
             ACTIVATION_TIME + 2)
         # In old mempool: tx_chain2, tx_post1
         # Recovered from blocks: tx_chain0, tx_chain1, tx_post0
         # Lost from blocks: tx_pre0
         # Retained from old mempool: tx_chain2, tx_post1
         # Evicted from old mempool: NONE
         check_mempool_equal(
             [tx_chain0, tx_chain1, tx_chain2, tx_post0, tx_post1])
 
 
 if __name__ == '__main__':
     MempoolCoherenceOnActivationsTest().main()
diff --git a/test/functional/abc-minimaldata.py b/test/functional/abc-minimaldata.py
index 17b3d9423..4e78e23a0 100755
--- a/test/functional/abc-minimaldata.py
+++ b/test/functional/abc-minimaldata.py
@@ -1,184 +1,185 @@
 #!/usr/bin/env python3
 # Copyright (c) 2019 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """
 This tests the MINIMALDATA consensus rule.
 - test rejection in mempool, with error changing before/after activation.
 - test acceptance in blocks before activation, and rejection after.
 - check non-banning for peers who send invalid txns that would have been valid
 on the other side of the upgrade.
 
 Derived from abc-schnorr.py
 """
 
 from test_framework.blocktools import (
     create_block,
     create_coinbase,
     create_tx_with_script,
     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 (
     CScript,
     OP_ADD,
     OP_TRUE,
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.txtools import pad_tx
 from test_framework.util import assert_raises_rpc_error
 
 # Minimal push violations in mempool are rejected with a bannable error.
 MINIMALPUSH_ERROR = 'mandatory-script-verify-flag-failed (Data push larger than necessary)'
 
 # Blocks with invalid scripts give this error:
 BADINPUTS_ERROR = 'blk-bad-inputs'
 
 
 class MinimaldataTest(BitcoinTestFramework):
 
     def set_test_params(self):
         self.num_nodes = 1
         self.block_heights = {}
+        self.extra_args = [['-acceptnonstdtxn=1']]
 
     def bootstrap_p2p(self, *, num_connections=1):
         """Add a P2P connection to the node.
 
         Helper to connect and wait for version handshake."""
         for _ in range(num_connections):
             self.nodes[0].add_p2p_connection(P2PDataStore())
 
     def reconnect_p2p(self, **kwargs):
         """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(**kwargs)
 
     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.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 check_for_ban_on_rejected_tx(self, tx, reject_reason=None):
         """Check we are disconnected when sending a txn that the node rejects.
 
         (Can't actually get banned, since bitcoind won't ban local peers.)"""
         self.nodes[0].p2p.send_txs_and_test(
             [tx], self.nodes[0], success=False, expect_disconnect=True, reject_reason=reject_reason)
         self.reconnect_p2p()
 
     def check_for_ban_on_rejected_block(self, block, reject_reason=None):
         """Check we are disconnected when sending a block that the node rejects.
 
         (Can't actually get banned, since bitcoind won't ban local peers.)"""
         self.nodes[0].p2p.send_blocks_and_test(
             [block], self.nodes[0], success=False, reject_reason=reject_reason, expect_disconnect=True)
         self.reconnect_p2p()
 
     def run_test(self):
         node, = self.nodes
 
         self.bootstrap_p2p()
 
         tip = self.getbestblock(node)
 
         self.log.info("Create some blocks with OP_1 coinbase for spending.")
         blocks = []
         for _ in range(10):
             tip = self.build_block(tip)
             blocks.append(tip)
         node.p2p.send_blocks_and_test(blocks, node, success=True)
         spendable_outputs = [block.vtx[0] for block in blocks]
 
         self.log.info("Mature the blocks and get out of IBD.")
         node.generatetoaddress(100, node.get_deterministic_priv_key().address)
 
         tip = self.getbestblock(node)
 
         self.log.info("Setting up spends to test and mining the fundings.")
         fundings = []
 
         def create_fund_and_spend_tx():
             spendfrom = spendable_outputs.pop()
 
             script = CScript([OP_ADD])
 
             value = spendfrom.vout[0].nValue
 
             # Fund transaction
             txfund = create_tx_with_script(spendfrom, 0, b'', value, script)
             txfund.rehash()
             fundings.append(txfund)
 
             # Spend transaction
             txspend = CTransaction()
             txspend.vout.append(
                 CTxOut(value - 1000, CScript([OP_TRUE])))
             txspend.vin.append(
                 CTxIn(COutPoint(txfund.sha256, 0), b''))
 
             # Sign the transaction
             txspend.vin[0].scriptSig = CScript(
                 b'\x01\x01\x51')  # PUSH1(0x01) OP_1
             pad_tx(txspend)
             txspend.rehash()
 
             return txspend
 
         # Non minimal tx are invalid.
         nonminimaltx = create_fund_and_spend_tx()
 
         tip = self.build_block(tip, fundings)
         node.p2p.send_blocks_and_test([tip], node)
 
         self.log.info("Trying to mine a minimaldata violation.")
         self.check_for_ban_on_rejected_block(
             self.build_block(tip, [nonminimaltx]), BADINPUTS_ERROR)
         self.log.info(
             "If we try to submit it by mempool or RPC we are banned")
         assert_raises_rpc_error(-26, MINIMALPUSH_ERROR,
                                 node.sendrawtransaction, ToHex(nonminimaltx))
         self.check_for_ban_on_rejected_tx(
             nonminimaltx, MINIMALPUSH_ERROR)
 
         self.log.info("Mine a normal block")
         tip = self.build_block(tip)
         node.p2p.send_blocks_and_test([tip], node)
 
 
 if __name__ == '__main__':
     MinimaldataTest().main()
diff --git a/test/functional/abc-op-reversebytes-activation.py b/test/functional/abc-op-reversebytes-activation.py
index a4f34008d..13692e49d 100755
--- a/test/functional/abc-op-reversebytes-activation.py
+++ b/test/functional/abc-op-reversebytes-activation.py
@@ -1,290 +1,291 @@
 #!/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.
 """
 This test checks the activation logic of OP_REVERSEBYTES.
 Derived from both abc-schnorrmultisig-activation.py (see https://reviews.bitcoinabc.org/D3736) and
 abc-schnorrmultisig.py
 """
 
 from test_framework.blocktools import (
     create_block,
     create_coinbase,
     create_tx_with_script,
     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 (
     CScript,
     OP_EQUAL,
     OP_REVERSEBYTES,
     OP_RETURN,
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, assert_raises_rpc_error
 
 
 # The upgrade activation time, which we artificially set far into the future.
 PHONON_START_TIME = 2000000000
 
 
 # Blocks with invalid scripts give this error:
 BAD_INPUTS_ERROR = 'blk-bad-inputs'
 
 # Pre-upgrade, we get a BAD_OPCODE error
 PRE_UPGRADE_BAD_OPCODE_ERROR = \
     'upgrade-conditional-script-failure (Opcode missing or not understood)'
 
 
 class OpReversebytesActivationTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
         self.block_heights = {}
         self.extra_args = [
-            ["-phononactivationtime={}".format(PHONON_START_TIME)]]
+            ["-phononactivationtime={}".format(PHONON_START_TIME),
+             "-acceptnonstdtxn=1"]]
 
     def bootstrap_p2p(self, *, num_connections=1):
         """Add a P2P connection to the node.
 
         Helper to connect and wait for version handshake."""
         for _ in range(num_connections):
             self.nodes[0].add_p2p_connection(P2PDataStore())
         self.nodes[0].p2p.wait_for_verack()
 
     def reconnect_p2p(self, **kwargs):
         """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(**kwargs)
 
     def get_best_block(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=(), n_time=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 n_time is None else n_time
 
         block = create_block(
             parent.sha256, create_coinbase(block_height), block_time)
         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 check_for_no_ban_on_rejected_tx(self, tx, reject_reason):
         """Check we are not disconnected when sending a txn that the node rejects."""
         self.nodes[0].p2p.send_txs_and_test(
             [tx], self.nodes[0], success=False, reject_reason=reject_reason)
 
     def check_for_ban_on_rejected_tx(self, tx, reject_reason=None):
         """Check we are disconnected when sending a txn that the node rejects.
 
         (Can't actually get banned, since bitcoind won't ban local peers.)"""
         self.nodes[0].p2p.send_txs_and_test(
             [tx], self.nodes[0], success=False, expect_disconnect=True, reject_reason=reject_reason)
         self.reconnect_p2p()
 
     def check_for_ban_on_rejected_block(self, block, reject_reason=None):
         """Check we are disconnected when sending a block that the node rejects.
 
         (Can't actually get banned, since bitcoind won't ban local peers.)"""
         self.nodes[0].p2p.send_blocks_and_test([block], self.nodes[0], success=False,
                                                reject_reason=reject_reason, expect_disconnect=True)
         self.reconnect_p2p()
 
     def run_test(self):
         node, = self.nodes
 
         self.bootstrap_p2p()
 
         tip = self.get_best_block(node)
 
         self.log.info("Create some blocks with OP_1 coinbase for spending.")
         blocks = []
         for _ in range(10):
             tip = self.build_block(tip)
             blocks.append(tip)
         node.p2p.send_blocks_and_test(blocks, node, success=True)
         spendable_outputs = [block.vtx[0] for block in blocks]
 
         self.log.info("Mature the blocks and get out of IBD.")
         node.generatetoaddress(100, node.get_deterministic_priv_key().address)
 
         tip = self.get_best_block(node)
 
         self.log.info(
             "Set up spending transactions to test and mine the funding transactions.")
 
         def create_fund_and_spend_tx():
             spend_from = spendable_outputs.pop()
             value = spend_from.vout[0].nValue
 
             # Reversed data
             data = bytes.fromhex('0123456789abcdef')
             rev_data = bytes(reversed(data))
 
             # Lockscript: provide a bytestring that reverses to X
             script = CScript([OP_REVERSEBYTES, rev_data, OP_EQUAL])
 
             # Fund transaction: REVERSEBYTES <reversed(x)> EQUAL
             tx_fund = create_tx_with_script(spend_from, 0, b'', value, script)
             tx_fund.rehash()
 
             # Spend transaction: <x>
             tx_spend = CTransaction()
             tx_spend.vout.append(
                 CTxOut(value - 1000, CScript([b'x' * 100, OP_RETURN])))
             tx_spend.vin.append(
                 CTxIn(COutPoint(tx_fund.sha256, 0), b''))
             tx_spend.vin[0].scriptSig = CScript([data])
             tx_spend.rehash()
 
             return tx_spend, tx_fund
 
         # Create funding/spending transaction pair
         tx_reversebytes_spend, tx_reversebytes_fund = create_fund_and_spend_tx()
 
         # Mine funding transaction into block. Pre-upgrade output scripts can have
         # OP_REVERSEBYTES and still be fully valid, but they cannot spend it.
         tip = self.build_block(tip, [tx_reversebytes_fund])
         node.p2p.send_blocks_and_test([tip], node)
 
         self.log.info("Start pre-upgrade tests")
 
         self.log.info(
             "Sending rejected transaction (bad opcode) via RPC (doesn't ban)")
         assert_raises_rpc_error(-26, PRE_UPGRADE_BAD_OPCODE_ERROR,
                                 node.sendrawtransaction, ToHex(tx_reversebytes_spend))
 
         self.log.info(
             "Sending rejected transaction (bad opcode) via net (no banning)")
         self.check_for_no_ban_on_rejected_tx(
             tx_reversebytes_spend, PRE_UPGRADE_BAD_OPCODE_ERROR)
 
         self.log.info(
             "Sending invalid transactions in blocks (bad inputs, and get banned)")
         self.check_for_ban_on_rejected_block(self.build_block(tip, [tx_reversebytes_spend]),
                                              BAD_INPUTS_ERROR)
 
         self.log.info("Start activation tests")
 
         self.log.info("Approach to just before upgrade activation")
         # Move our clock to the upgrade time so we will accept such
         # future-timestamped blocks.
         node.setmocktime(PHONON_START_TIME)
 
         # Mine six blocks with timestamp starting at PHONON_START_TIME-1
         blocks = []
         for i in range(-1, 5):
             tip = self.build_block(tip, n_time=PHONON_START_TIME + i)
             blocks.append(tip)
         node.p2p.send_blocks_and_test(blocks, node)
 
         # Ensure our MTP is PHONON_START_TIME-1, just before activation
         assert_equal(node.getblockchaininfo()['mediantime'],
                      PHONON_START_TIME - 1)
 
         self.log.info(
             "The next block will activate, but the activation block itself must follow old rules")
         self.check_for_ban_on_rejected_block(
             self.build_block(tip, [tx_reversebytes_spend]), BAD_INPUTS_ERROR)
 
         # Save pre-upgrade block, we will reorg based on this block later
         pre_upgrade_block = tip
 
         self.log.info("Mine the activation block itself")
         tip = self.build_block(tip, [])
         node.p2p.send_blocks_and_test([tip], node)
 
         self.log.info("We have activated!")
         # Ensure our MTP is PHONON_START_TIME, exactly at activation
         assert_equal(node.getblockchaininfo()['mediantime'], PHONON_START_TIME)
         # Ensure empty mempool
         assert_equal(node.getrawmempool(), [])
 
         # Save upgrade block, will invalidate and reconsider this later
         upgrade_block = tip
 
         self.log.info(
             "Submitting a new OP_REVERSEBYTES tx via net, and mining it in a block")
         # Send OP_REVERSEBYTES tx
         node.p2p.send_txs_and_test([tx_reversebytes_spend], node)
 
         # Verify OP_REVERSEBYTES tx is in mempool
         assert_equal(set(node.getrawmempool()), {tx_reversebytes_spend.hash})
 
         # Mine OP_REVERSEBYTES tx into block
         tip = self.build_block(tip, [tx_reversebytes_spend])
         node.p2p.send_blocks_and_test([tip], node)
 
         # Save post-upgrade block, will invalidate and reconsider this later
         post_upgrade_block = tip
 
         self.log.info("Start deactivation tests")
 
         self.log.info(
             "Invalidating the post-upgrade blocks returns OP_REVERSEBYTES transaction to mempool")
         node.invalidateblock(post_upgrade_block.hash)
         assert_equal(set(node.getrawmempool()), {
                      tx_reversebytes_spend.hash})
 
         self.log.info(
             "Invalidating the upgrade block evicts the OP_REVERSEBYTES transaction")
         node.invalidateblock(upgrade_block.hash)
         assert_equal(set(node.getrawmempool()), set())
 
         self.log.info("Return to our tip")
         node.reconsiderblock(upgrade_block.hash)
         node.reconsiderblock(post_upgrade_block.hash)
         assert_equal(node.getbestblockhash(), tip.hash)
         assert_equal(node.getrawmempool(), [])
 
         self.log.info(
             "Create an empty-block reorg that forks from pre-upgrade")
         tip = pre_upgrade_block
         blocks = []
         for _ in range(10):
             tip = self.build_block(tip)
             blocks.append(tip)
         node.p2p.send_blocks_and_test(blocks, node)
 
         self.log.info(
             "Transactions from orphaned blocks are sent into mempool ready to be mined again, "
             "including upgrade-dependent ones even though the fork deactivated and reactivated "
             "the upgrade.")
         assert_equal(set(node.getrawmempool()),
                      {tx_reversebytes_spend.hash})
         node.generatetoaddress(1, node.get_deterministic_priv_key().address)
         tip = self.get_best_block(node)
         assert (set(tx.rehash() for tx in tip.vtx) >=
                 {tx_reversebytes_spend.hash})
 
 
 if __name__ == '__main__':
     OpReversebytesActivationTest().main()
diff --git a/test/functional/abc-p2p-compactblocks.py b/test/functional/abc-p2p-compactblocks.py
index 11d30b903..f4311ed5a 100755
--- a/test/functional/abc-p2p-compactblocks.py
+++ b/test/functional/abc-p2p-compactblocks.py
@@ -1,361 +1,363 @@
 #!/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 ONE_MEGABYTE
 from test_framework.messages import (
     COutPoint,
     CTransaction,
     CTxIn,
     CTxOut,
     HeaderAndShortIDs,
     msg_cmpctblock,
     msg_sendcmpct,
     ser_compact_size,
 )
 from test_framework.mininode import (
     mininode_lock,
     P2PDataStore,
     P2PInterface,
 )
 from test_framework.script import CScript, 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, wait_until
 
 
 class PreviousSpendableOutput():
 
     def __init__(self, tx=CTransaction(), n=-1):
         self.tx = tx
         # the output we're spending
         self.n = n
 
 
 # TestP2PConn: A peer we use to send messages to bitcoind, and store responses.
 class TestP2PConn(P2PInterface):
 
     def __init__(self):
         self.last_sendcmpct = None
         self.last_cmpctblock = None
         self.last_getheaders = None
         self.last_headers = None
         super().__init__()
 
     def on_sendcmpct(self, message):
         self.last_sendcmpct = message
 
     def on_cmpctblock(self, message):
         self.last_cmpctblock = message
         self.last_cmpctblock.header_and_shortids.header.calc_sha256()
 
     def on_getheaders(self, message):
         self.last_getheaders = message
 
     def on_headers(self, message):
         self.last_headers = message
         for x in self.last_headers.headers:
             x.calc_sha256()
 
     def clear_block_data(self):
         with mininode_lock:
             self.last_sendcmpct = None
             self.last_cmpctblock = None
 
 
 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 = 16 * ONE_MEGABYTE
         self.extra_args = [['-whitelist=127.0.0.1',
                             '-limitancestorcount=999999',
                             '-limitancestorsize=999999',
                             '-limitdescendantcount=999999',
                             '-limitdescendantsize=999999',
                             '-maxmempool=99999',
-                            "-excessiveblocksize={}".format(self.excessive_block_size)]]
+                            '-excessiveblocksize={}'.format(
+                                self.excessive_block_size),
+                            '-acceptnonstdtxn=1']]
         # UBSAN will cause this test to timeout without this.
         self.rpc_timeout = 180
 
     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_tx, n, value, script=CScript([OP_TRUE])):
         tx = create_tx_with_script(spend_tx, n, b"", value, script)
         return tx
 
     def next_block(self, number, spend=None, script=CScript(
             [OP_TRUE]), block_size=0, extra_txns=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 enough 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))
                 pad_tx(tx)
                 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()
 
             # 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])
 
             # Add transaction until we reach the expected transaction count
             for _ in range(extra_txns):
                 self.add_transactions_to_block(block, [get_base_transaction()])
 
             # If we have a block size requirement, just fill
             # the block until we get there
             current_block_size = len(block.serialize())
             overage_bytes = 0
             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))
 
                 # Add padding to fill the block.
                 left_to_fill = block_size - current_block_size
 
                 # Don't go over the 1 mb limit for a txn
                 if left_to_fill > 500000:
                     # Make sure we eat up non-divisible by 100 amounts quickly
                     # Also keep transaction less than 1 MB
                     left_to_fill = 500000 + left_to_fill % 100
 
                 # Create the new transaction
                 tx = get_base_transaction()
                 pad_tx(tx, left_to_fill - overage_bytes)
                 if len(tx.serialize()) + current_block_size > block_size:
                     # Our padding was too big try again
                     overage_bytes += 1
                     continue
 
                 # 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]
         default_p2p = node.add_p2p_connection(P2PDataStore())
         test_p2p = node.add_p2p_connection(TestP2PConn())
 
         # 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]
 
         # shorthand for functions
         block = self.next_block
 
         # Create a new block
         block(0)
         save_spendable_output()
         default_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()
 
         # Get to one block of the May 15, 2018 HF activation
         for i in range(6):
             block(5100 + i)
             maturity_blocks.append(self.tip)
 
         # Send it all to the node at once.
         default_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())
 
         # Check that compact block also work for big blocks
         # Wait for SENDCMPCT
         def received_sendcmpct():
             return (test_p2p.last_sendcmpct is not None)
         wait_until(received_sendcmpct, timeout=30)
 
         sendcmpct = msg_sendcmpct()
         sendcmpct.version = 1
         sendcmpct.announce = True
         test_p2p.send_and_ping(sendcmpct)
 
         # Exchange headers
         def received_getheaders():
             return (test_p2p.last_getheaders is not None)
         wait_until(received_getheaders, timeout=30)
 
         # Return the favor
         test_p2p.send_message(test_p2p.last_getheaders)
 
         # Wait for the header list
         def received_headers():
             return (test_p2p.last_headers is not None)
         wait_until(received_headers, timeout=30)
 
         # It's like we know about the same headers !
         test_p2p.send_message(test_p2p.last_headers)
 
         # Send a block
         b1 = block(1, spend=out[0], block_size=ONE_MEGABYTE + 1)
         default_p2p.send_blocks_and_test([self.tip], node)
 
         # Checks the node to forward it via compact block
         def received_block():
             return (test_p2p.last_cmpctblock is not None)
         wait_until(received_block, timeout=30)
 
         # Was it our block ?
         cmpctblk_header = test_p2p.last_cmpctblock.header_and_shortids.header
         cmpctblk_header.calc_sha256()
         assert cmpctblk_header.sha256 == b1.sha256
 
         # Send a large block with numerous transactions.
         test_p2p.clear_block_data()
         b2 = block(2, spend=out[1], extra_txns=70000,
                    block_size=self.excessive_block_size - 1000)
         default_p2p.send_blocks_and_test([self.tip], node)
 
         # Checks the node forwards it via compact block
         wait_until(received_block, timeout=30)
 
         # Was it our block ?
         cmpctblk_header = test_p2p.last_cmpctblock.header_and_shortids.header
         cmpctblk_header.calc_sha256()
         assert cmpctblk_header.sha256 == b2.sha256
 
         # In order to avoid having to resend a ton of transactions, we invalidate
         # b2, which will send all its transactions in the mempool. Note that this
         # assumes reorgs will insert low-fee transactions back into the
         # mempool.
         node.invalidateblock(node.getbestblockhash())
 
         # Let's send a compact block and see if the node accepts it.
         # Let's modify b2 and use it so that we can reuse the mempool.
         tx = b2.vtx[0]
         tx.vout.append(CTxOut(0, CScript([random.randint(0, 256), OP_RETURN])))
         tx.rehash()
         b2.vtx[0] = tx
         b2.hashMerkleRoot = b2.calc_merkle_root()
         b2.solve()
 
         # Now we create the compact block and send it
         comp_block = HeaderAndShortIDs()
         comp_block.initialize_from_block(b2)
         test_p2p.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
 
         # Check that compact block is received properly
         assert int(node.getbestblockhash(), 16) == b2.sha256
 
 
 if __name__ == '__main__':
     FullBlockTest().main()
diff --git a/test/functional/abc-phonon-mempoolpolicy.py b/test/functional/abc-phonon-mempoolpolicy.py
index 5a2f071ec..139adebf1 100755
--- a/test/functional/abc-phonon-mempoolpolicy.py
+++ b/test/functional/abc-phonon-mempoolpolicy.py
@@ -1,282 +1,283 @@
 #!/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 ancestor and descendants policies around phonon-activation."""
 
 from test_framework.blocktools import (
     create_block,
     create_coinbase,
     create_tx_with_script,
     make_conform_to_ctor,
 )
 from test_framework.txtools import pad_tx
 from test_framework.messages import (
     CBlock,
     COutPoint,
     CTransaction,
     CTxIn,
     CTxOut,
     FromHex,
     ToHex,
 )
 from test_framework.mininode import (
     P2PDataStore,
 )
 from test_framework.script import (
     CScript,
     OP_TRUE
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, assert_raises_rpc_error
 
 # Phonon dummy activation time
 PHONON_START_TIME = 2000000000
 
 # Replay protection time needs to be moved beyond phonon activation
 REPLAY_PROTECTION_TIME = PHONON_START_TIME * 2
 
 PREFORK_MAX_ANCESTORS = 25
 PREFORK_MAX_DESCENDANTS = 25
 POSTFORK_MAX_ANCESTORS = 50
 POSTFORK_MAX_DESCENDANTS = 50
 
 LONG_MEMPOOL_ERROR = "too-long-mempool-chain"
 
 
 class PhononPolicyChangeTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
 
         self.block_heights = {}
         self.extra_args = [[
             "-phononactivationtime={}".format(PHONON_START_TIME),
             "-replayprotectionactivationtime={}".format(
-                REPLAY_PROTECTION_TIME)]]
+                REPLAY_PROTECTION_TIME),
+            "-acceptnonstdtxn=1"]]
 
     def bootstrap_p2p(self):
         self.nodes[0].add_p2p_connection(P2PDataStore())
         self.nodes[0].p2p.wait_for_verack()
 
     def get_best_block(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 check_for_no_ban_on_rejected_tx(self, tx, reject_reason):
         """Check we are not disconnected when sending a txn that the node rejects."""
         self.nodes[0].p2p.send_txs_and_test(
             [tx], self.nodes[0], success=False, reject_reason=reject_reason)
 
     def build_block(self, parent, transactions=(), n_time=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 n_time is None else n_time
 
         block = create_block(
             parent.sha256, create_coinbase(block_height), block_time)
         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 build_ancestor_chain(self, spend_from, num_ancestors):
         fee = 1000
         chain = [spend_from]
         for _ in range(num_ancestors):
             parent_tx = chain[-1]
             tx = create_tx_with_script(
                 parent_tx,
                 n=0,
                 amount=parent_tx.vout[0].nValue -
                 fee,
                 script_pub_key=CScript(
                     [OP_TRUE]))
             chain.append(tx)
 
         return chain[1:]
 
     def build_descendants_chain(self, spend_from, num_descendants):
         # -1 as parent counts toward descendants
         num_descendants -= 1
         fee = 1000
         descendants = []
 
         parent_tx = CTransaction()
         parent_tx.vin.append(
             CTxIn(
                 COutPoint(
                     spend_from.sha256,
                     0),
                 b'',
                 0xffffffff))
         amount = (spend_from.vout[0].nValue - fee) // num_descendants
 
         for _ in range(num_descendants):
             parent_tx.vout.append(CTxOut(amount, CScript([OP_TRUE])))
         pad_tx(parent_tx)
         parent_tx.rehash()
 
         for n in range(num_descendants):
             child_tx = create_tx_with_script(
                 parent_tx, n=n, amount=parent_tx.vout[0].nValue - fee)
             descendants.append(child_tx)
 
         assert(len(descendants) == num_descendants)
 
         return [parent_tx] + descendants
 
     def run_test(self):
         node, = self.nodes
 
         self.bootstrap_p2p()
 
         tip = self.get_best_block(node)
 
         self.log.info("Create some blocks with OP_1 coinbase for spending.")
         blocks = []
         for _ in range(10):
             tip = self.build_block(tip)
             blocks.append(tip)
         node.p2p.send_blocks_and_test(blocks, node, success=True)
         spendable_outputs = [block.vtx[0] for block in blocks]
 
         self.log.info("Mature the blocks and get out of IBD.")
         node.generatetoaddress(100, node.get_deterministic_priv_key().address)
 
         tip = self.get_best_block(node)
         self.log.info("Start pre-upgrade tests")
 
         # Test pre-upgrade max ancestor limit.
         # We create the full post-fork length chain for use later (+1 to test
         # too long chain)
         ancestors = self.build_ancestor_chain(
             spendable_outputs.pop(0), POSTFORK_MAX_ANCESTORS + 1)
         [node.sendrawtransaction(ToHex(tx))
          for tx in ancestors[:PREFORK_MAX_ANCESTORS]]
 
         self.log.info(
             "Sending rejected transaction (too many ancestors) via RPC")
         assert_raises_rpc_error(-26,
                                 LONG_MEMPOOL_ERROR,
                                 node.sendrawtransaction,
                                 ToHex(ancestors[PREFORK_MAX_ANCESTORS]))
 
         self.log.info(
             "Sending rejected transaction (too many ancestors) via net")
         self.check_for_no_ban_on_rejected_tx(
             ancestors[PREFORK_MAX_ANCESTORS], LONG_MEMPOOL_ERROR)
 
         # Test pre-upgrade max descendants limit
         # We create the full post-fork length chain for use later (+1 to test
         # too long chain)
         descendants = self.build_descendants_chain(
             spendable_outputs.pop(0), POSTFORK_MAX_DESCENDANTS + 1)
         [node.sendrawtransaction(ToHex(tx))
          for tx in descendants[:PREFORK_MAX_DESCENDANTS]]
 
         self.log.info(
             "Sending rejected transaction (too many descendants) via RPC")
         assert_raises_rpc_error(-26,
                                 LONG_MEMPOOL_ERROR,
                                 node.sendrawtransaction,
                                 ToHex(descendants[PREFORK_MAX_DESCENDANTS]))
 
         self.log.info(
             "Sending rejected transaction (too many descendants) via net")
         self.check_for_no_ban_on_rejected_tx(
             descendants[PREFORK_MAX_DESCENDANTS], LONG_MEMPOOL_ERROR)
 
         self.log.info("Start activation tests")
 
         self.log.info("Approach to just before upgrade activation")
         # Move our clock to the upgrade time so we will accept such
         # future-timestamped blocks.
         node.setmocktime(PHONON_START_TIME)
 
         # Mine six blocks with timestamp starting at PHONON_START_TIME-1
         blocks = []
         for i in range(-1, 5):
             tip = self.build_block(tip, n_time=PHONON_START_TIME + i)
             blocks.append(tip)
         node.p2p.send_blocks_and_test(blocks, node)
 
         # Ensure our MTP is PHONON_START_TIME-1, just before activation
         assert_equal(node.getblockchaininfo()['mediantime'],
                      PHONON_START_TIME - 1)
 
         self.log.info(
             "The next block will activate, but at the activation block itself must follow old rules")
 
         self.check_for_no_ban_on_rejected_tx(
             ancestors[PREFORK_MAX_ANCESTORS], LONG_MEMPOOL_ERROR)
         self.check_for_no_ban_on_rejected_tx(
             descendants[PREFORK_MAX_DESCENDANTS], LONG_MEMPOOL_ERROR)
 
         # Save pre-upgrade block, we will reorg based on this block later
         pre_upgrade_block = tip
 
         self.log.info("Mine the activation block itself")
         tip = self.build_block(tip, [])
         node.p2p.send_blocks_and_test([tip], node)
 
         self.log.info("We have activated!")
         # Ensure our MTP is PHONON_START_TIME, exactly at activation
         assert_equal(node.getblockchaininfo()['mediantime'], PHONON_START_TIME)
 
         # Test post-upgrade max ancestor limit
         [node.sendrawtransaction(
             ToHex(tx)) for tx in ancestors[PREFORK_MAX_ANCESTORS:POSTFORK_MAX_ANCESTORS]]
 
         self.log.info(
             "Sending rejected transaction (too many ancestors) via RPC")
         assert_raises_rpc_error(-26,
                                 LONG_MEMPOOL_ERROR,
                                 node.sendrawtransaction,
                                 ToHex(ancestors[-1]))
 
         self.log.info(
             "Sending rejected transaction (too many ancestors) via net")
         self.check_for_no_ban_on_rejected_tx(ancestors[-1], LONG_MEMPOOL_ERROR)
 
         # Test post-upgrade max descendants limit
         [node.sendrawtransaction(ToHex(
             tx)) for tx in descendants[PREFORK_MAX_DESCENDANTS:POSTFORK_MAX_DESCENDANTS]]
 
         self.log.info(
             "Sending rejected transaction (too many descendants) via RPC")
         assert_raises_rpc_error(-26,
                                 LONG_MEMPOOL_ERROR,
                                 node.sendrawtransaction,
                                 ToHex(descendants[-1]))
 
         self.log.info(
             "Sending rejected transaction (too many descendants) via net")
         self.check_for_no_ban_on_rejected_tx(
             descendants[-1], LONG_MEMPOOL_ERROR)
 
         self.log.info("Start deactivation tests")
 
         self.log.info(
             "Invalidating the pre-upgrade blocks trims the mempool back to old policies")
         node.invalidateblock(pre_upgrade_block.hash)
 
         assert_equal(PREFORK_MAX_ANCESTORS +
                      PREFORK_MAX_DESCENDANTS, len(node.getrawmempool()))
         expected = set([tx.hash for tx in ancestors[:PREFORK_MAX_ANCESTORS] +
                         descendants[:PREFORK_MAX_ANCESTORS]])
         assert_equal(set(node.getrawmempool()), expected)
 
 
 if __name__ == '__main__':
     PhononPolicyChangeTest().main()
diff --git a/test/functional/abc-replay-protection.py b/test/functional/abc-replay-protection.py
index f4b43c407..562fc619e 100755
--- a/test/functional/abc-replay-protection.py
+++ b/test/functional/abc-replay-protection.py
@@ -1,318 +1,320 @@
 #!/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 activation of UAHF and the different consensus
 related to this activation.
 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,
     make_conform_to_ctor,
 )
 from test_framework.key import CECKey
 from test_framework.messages import (
     COIN,
     COutPoint,
     CTransaction,
     CTxIn,
     CTxOut,
     ToHex,
 )
 from test_framework.mininode import P2PDataStore
 from test_framework.script import (
     CScript,
     OP_CHECKSIG,
     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
 
 # far into the future
 REPLAY_PROTECTION_START_TIME = 2000000000
 
 # Error due to invalid signature
 RPC_INVALID_SIGNATURE_ERROR = "mandatory-script-verify-flag-failed (Signature must be zero for failed CHECK(MULTI)SIG operation) (code 16)"
 
 
 class PreviousSpendableOutput(object):
 
     def __init__(self, tx=CTransaction(), n=-1):
         self.tx = tx
         self.n = n
 
 
 class ReplayProtectionTest(BitcoinTestFramework):
 
     def set_test_params(self):
         self.num_nodes = 1
         self.setup_clean_chain = True
         self.block_heights = {}
         self.tip = None
         self.blocks = {}
         self.extra_args = [['-whitelist=127.0.0.1',
-                            "-replayprotectionactivationtime={}".format(REPLAY_PROTECTION_START_TIME)]]
+                            "-replayprotectionactivationtime={}".format(
+                                REPLAY_PROTECTION_START_TIME),
+                            "-acceptnonstdtxn=1"]]
 
     def next_block(self, number):
         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()
         block = create_block(base_block_hash, coinbase, block_time)
 
         # 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())
         node.setmocktime(REPLAY_PROTECTION_START_TIME)
 
         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]
             block.vtx.extend(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
         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(100):
             out.append(get_spendable_output())
 
         # Generate a key pair to test P2SH sigops count
         private_key = CECKey()
         private_key.set_secretbytes(b"replayprotection")
         public_key = private_key.get_pubkey()
 
         # This is a little handier to use than the version in blocktools.py
         def create_fund_and_spend_tx(spend, forkvalue=0):
             # Fund transaction
             script = CScript([public_key, OP_CHECKSIG])
             txfund = create_tx_with_script(
                 spend.tx, spend.n, b'', 50 * COIN - 1000, script)
             txfund.rehash()
 
             # Spend transaction
             txspend = CTransaction()
             txspend.vout.append(CTxOut(50 * COIN - 2000, CScript([OP_TRUE])))
             txspend.vin.append(CTxIn(COutPoint(txfund.sha256, 0), b''))
 
             # Sign the transaction
             sighashtype = (forkvalue << 8) | SIGHASH_ALL | SIGHASH_FORKID
             sighash = SignatureHashForkId(
                 script, txspend, 0, sighashtype, 50 * COIN - 1000)
             sig = private_key.sign(sighash) + \
                 bytes(bytearray([SIGHASH_ALL | SIGHASH_FORKID]))
             txspend.vin[0].scriptSig = CScript([sig])
             txspend.rehash()
 
             return [txfund, txspend]
 
         def send_transaction_to_mempool(tx):
             tx_id = node.sendrawtransaction(ToHex(tx))
             assert tx_id in set(node.getrawmempool())
             return tx_id
 
         # Before the fork, no replay protection required to get in the mempool.
         txns = create_fund_and_spend_tx(out[0])
         send_transaction_to_mempool(txns[0])
         send_transaction_to_mempool(txns[1])
 
         # And txns get mined in a block properly.
         block(1)
         update_block(1, txns)
         node.p2p.send_blocks_and_test([self.tip], node)
 
         # Replay protected transactions are rejected.
         replay_txns = create_fund_and_spend_tx(out[1], 0xffdead)
         send_transaction_to_mempool(replay_txns[0])
         assert_raises_rpc_error(-26, RPC_INVALID_SIGNATURE_ERROR,
                                 node.sendrawtransaction, ToHex(replay_txns[1]))
 
         # And block containing them are rejected as well.
         block(2)
         update_block(2, replay_txns)
         node.p2p.send_blocks_and_test(
             [self.tip], node, success=False, reject_reason='blk-bad-inputs')
 
         # Rewind bad block
         tip(1)
 
         # Create a block that would activate the replay protection.
         bfork = block(5555)
         bfork.nTime = REPLAY_PROTECTION_START_TIME - 1
         update_block(5555, [])
         node.p2p.send_blocks_and_test([self.tip], node)
 
         activation_blocks = []
         for i in range(5):
             block(5100 + i)
             activation_blocks.append(self.tip)
         node.p2p.send_blocks_and_test(activation_blocks, node)
 
         # Check we are just before the activation time
         assert_equal(
             node.getblockchaininfo()['mediantime'],
             REPLAY_PROTECTION_START_TIME - 1)
 
         # We are just before the fork, replay protected txns still are rejected
         assert_raises_rpc_error(-26, RPC_INVALID_SIGNATURE_ERROR,
                                 node.sendrawtransaction, ToHex(replay_txns[1]))
 
         block(3)
         update_block(3, replay_txns)
         node.p2p.send_blocks_and_test(
             [self.tip], node, success=False, reject_reason='blk-bad-inputs')
 
         # Rewind bad block
         tip(5104)
 
         # Send some non replay protected txns in the mempool to check
         # they get cleaned at activation.
         txns = create_fund_and_spend_tx(out[2])
         send_transaction_to_mempool(txns[0])
         tx_id = send_transaction_to_mempool(txns[1])
 
         # Activate the replay protection
         block(5556)
         node.p2p.send_blocks_and_test([self.tip], node)
 
         # Check we just activated the replay protection
         assert_equal(
             node.getblockchaininfo()['mediantime'],
             REPLAY_PROTECTION_START_TIME)
 
         # Non replay protected transactions are not valid anymore,
         # so they should be removed from the mempool.
         assert tx_id not in set(node.getrawmempool())
 
         # Good old transactions are now invalid.
         send_transaction_to_mempool(txns[0])
         assert_raises_rpc_error(-26, RPC_INVALID_SIGNATURE_ERROR,
                                 node.sendrawtransaction, ToHex(txns[1]))
 
         # They also cannot be mined
         block(4)
         update_block(4, txns)
         node.p2p.send_blocks_and_test(
             [self.tip], node, success=False, reject_reason='blk-bad-inputs')
 
         # Rewind bad block
         tip(5556)
 
         # The replay protected transaction is now valid
         replay_tx0_id = send_transaction_to_mempool(replay_txns[0])
         replay_tx1_id = send_transaction_to_mempool(replay_txns[1])
 
         # Make sure the transaction are ready to be mined.
         tmpl = node.getblocktemplate()
 
         found_id0 = False
         found_id1 = False
 
         for txn in tmpl['transactions']:
             txid = txn['txid']
             if txid == replay_tx0_id:
                 found_id0 = True
             elif txid == replay_tx1_id:
                 found_id1 = True
 
         assert found_id0 and found_id1
 
         # And the mempool is still in good shape.
         assert replay_tx0_id in set(node.getrawmempool())
         assert replay_tx1_id in set(node.getrawmempool())
 
         # They also can also be mined
         block(5)
         update_block(5, replay_txns)
         node.p2p.send_blocks_and_test([self.tip], node)
 
         # Ok, now we check if a reorg work properly across the activation.
         postforkblockid = node.getbestblockhash()
         node.invalidateblock(postforkblockid)
         assert replay_tx0_id in set(node.getrawmempool())
         assert replay_tx1_id in set(node.getrawmempool())
 
         # Deactivating replay protection.
         forkblockid = node.getbestblockhash()
         node.invalidateblock(forkblockid)
         # The funding tx is not evicted from the mempool, since it's valid in
         # both sides of the fork
         assert replay_tx0_id in set(node.getrawmempool())
         assert replay_tx1_id not in set(node.getrawmempool())
 
         # Check that we also do it properly on deeper reorg.
         node.reconsiderblock(forkblockid)
         node.reconsiderblock(postforkblockid)
         node.invalidateblock(forkblockid)
         assert replay_tx0_id in set(node.getrawmempool())
         assert replay_tx1_id not in set(node.getrawmempool())
 
 
 if __name__ == '__main__':
     ReplayProtectionTest().main()
diff --git a/test/functional/abc-schnorr.py b/test/functional/abc-schnorr.py
index 10b5bb651..c3d83331f 100755
--- a/test/functional/abc-schnorr.py
+++ b/test/functional/abc-schnorr.py
@@ -1,246 +1,248 @@
 #!/usr/bin/env python3
 # Copyright (c) 2019 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """
 This tests the treatment of Schnorr transaction signatures:
 - acceptance both in mempool and blocks.
 - check banning for peers who send txns with 64 byte ECDSA DER sigs.
 
 Derived from a variety of functional tests.
 """
 
 from test_framework.blocktools import (
     create_block,
     create_coinbase,
     create_tx_with_script,
     make_conform_to_ctor,
 )
 from test_framework.key import CECKey
 from test_framework.messages import (
     CBlock,
     COutPoint,
     CTransaction,
     CTxIn,
     CTxOut,
     FromHex,
     ToHex,
 )
 from test_framework.mininode import (
     P2PDataStore,
 )
 from test_framework import schnorr
 from test_framework.script import (
     CScript,
     OP_1,
     OP_CHECKMULTISIG,
     OP_CHECKSIG,
     OP_TRUE,
     SIGHASH_ALL,
     SIGHASH_FORKID,
     SignatureHashForkId,
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_raises_rpc_error
 
 # A mandatory (bannable) error occurs when people pass Schnorr signatures
 # into OP_CHECKMULTISIG.
 SCHNORR_MULTISIG_ERROR = 'mandatory-script-verify-flag-failed (Signature cannot be 65 bytes in CHECKMULTISIG)'
 
 # A mandatory (bannable) error occurs when people send invalid Schnorr
 # sigs into OP_CHECKSIG.
 NULLFAIL_ERROR = 'mandatory-script-verify-flag-failed (Signature must be zero for failed CHECK(MULTI)SIG operation)'
 
 # Blocks with invalid scripts give this error:
 BADINPUTS_ERROR = 'blk-bad-inputs'
 
 
 # This 64-byte signature is used to test exclusion & banning according to
 # the above error messages.
 # Tests of real 64 byte ECDSA signatures can be found in script_tests.
 sig64 = b'\0' * 64
 
 
 class SchnorrTest(BitcoinTestFramework):
 
     def set_test_params(self):
         self.num_nodes = 1
         self.block_heights = {}
+        self.extra_args = [[
+            "-acceptnonstdtxn=1"]]
 
     def bootstrap_p2p(self, *, num_connections=1):
         """Add a P2P connection to the node.
 
         Helper to connect and wait for version handshake."""
         for _ in range(num_connections):
             self.nodes[0].add_p2p_connection(P2PDataStore())
 
     def reconnect_p2p(self, **kwargs):
         """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(**kwargs)
 
     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.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 check_for_ban_on_rejected_tx(self, tx, reject_reason=None):
         """Check we are disconnected when sending a txn that the node rejects.
 
         (Can't actually get banned, since bitcoind won't ban local peers.)"""
         self.nodes[0].p2p.send_txs_and_test(
             [tx], self.nodes[0], success=False, reject_reason=reject_reason, expect_disconnect=True)
         self.reconnect_p2p()
 
     def check_for_ban_on_rejected_block(self, block, reject_reason=None):
         """Check we are disconnected when sending a block that the node rejects.
 
         (Can't actually get banned, since bitcoind won't ban local peers.)"""
         self.nodes[0].p2p.send_blocks_and_test(
             [block], self.nodes[0], success=False, reject_reason=reject_reason, expect_disconnect=True)
         self.reconnect_p2p()
 
     def run_test(self):
         node, = self.nodes
 
         self.bootstrap_p2p()
 
         tip = self.getbestblock(node)
 
         self.log.info("Create some blocks with OP_1 coinbase for spending.")
         blocks = []
         for _ in range(10):
             tip = self.build_block(tip)
             blocks.append(tip)
         node.p2p.send_blocks_and_test(blocks, node, success=True)
         spendable_outputs = [block.vtx[0] for block in blocks]
 
         self.log.info("Mature the blocks and get out of IBD.")
         node.generatetoaddress(100, node.get_deterministic_priv_key().address)
 
         tip = self.getbestblock(node)
 
         self.log.info("Setting up spends to test and mining the fundings.")
         fundings = []
 
         # Generate a key pair
         privkeybytes = b"Schnorr!" * 4
         private_key = CECKey()
         private_key.set_secretbytes(privkeybytes)
         # get uncompressed public key serialization
         public_key = private_key.get_pubkey()
 
         def create_fund_and_spend_tx(multi=False, sig='schnorr'):
             spendfrom = spendable_outputs.pop()
 
             if multi:
                 script = CScript([OP_1, public_key, OP_1, OP_CHECKMULTISIG])
             else:
                 script = CScript([public_key, OP_CHECKSIG])
 
             value = spendfrom.vout[0].nValue
 
             # Fund transaction
             txfund = create_tx_with_script(spendfrom, 0, b'', value, script)
             txfund.rehash()
             fundings.append(txfund)
 
             # Spend transaction
             txspend = CTransaction()
             txspend.vout.append(
                 CTxOut(value - 1000, CScript([OP_TRUE])))
             txspend.vin.append(
                 CTxIn(COutPoint(txfund.sha256, 0), b''))
 
             # Sign the transaction
             sighashtype = SIGHASH_ALL | SIGHASH_FORKID
             hashbyte = bytes([sighashtype & 0xff])
             sighash = SignatureHashForkId(
                 script, txspend, 0, sighashtype, value)
             if sig == 'schnorr':
                 txsig = schnorr.sign(privkeybytes, sighash) + hashbyte
             elif sig == 'ecdsa':
                 txsig = private_key.sign(sighash) + hashbyte
             elif isinstance(sig, bytes):
                 txsig = sig + hashbyte
             if multi:
                 txspend.vin[0].scriptSig = CScript([b'', txsig])
             else:
                 txspend.vin[0].scriptSig = CScript([txsig])
             txspend.rehash()
 
             return txspend
 
         schnorrchecksigtx = create_fund_and_spend_tx()
         schnorrmultisigtx = create_fund_and_spend_tx(multi=True)
         ecdsachecksigtx = create_fund_and_spend_tx(sig='ecdsa')
         sig64checksigtx = create_fund_and_spend_tx(sig=sig64)
         sig64multisigtx = create_fund_and_spend_tx(multi=True, sig=sig64)
 
         tip = self.build_block(tip, fundings)
         node.p2p.send_blocks_and_test([tip], node)
 
         self.log.info("Typical ECDSA and Schnorr CHECKSIG are valid.")
         node.p2p.send_txs_and_test([schnorrchecksigtx, ecdsachecksigtx], node)
         # They get mined as usual.
         node.generatetoaddress(1, node.get_deterministic_priv_key().address)
         tip = self.getbestblock(node)
         # Make sure they are in the block, and mempool is now empty.
         txhashes = set([schnorrchecksigtx.hash, ecdsachecksigtx.hash])
         assert txhashes.issubset(tx.rehash() for tx in tip.vtx)
         assert not node.getrawmempool()
 
         self.log.info("Schnorr in multisig is rejected with mandatory error.")
         assert_raises_rpc_error(-26, SCHNORR_MULTISIG_ERROR,
                                 node.sendrawtransaction, ToHex(schnorrmultisigtx))
         # And it is banworthy.
         self.check_for_ban_on_rejected_tx(
             schnorrmultisigtx, SCHNORR_MULTISIG_ERROR)
         # And it can't be mined
         self.check_for_ban_on_rejected_block(
             self.build_block(tip, [schnorrmultisigtx]), BADINPUTS_ERROR)
 
         self.log.info("Bad 64-byte sig is rejected with mandatory error.")
         # In CHECKSIG it's invalid Schnorr and hence NULLFAIL.
         assert_raises_rpc_error(-26, NULLFAIL_ERROR,
                                 node.sendrawtransaction, ToHex(sig64checksigtx))
         # In CHECKMULTISIG it's invalid length and hence BAD_LENGTH.
         assert_raises_rpc_error(-26, SCHNORR_MULTISIG_ERROR,
                                 node.sendrawtransaction, ToHex(sig64multisigtx))
         # Sending these transactions is banworthy.
         self.check_for_ban_on_rejected_tx(sig64checksigtx, NULLFAIL_ERROR)
         self.check_for_ban_on_rejected_tx(
             sig64multisigtx, SCHNORR_MULTISIG_ERROR)
         # And they can't be mined either...
         self.check_for_ban_on_rejected_block(
             self.build_block(tip, [sig64checksigtx]), BADINPUTS_ERROR)
         self.check_for_ban_on_rejected_block(
             self.build_block(tip, [sig64multisigtx]), BADINPUTS_ERROR)
 
 
 if __name__ == '__main__':
     SchnorrTest().main()
diff --git a/test/functional/abc-schnorrmultisig.py b/test/functional/abc-schnorrmultisig.py
index 832faeb5d..d192a9d90 100755
--- a/test/functional/abc-schnorrmultisig.py
+++ b/test/functional/abc-schnorrmultisig.py
@@ -1,247 +1,248 @@
 #!/usr/bin/env python3
 # Copyright (c) 2019 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """
 This tests the  CHECKMULTISIG mode that uses Schnorr transaction signatures and
 repurposes the dummy element to indicate which signatures are being checked.
 - acceptance both in mempool and blocks.
 - check non-banning for peers who send invalid txns that would have been valid
 on the other side of the upgrade.
 - check banning of peers for some fully-invalid transactions.
 
 Derived from abc-schnorr.py
 """
 
 from test_framework.blocktools import (
     create_block,
     create_coinbase,
     create_tx_with_script,
     make_conform_to_ctor,
 )
 from test_framework.key import CECKey
 from test_framework.messages import (
     CBlock,
     COutPoint,
     CTransaction,
     CTxIn,
     CTxOut,
     FromHex,
     ToHex,
 )
 from test_framework.mininode import (
     P2PDataStore,
 )
 from test_framework import schnorr
 from test_framework.script import (
     CScript,
     OP_0,
     OP_1,
     OP_CHECKMULTISIG,
     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
 
 
 # ECDSA checkmultisig with non-null dummy are invalid since the new mode
 # refuses ECDSA.
 ECDSA_NULLDUMMY_ERROR = 'mandatory-script-verify-flag-failed (Only Schnorr signatures allowed in this operation)'
 
 # A mandatory (bannable) error occurs when people pass Schnorr signatures into
 # legacy OP_CHECKMULTISIG.
 SCHNORR_LEGACY_MULTISIG_ERROR = 'mandatory-script-verify-flag-failed (Signature cannot be 65 bytes in CHECKMULTISIG)'
 
 # Blocks with invalid scripts give this error:
 BADINPUTS_ERROR = 'blk-bad-inputs'
 
 
 # This 64-byte signature is used to test exclusion & banning according to
 # the above error messages.
 # Tests of real 64 byte ECDSA signatures can be found in script_tests.
 sig64 = b'\0' * 64
 
 
 class SchnorrMultisigTest(BitcoinTestFramework):
 
     def set_test_params(self):
         self.num_nodes = 1
         self.block_heights = {}
+        self.extra_args = [["-acceptnonstdtxn=1"]]
 
     def bootstrap_p2p(self, *, num_connections=1):
         """Add a P2P connection to the node.
 
         Helper to connect and wait for version handshake."""
         for _ in range(num_connections):
             self.nodes[0].add_p2p_connection(P2PDataStore())
 
     def reconnect_p2p(self, **kwargs):
         """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(**kwargs)
 
     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.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 check_for_ban_on_rejected_tx(self, tx, reject_reason=None):
         """Check we are disconnected when sending a txn that the node rejects.
 
         (Can't actually get banned, since bitcoind won't ban local peers.)"""
         self.nodes[0].p2p.send_txs_and_test(
             [tx], self.nodes[0], success=False, expect_disconnect=True, reject_reason=reject_reason)
         self.reconnect_p2p()
 
     def check_for_ban_on_rejected_block(self, block, reject_reason=None):
         """Check we are disconnected when sending a block that the node rejects.
 
         (Can't actually get banned, since bitcoind won't ban local peers.)"""
         self.nodes[0].p2p.send_blocks_and_test(
             [block], self.nodes[0], success=False, reject_reason=reject_reason, expect_disconnect=True)
         self.reconnect_p2p()
 
     def run_test(self):
         node, = self.nodes
 
         self.bootstrap_p2p()
 
         tip = self.getbestblock(node)
 
         self.log.info("Create some blocks with OP_1 coinbase for spending.")
         blocks = []
         for _ in range(10):
             tip = self.build_block(tip)
             blocks.append(tip)
         node.p2p.send_blocks_and_test(blocks, node, success=True)
         spendable_outputs = [block.vtx[0] for block in blocks]
 
         self.log.info("Mature the blocks and get out of IBD.")
         node.generatetoaddress(100, node.get_deterministic_priv_key().address)
 
         tip = self.getbestblock(node)
 
         self.log.info("Setting up spends to test and mining the fundings.")
         fundings = []
 
         # Generate a key pair
         privkeybytes = b"Schnorr!" * 4
         private_key = CECKey()
         private_key.set_secretbytes(privkeybytes)
         # get uncompressed public key serialization
         public_key = private_key.get_pubkey()
 
         def create_fund_and_spend_tx(dummy=OP_0, sigtype='ecdsa'):
             spendfrom = spendable_outputs.pop()
 
             script = CScript([OP_1, public_key, OP_1, OP_CHECKMULTISIG])
 
             value = spendfrom.vout[0].nValue
 
             # Fund transaction
             txfund = create_tx_with_script(spendfrom, 0, b'', value, script)
             txfund.rehash()
             fundings.append(txfund)
 
             # Spend transaction
             txspend = CTransaction()
             txspend.vout.append(
                 CTxOut(value - 1000, CScript([OP_TRUE])))
             txspend.vin.append(
                 CTxIn(COutPoint(txfund.sha256, 0), b''))
 
             # Sign the transaction
             sighashtype = SIGHASH_ALL | SIGHASH_FORKID
             hashbyte = bytes([sighashtype & 0xff])
             sighash = SignatureHashForkId(
                 script, txspend, 0, sighashtype, value)
             if sigtype == 'schnorr':
                 txsig = schnorr.sign(privkeybytes, sighash) + hashbyte
             elif sigtype == 'ecdsa':
                 txsig = private_key.sign(sighash) + hashbyte
             txspend.vin[0].scriptSig = CScript([dummy, txsig])
             txspend.rehash()
 
             return txspend
 
         # This is valid.
         ecdsa0tx = create_fund_and_spend_tx(OP_0, 'ecdsa')
 
         # This is invalid.
         ecdsa1tx = create_fund_and_spend_tx(OP_1, 'ecdsa')
 
         # This is invalid.
         schnorr0tx = create_fund_and_spend_tx(OP_0, 'schnorr')
 
         # This is valid.
         schnorr1tx = create_fund_and_spend_tx(OP_1, 'schnorr')
 
         tip = self.build_block(tip, fundings)
         node.p2p.send_blocks_and_test([tip], node)
 
         self.log.info("Send a legacy ECDSA multisig into mempool.")
         node.p2p.send_txs_and_test([ecdsa0tx], node)
         assert_equal(node.getrawmempool(), [ecdsa0tx.hash])
 
         self.log.info("Trying to mine a non-null-dummy ECDSA.")
         self.check_for_ban_on_rejected_block(
             self.build_block(tip, [ecdsa1tx]), BADINPUTS_ERROR)
         self.log.info(
             "If we try to submit it by mempool or RPC, it is rejected and we are banned")
         assert_raises_rpc_error(-26, ECDSA_NULLDUMMY_ERROR,
                                 node.sendrawtransaction, ToHex(ecdsa1tx))
         self.check_for_ban_on_rejected_tx(
             ecdsa1tx, ECDSA_NULLDUMMY_ERROR)
 
         self.log.info(
             "Submitting a Schnorr-multisig via net, and mining it in a block")
         node.p2p.send_txs_and_test([schnorr1tx], node)
         assert_equal(set(node.getrawmempool()), {
                      ecdsa0tx.hash, schnorr1tx.hash})
         tip = self.build_block(tip, [schnorr1tx])
         node.p2p.send_blocks_and_test([tip], node)
 
         self.log.info(
             "That legacy ECDSA multisig is still in mempool, let's mine it")
         assert_equal(node.getrawmempool(), [ecdsa0tx.hash])
         tip = self.build_block(tip, [ecdsa0tx])
         node.p2p.send_blocks_and_test([tip], node)
         assert_equal(node.getrawmempool(), [])
 
         self.log.info(
             "Trying Schnorr in legacy multisig is invalid and banworthy.")
         self.check_for_ban_on_rejected_tx(
             schnorr0tx, SCHNORR_LEGACY_MULTISIG_ERROR)
         self.check_for_ban_on_rejected_block(
             self.build_block(tip, [schnorr0tx]), BADINPUTS_ERROR)
 
 
 if __name__ == '__main__':
     SchnorrMultisigTest().main()
diff --git a/test/functional/abc-sigchecks-inputstandardness-activation.py b/test/functional/abc-sigchecks-inputstandardness-activation.py
index 2812f0b79..be3e6cf69 100755
--- a/test/functional/abc-sigchecks-inputstandardness-activation.py
+++ b/test/functional/abc-sigchecks-inputstandardness-activation.py
@@ -1,311 +1,312 @@
 #!/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 activation of per-input sigchecks limit standardness rule
 """
 
 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 (
     CScript,
     OP_CHECKDATASIG,
     OP_CHECKDATASIGVERIFY,
     OP_3DUP,
     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
 from collections import deque
 
 # Set test to run with sigchecks activation far in the future.
 SIGCHECKS_ACTIVATION_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 = SIGCHECKS_ACTIVATION_TIME * 2
 
 TX_INPUT_SIGCHECKS_ERROR = "non-mandatory-script-verify-flag (Input SigChecks limit exceeded) (code 64)"
 
 
 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_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 InputSigChecksActivationTest(BitcoinTestFramework):
 
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
         self.block_heights = {}
         self.extra_args = [["-phononactivationtime={}".format(
             SIGCHECKS_ACTIVATION_TIME),
             "-replayprotectionactivationtime={}".format(
-            REPLAY_PROTECTION_START_TIME), ]]
+            REPLAY_PROTECTION_START_TIME),
+            "-acceptnonstdtxn=1"]]
 
     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,) = self.nodes
         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)
         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)
 
         # To make compact and fast-to-verify transactions, we'll use
         # CHECKDATASIG over and over with the same data.
         # (Using the same stuff over and over again means we get to hit the
         # node's signature cache and don't need to make new signatures every
         # time.)
         cds_message = b''
         # r=1 and s=1 ecdsa, the minimum values.
         cds_signature = bytes.fromhex('3006020101020101')
         # Recovered pubkey
         cds_pubkey = bytes.fromhex(
             '03089b476b570d66fad5a20ae6188ebbaf793a4c2a228c65f3d79ee8111d56c932')
 
         fundings = []
 
         def make_spend(scriptpubkey, scriptsig):
             # Add a funding tx to fundings, and return a tx spending that using
             # scriptsig.
             self.log.debug(
                 "Gen tx with locking script {} unlocking script {} .".format(
                     scriptpubkey.hex(), scriptsig.hex()))
 
             # get funds locked with OP_1
             sourcetx = self.spendable_outputs.popleft()
             # make funding that forwards to scriptpubkey
             fundtx = create_transaction(sourcetx, scriptpubkey)
             fundings.append(fundtx)
 
             # make the spending
             tx = CTransaction()
             tx.vin.append(CTxIn(COutPoint(fundtx.sha256, 1), scriptsig))
             tx.vout.append(CTxOut(0, CScript([OP_RETURN])))
             pad_tx(tx)
             tx.rehash()
             return tx
 
         self.log.info("Generating txes used in this test")
 
         # "Good" txns that pass our rule:
 
         goodtxes = [
             # most dense allowed input -- 2 sigchecks with a 26-byte scriptsig.
             make_spend(CScript([cds_message,
                                 cds_pubkey,
                                 OP_3DUP,
                                 OP_CHECKDATASIGVERIFY,
                                 OP_CHECKDATASIGVERIFY]),
                        CScript([b'x' * 16,
                                 cds_signature])),
 
             # 4 sigchecks with a 112-byte scriptsig, just at the limit for this
             # sigchecks count.
             make_spend(CScript([cds_message,
                                 cds_pubkey,
                                 OP_3DUP,
                                 OP_CHECKDATASIGVERIFY,
                                 OP_3DUP,
                                 OP_CHECKDATASIGVERIFY,
                                 OP_3DUP,
                                 OP_CHECKDATASIGVERIFY,
                                 OP_CHECKDATASIGVERIFY]),
                        CScript([b'x' * 101,
                                 cds_signature])),
 
             # "nice" transaction - 1 sigcheck with 9-byte scriptsig.
             make_spend(CScript([cds_message, cds_pubkey, OP_CHECKDATASIG]), CScript(
                 [cds_signature])),
 
             # 1 sigcheck with 0-byte scriptsig.
             make_spend(CScript([cds_signature, cds_message,
                                 cds_pubkey, OP_CHECKDATASIG]), CScript([])),
         ]
 
         badtxes = [
             # "Bad" txns:
             # 2 sigchecks with a 25-byte scriptsig, just 1 byte too short.
             make_spend(CScript([cds_message,
                                 cds_pubkey,
                                 OP_3DUP,
                                 OP_CHECKDATASIGVERIFY,
                                 OP_CHECKDATASIGVERIFY]),
                        CScript([b'x' * 15,
                                 cds_signature])),
 
             # 4 sigchecks with a 111-byte scriptsig, just 1 byte too short.
             make_spend(CScript([cds_message,
                                 cds_pubkey,
                                 OP_3DUP,
                                 OP_CHECKDATASIGVERIFY,
                                 OP_3DUP,
                                 OP_CHECKDATASIGVERIFY,
                                 OP_3DUP,
                                 OP_CHECKDATASIGVERIFY,
                                 OP_CHECKDATASIGVERIFY]),
                        CScript([b'x' * 100,
                                 cds_signature])),
         ]
 
         goodtxids = set(t.hash for t in goodtxes)
         badtxids = set(t.hash for t in badtxes)
 
         self.log.info("Funding the txes")
         tip = self.build_block(tip, fundings)
         node.p2p.send_blocks_and_test([tip], node)
 
         # 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(SIGCHECKS_ACTIVATION_TIME + 10)
         # Mine six blocks with timestamp starting at
         # SIGCHECKS_ACTIVATION_TIME-1
         blocks = []
         for i in range(-1, 5):
             tip = self.build_block(tip, nTime=SIGCHECKS_ACTIVATION_TIME + i)
             blocks.append(tip)
         node.p2p.send_blocks_and_test(blocks, node)
         assert_equal(node.getblockchaininfo()[
                      'mediantime'], SIGCHECKS_ACTIVATION_TIME - 1)
 
         self.log.info(
             "The next block will activate, but the activation block itself must follow old rules")
 
         self.log.info("Send all the transactions just before upgrade")
 
         node.p2p.send_txs_and_test(goodtxes, node)
         node.p2p.send_txs_and_test(badtxes, node)
 
         assert_equal(set(node.getrawmempool()), goodtxids | badtxids)
 
         # ask the node to mine a block, it should include the bad txes.
         [blockhash] = node.generatetoaddress(
             1, node.get_deterministic_priv_key().address)
         assert_equal(set(node.getblock(blockhash, 1)[
                      'tx'][1:]), goodtxids | badtxids)
         assert_equal(node.getrawmempool(), [])
 
         # discard that block
         node.invalidateblock(blockhash)
         assert_equal(set(node.getrawmempool()), goodtxids | badtxids)
 
         self.log.info("Mine the activation block itself")
         tip = self.build_block(tip)
         node.p2p.send_blocks_and_test([tip], node)
 
         self.log.info("We have activated!")
         assert_equal(node.getblockchaininfo()[
                      'mediantime'], SIGCHECKS_ACTIVATION_TIME)
 
         self.log.info(
             "The high-sigchecks transactions got evicted but the good ones are still around")
         assert_equal(set(node.getrawmempool()), goodtxids)
 
         self.log.info(
             "Now the high-sigchecks transactions are rejected from mempool.")
         # try sending some of the bad txes again after the upgrade
         for tx in badtxes:
             check_for_no_ban_on_rejected_tx(node, tx, TX_INPUT_SIGCHECKS_ERROR)
             assert_raises_rpc_error(-26, TX_INPUT_SIGCHECKS_ERROR,
                                     node.sendrawtransaction, ToHex(tx))
 
         self.log.info("But they can still be mined!")
 
         # now make a block with all the txes, they still are accepted in
         # blocks!
         tip = self.build_block(tip, goodtxes + badtxes)
         node.p2p.send_blocks_and_test([tip], node)
 
         assert_equal(node.getbestblockhash(), tip.hash)
 
 
 if __name__ == '__main__':
     InputSigChecksActivationTest().main()
diff --git a/test/functional/abc-sigops-deactivation.py b/test/functional/abc-sigops-deactivation.py
index 45ee4bb5d..a08631c20 100755
--- a/test/functional/abc-sigops-deactivation.py
+++ b/test/functional/abc-sigops-deactivation.py
@@ -1,359 +1,359 @@
 #!/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, timeargs + ['-acceptnonstdtxn=0']]
+        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
index 08a7c1bc3..8be28ee25 100755
--- a/test/functional/abc-sigops-mempool-mining.py
+++ b/test/functional/abc-sigops-mempool-mining.py
@@ -1,329 +1,330 @@
 #!/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)]]
+            ["-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/feature_bip68_sequence.py b/test/functional/feature_bip68_sequence.py
index 7d45fbe9b..61701fb0c 100755
--- a/test/functional/feature_bip68_sequence.py
+++ b/test/functional/feature_bip68_sequence.py
@@ -1,494 +1,494 @@
 #!/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 BIP68 implementation."""
 
 import time
 
 from test_framework.blocktools import (
     create_block,
     create_coinbase,
 )
 from test_framework.messages import (
     COIN,
     COutPoint,
     CTransaction,
     CTxIn,
     CTxOut,
     FromHex,
     ToHex,
 )
 from test_framework.script import CScript
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.txtools import pad_tx
 from test_framework.util import (
     assert_equal,
     assert_greater_than,
     assert_raises_rpc_error,
     connect_nodes,
     disconnect_nodes,
     satoshi_round,
     sync_blocks,
 )
 
 SEQUENCE_LOCKTIME_DISABLE_FLAG = (1 << 31)
 # this means use time (0 means height)
 SEQUENCE_LOCKTIME_TYPE_FLAG = (1 << 22)
 # this is a bit-shift
 SEQUENCE_LOCKTIME_GRANULARITY = 9
 SEQUENCE_LOCKTIME_MASK = 0x0000ffff
 
 # RPC error for non-BIP68 final transactions
 NOT_FINAL_ERROR = "non-BIP68-final (code 64)"
 
 
 class BIP68Test(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
-        self.extra_args = [["-noparkdeepreorg", "-maxreorgdepth=-1"],
+        self.extra_args = [["-noparkdeepreorg", "-maxreorgdepth=-1", "-acceptnonstdtxn=1"],
                            ["-acceptnonstdtxn=0", "-maxreorgdepth=-1"]]
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def run_test(self):
         self.relayfee = self.nodes[0].getnetworkinfo()["relayfee"]
 
         # Generate some coins
         self.nodes[0].generate(110)
 
         self.log.info("Running test disable flag")
         self.test_disable_flag()
 
         self.log.info("Running test sequence-lock-confirmed-inputs")
         self.test_sequence_lock_confirmed_inputs()
 
         self.log.info("Running test sequence-lock-unconfirmed-inputs")
         self.test_sequence_lock_unconfirmed_inputs()
 
         self.log.info(
             "Running test BIP68 not consensus before versionbits activation")
         self.test_bip68_not_consensus()
 
         self.log.info("Activating BIP68 (and 112/113)")
         self.activateCSV()
 
         print("Verifying nVersion=2 transactions are standard.")
         print("Note that with current versions of bitcoin software, nVersion=2 transactions are always standard (independent of BIP68 activation status).")
         self.test_version2_relay()
 
         self.log.info("Passed")
 
     # Test that BIP68 is not in effect if tx version is 1, or if
     # the first sequence bit is set.
     def test_disable_flag(self):
         # Create some unconfirmed inputs
         new_addr = self.nodes[0].getnewaddress()
         # send 2 BCH
         self.nodes[0].sendtoaddress(new_addr, 2)
 
         utxos = self.nodes[0].listunspent(0, 0)
         assert len(utxos) > 0
 
         utxo = utxos[0]
 
         tx1 = CTransaction()
         value = int(satoshi_round(utxo["amount"] - self.relayfee) * COIN)
 
         # Check that the disable flag disables relative locktime.
         # If sequence locks were used, this would require 1 block for the
         # input to mature.
         sequence_value = SEQUENCE_LOCKTIME_DISABLE_FLAG | 1
         tx1.vin = [
             CTxIn(COutPoint(int(utxo["txid"], 16), utxo["vout"]), nSequence=sequence_value)]
         tx1.vout = [CTxOut(value, CScript([b'a']))]
         pad_tx(tx1)
 
         tx1_signed = self.nodes[0].signrawtransactionwithwallet(ToHex(tx1))[
             "hex"]
         tx1_id = self.nodes[0].sendrawtransaction(tx1_signed)
         tx1_id = int(tx1_id, 16)
 
         # This transaction will enable sequence-locks, so this transaction should
         # fail
         tx2 = CTransaction()
         tx2.nVersion = 2
         sequence_value = sequence_value & 0x7fffffff
         tx2.vin = [CTxIn(COutPoint(tx1_id, 0), nSequence=sequence_value)]
         tx2.vout = [CTxOut(int(value - self.relayfee * COIN), CScript([b'a']))]
         pad_tx(tx2)
         tx2.rehash()
 
         assert_raises_rpc_error(-26, NOT_FINAL_ERROR,
                                 self.nodes[0].sendrawtransaction, ToHex(tx2))
 
         # Setting the version back down to 1 should disable the sequence lock,
         # so this should be accepted.
         tx2.nVersion = 1
 
         self.nodes[0].sendrawtransaction(ToHex(tx2))
 
     # Calculate the median time past of a prior block ("confirmations" before
     # the current tip).
     def get_median_time_past(self, confirmations):
         block_hash = self.nodes[0].getblockhash(
             self.nodes[0].getblockcount() - confirmations)
         return self.nodes[0].getblockheader(block_hash)["mediantime"]
 
     # Test that sequence locks are respected for transactions spending
     # confirmed inputs.
     def test_sequence_lock_confirmed_inputs(self):
         # Create lots of confirmed utxos, and use them to generate lots of random
         # transactions.
         max_outputs = 50
         addresses = []
         while len(addresses) < max_outputs:
             addresses.append(self.nodes[0].getnewaddress())
         while len(self.nodes[0].listunspent()) < 200:
             import random
             random.shuffle(addresses)
             num_outputs = random.randint(1, max_outputs)
             outputs = {}
             for i in range(num_outputs):
                 outputs[addresses[i]] = random.randint(1, 20) * 0.01
             self.nodes[0].sendmany("", outputs)
             self.nodes[0].generate(1)
 
         utxos = self.nodes[0].listunspent()
 
         # Try creating a lot of random transactions.
         # Each time, choose a random number of inputs, and randomly set
         # some of those inputs to be sequence locked (and randomly choose
         # between height/time locking). Small random chance of making the locks
         # all pass.
         for i in range(400):
             # Randomly choose up to 10 inputs
             num_inputs = random.randint(1, 10)
             random.shuffle(utxos)
 
             # Track whether any sequence locks used should fail
             should_pass = True
 
             # Track whether this transaction was built with sequence locks
             using_sequence_locks = False
 
             tx = CTransaction()
             tx.nVersion = 2
             value = 0
             for j in range(num_inputs):
                 # this disables sequence locks
                 sequence_value = 0xfffffffe
 
                 # 50% chance we enable sequence locks
                 if random.randint(0, 1):
                     using_sequence_locks = True
 
                     # 10% of the time, make the input sequence value pass
                     input_will_pass = (random.randint(1, 10) == 1)
                     sequence_value = utxos[j]["confirmations"]
                     if not input_will_pass:
                         sequence_value += 1
                         should_pass = False
 
                     # Figure out what the median-time-past was for the confirmed input
                     # Note that if an input has N confirmations, we're going back N blocks
                     # from the tip so that we're looking up MTP of the block
                     # PRIOR to the one the input appears in, as per the BIP68
                     # spec.
                     orig_time = self.get_median_time_past(
                         utxos[j]["confirmations"])
                     # MTP of the tip
                     cur_time = self.get_median_time_past(0)
 
                     # can only timelock this input if it's not too old --
                     # otherwise use height
                     can_time_lock = True
                     if ((cur_time - orig_time)
                             >> SEQUENCE_LOCKTIME_GRANULARITY) >= SEQUENCE_LOCKTIME_MASK:
                         can_time_lock = False
 
                     # if time-lockable, then 50% chance we make this a time
                     # lock
                     if random.randint(0, 1) and can_time_lock:
                         # Find first time-lock value that fails, or latest one
                         # that succeeds
                         time_delta = sequence_value << SEQUENCE_LOCKTIME_GRANULARITY
                         if input_will_pass and time_delta > cur_time - orig_time:
                             sequence_value = (
                                 (cur_time - orig_time) >> SEQUENCE_LOCKTIME_GRANULARITY)
                         elif (not input_will_pass and time_delta <= cur_time - orig_time):
                             sequence_value = (
                                 (cur_time - orig_time) >> SEQUENCE_LOCKTIME_GRANULARITY) + 1
                         sequence_value |= SEQUENCE_LOCKTIME_TYPE_FLAG
                 tx.vin.append(
                     CTxIn(COutPoint(int(utxos[j]["txid"], 16), utxos[j]["vout"]), nSequence=sequence_value))
                 value += utxos[j]["amount"] * COIN
             # Overestimate the size of the tx - signatures should be less than
             # 120 bytes, and leave 50 for the output
             tx_size = len(ToHex(tx)) // 2 + 120 * num_inputs + 50
             tx.vout.append(
                 CTxOut(int(value - self.relayfee * tx_size * COIN / 1000), CScript([b'a'])))
             rawtx = self.nodes[0].signrawtransactionwithwallet(ToHex(tx))[
                 "hex"]
 
             if (using_sequence_locks and not should_pass):
                 # This transaction should be rejected
                 assert_raises_rpc_error(-26, NOT_FINAL_ERROR,
                                         self.nodes[0].sendrawtransaction, rawtx)
             else:
                 # This raw transaction should be accepted
                 self.nodes[0].sendrawtransaction(rawtx)
                 utxos = self.nodes[0].listunspent()
 
     # Test that sequence locks on unconfirmed inputs must have nSequence
     # height or time of 0 to be accepted.
     # Then test that BIP68-invalid transactions are removed from the mempool
     # after a reorg.
     def test_sequence_lock_unconfirmed_inputs(self):
         # Store height so we can easily reset the chain at the end of the test
         cur_height = self.nodes[0].getblockcount()
 
         # Create a mempool tx.
         txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 2)
         tx1 = FromHex(CTransaction(), self.nodes[0].getrawtransaction(txid))
         tx1.rehash()
 
         # As the fees are calculated prior to the transaction being signed,
         # there is some uncertainty that calculate fee provides the correct
         # minimal fee. Since regtest coins are free, let's go ahead and
         # increase the fee by an order of magnitude to ensure this test
         # passes.
         fee_multiplier = 10
 
         # Anyone-can-spend mempool tx.
         # Sequence lock of 0 should pass.
         tx2 = CTransaction()
         tx2.nVersion = 2
         tx2.vin = [CTxIn(COutPoint(tx1.sha256, 0), nSequence=0)]
         tx2.vout = [
             CTxOut(int(0), CScript([b'a']))]
         tx2.vout[0].nValue = tx1.vout[0].nValue - \
             fee_multiplier * self.nodes[0].calculate_fee(tx2)
         tx2_raw = self.nodes[0].signrawtransactionwithwallet(ToHex(tx2))["hex"]
         tx2 = FromHex(tx2, tx2_raw)
         tx2.rehash()
         self.nodes[0].sendrawtransaction(tx2_raw)
 
         # Create a spend of the 0th output of orig_tx with a sequence lock
         # of 1, and test what happens when submitting.
         # orig_tx.vout[0] must be an anyone-can-spend output
         def test_nonzero_locks(orig_tx, node, use_height_lock):
             sequence_value = 1
             if not use_height_lock:
                 sequence_value |= SEQUENCE_LOCKTIME_TYPE_FLAG
 
             tx = CTransaction()
             tx.nVersion = 2
             tx.vin = [
                 CTxIn(COutPoint(orig_tx.sha256, 0), nSequence=sequence_value)]
             tx.vout = [
                 CTxOut(int(orig_tx.vout[0].nValue - fee_multiplier * node.calculate_fee(tx)), CScript([b'a']))]
             pad_tx(tx)
             tx.rehash()
 
             if (orig_tx.hash in node.getrawmempool()):
                 # sendrawtransaction should fail if the tx is in the mempool
                 assert_raises_rpc_error(-26, NOT_FINAL_ERROR,
                                         node.sendrawtransaction, ToHex(tx))
             else:
                 # sendrawtransaction should succeed if the tx is not in the
                 # mempool
                 node.sendrawtransaction(ToHex(tx))
 
             return tx
 
         test_nonzero_locks(
             tx2, self.nodes[0], use_height_lock=True)
         test_nonzero_locks(
             tx2, self.nodes[0], use_height_lock=False)
 
         # Now mine some blocks, but make sure tx2 doesn't get mined.
         # Use prioritisetransaction to lower the effective feerate to 0
         self.nodes[0].prioritisetransaction(
             txid=tx2.hash, fee_delta=-fee_multiplier * self.nodes[0].calculate_fee(tx2))
         cur_time = int(time.time())
         for i in range(10):
             self.nodes[0].setmocktime(cur_time + 600)
             self.nodes[0].generate(1)
             cur_time += 600
 
         assert tx2.hash in self.nodes[0].getrawmempool()
 
         test_nonzero_locks(
             tx2, self.nodes[0], use_height_lock=True)
         test_nonzero_locks(
             tx2, self.nodes[0], use_height_lock=False)
 
         # Mine tx2, and then try again
         self.nodes[0].prioritisetransaction(
             txid=tx2.hash, fee_delta=fee_multiplier * self.nodes[0].calculate_fee(tx2))
 
         # Advance the time on the node so that we can test timelocks
         self.nodes[0].setmocktime(cur_time + 600)
         self.nodes[0].generate(1)
         assert tx2.hash not in self.nodes[0].getrawmempool()
 
         # Now that tx2 is not in the mempool, a sequence locked spend should
         # succeed
         tx3 = test_nonzero_locks(
             tx2, self.nodes[0], use_height_lock=False)
         assert tx3.hash in self.nodes[0].getrawmempool()
 
         self.nodes[0].generate(1)
         assert tx3.hash not in self.nodes[0].getrawmempool()
 
         # One more test, this time using height locks
         tx4 = test_nonzero_locks(
             tx3, self.nodes[0], use_height_lock=True)
         assert tx4.hash in self.nodes[0].getrawmempool()
 
         # Now try combining confirmed and unconfirmed inputs
         tx5 = test_nonzero_locks(
             tx4, self.nodes[0], use_height_lock=True)
         assert tx5.hash not in self.nodes[0].getrawmempool()
 
         utxos = self.nodes[0].listunspent()
         tx5.vin.append(
             CTxIn(COutPoint(int(utxos[0]["txid"], 16), utxos[0]["vout"]), nSequence=1))
         tx5.vout[0].nValue += int(utxos[0]["amount"] * COIN)
         raw_tx5 = self.nodes[0].signrawtransactionwithwallet(ToHex(tx5))["hex"]
 
         assert_raises_rpc_error(-26, NOT_FINAL_ERROR,
                                 self.nodes[0].sendrawtransaction, raw_tx5)
 
         # Test mempool-BIP68 consistency after reorg
         #
         # State of the transactions in the last blocks:
         # ... -> [ tx2 ] ->  [ tx3 ]
         #         tip-1        tip
         # And currently tx4 is in the mempool.
         #
         # If we invalidate the tip, tx3 should get added to the mempool, causing
         # tx4 to be removed (fails sequence-lock).
         self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
         assert tx4.hash not in self.nodes[0].getrawmempool()
         assert tx3.hash in self.nodes[0].getrawmempool()
 
         # Now mine 2 empty blocks to reorg out the current tip (labeled tip-1 in
         # diagram above).
         # This would cause tx2 to be added back to the mempool, which in turn causes
         # tx3 to be removed.
         tip = int(self.nodes[0].getblockhash(
             self.nodes[0].getblockcount() - 1), 16)
         height = self.nodes[0].getblockcount()
         for i in range(2):
             block = create_block(tip, create_coinbase(height), cur_time)
             block.nVersion = 3
             block.rehash()
             block.solve()
             tip = block.sha256
             height += 1
             self.nodes[0].submitblock(ToHex(block))
             cur_time += 1
 
         mempool = self.nodes[0].getrawmempool()
         assert tx3.hash not in mempool
         assert tx2.hash in mempool
 
         # Reset the chain and get rid of the mocktimed-blocks
         self.nodes[0].setmocktime(0)
         self.nodes[0].invalidateblock(
             self.nodes[0].getblockhash(cur_height + 1))
         self.nodes[0].generate(10)
 
     def get_csv_status(self):
         height = self.nodes[0].getblockchaininfo()['blocks']
         return height >= 576
 
     # Make sure that BIP68 isn't being used to validate blocks, prior to
     # versionbits activation.  If more blocks are mined prior to this test
     # being run, then it's possible the test has activated the soft fork, and
     # this test should be moved to run earlier, or deleted.
     def test_bip68_not_consensus(self):
         assert_equal(self.get_csv_status(), False)
         txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 2)
 
         tx1 = FromHex(CTransaction(), self.nodes[0].getrawtransaction(txid))
         tx1.rehash()
 
         # Make an anyone-can-spend transaction
         tx2 = CTransaction()
         tx2.nVersion = 1
         tx2.vin = [CTxIn(COutPoint(tx1.sha256, 0), nSequence=0)]
         tx2.vout = [
             CTxOut(int(tx1.vout[0].nValue - self.relayfee * COIN), CScript([b'a']))]
 
         # sign tx2
         tx2_raw = self.nodes[0].signrawtransactionwithwallet(ToHex(tx2))["hex"]
         tx2 = FromHex(tx2, tx2_raw)
         pad_tx(tx2)
         tx2.rehash()
 
         self.nodes[0].sendrawtransaction(ToHex(tx2))
 
         # Now make an invalid spend of tx2 according to BIP68
         # 100 block relative locktime
         sequence_value = 100
 
         tx3 = CTransaction()
         tx3.nVersion = 2
         tx3.vin = [CTxIn(COutPoint(tx2.sha256, 0), nSequence=sequence_value)]
         tx3.vout = [
             CTxOut(int(tx2.vout[0].nValue - self.relayfee * COIN), CScript([b'a']))]
         pad_tx(tx3)
         tx3.rehash()
 
         assert_raises_rpc_error(-26, NOT_FINAL_ERROR,
                                 self.nodes[0].sendrawtransaction, ToHex(tx3))
 
         # make a block that violates bip68; ensure that the tip updates
         tip = int(self.nodes[0].getbestblockhash(), 16)
         block = create_block(
             tip, create_coinbase(self.nodes[0].getblockcount() + 1))
         block.nVersion = 3
         block.vtx.extend(
             sorted([tx1, tx2, tx3], key=lambda tx: tx.get_id()))
         block.hashMerkleRoot = block.calc_merkle_root()
         block.rehash()
         block.solve()
 
         self.nodes[0].submitblock(ToHex(block))
         assert_equal(self.nodes[0].getbestblockhash(), block.hash)
 
     def activateCSV(self):
         # activation should happen at block height 576
         csv_activation_height = 576
         height = self.nodes[0].getblockcount()
         assert_greater_than(csv_activation_height - height, 1)
         self.nodes[0].generate(csv_activation_height - height - 1)
         assert_equal(self.get_csv_status(), False)
         disconnect_nodes(self.nodes[0], self.nodes[1])
         self.nodes[0].generate(1)
         assert_equal(self.get_csv_status(), True)
         # We have a block that has CSV activated, but we want to be at
         # the activation point, so we invalidate the tip.
         self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
         connect_nodes(self.nodes[0], self.nodes[1])
         sync_blocks(self.nodes)
 
     # Use self.nodes[1] to test that version 2 transactions are standard.
     def test_version2_relay(self):
         inputs = []
         outputs = {self.nodes[1].getnewaddress(): 1.0}
         rawtx = self.nodes[1].createrawtransaction(inputs, outputs)
         rawtxfund = self.nodes[1].fundrawtransaction(rawtx)['hex']
         tx = FromHex(CTransaction(), rawtxfund)
         tx.nVersion = 2
         tx_signed = self.nodes[1].signrawtransactionwithwallet(ToHex(tx))[
             "hex"]
         self.nodes[1].sendrawtransaction(tx_signed)
 
 
 if __name__ == '__main__':
     BIP68Test().main()
diff --git a/test/functional/feature_block.py b/test/functional/feature_block.py
index 727c92a4e..d0da97d36 100755
--- a/test/functional/feature_block.py
+++ b/test/functional/feature_block.py
@@ -1,1162 +1,1164 @@
 #!/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."""
 import copy
 import struct
 import time
 
 from test_framework.blocktools import (
     create_block,
     create_coinbase,
     create_tx_with_script,
     make_conform_to_ctor,
 )
 from test_framework.cdefs import LEGACY_MAX_BLOCK_SIZE
 from test_framework.key import CECKey
 from test_framework.messages import (
     CBlock,
     COIN,
     COutPoint,
     CTransaction,
     CTxIn,
     CTxOut,
     uint256_from_compact,
     uint256_from_str,
 )
 from test_framework.mininode import P2PDataStore
 from test_framework.script import (
     CScript,
     OP_ELSE,
     OP_ENDIF,
     OP_FALSE,
     OP_IF,
     OP_INVALIDOPCODE,
     OP_RETURN,
     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
 
 
 #  Use this class for tests that require behavior other than normal "mininode" behavior.
 #  For now, it is used to serialize a bloated varint (b64).
 
 
 class CBrokenBlock(CBlock):
     def initialize(self, base_block):
         self.vtx = copy.deepcopy(base_block.vtx)
         self.hashMerkleRoot = self.calc_merkle_root()
 
     def serialize(self):
         r = b""
         r += super(CBlock, self).serialize()
         r += struct.pack("<BQ", 255, len(self.vtx))
         for tx in self.vtx:
             r += tx.serialize()
         return r
 
     def normal_serialize(self):
         return super().serialize()
 
 
 class FullBlockTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
         self.setup_clean_chain = True
-        self.extra_args = [['-noparkdeepreorg', '-maxreorgdepth=-1']]
+        # This is a consensus block test, we don't care about tx policy
+        self.extra_args = [['-noparkdeepreorg',
+                            '-maxreorgdepth=-1', '-acceptnonstdtxn=1']]
 
     def run_test(self):
         node = self.nodes[0]  # convenience reference to the node
 
         self.bootstrap_p2p()  # Add one p2p connection to the node
 
         self.block_heights = {}
         self.coinbase_key = CECKey()
         self.coinbase_key.set_secretbytes(b"horsebattery")
         self.coinbase_pubkey = self.coinbase_key.get_pubkey()
         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(99):
             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 couple of blocks on top (which output is spent is
         # in parentheses):
         #     genesis -> b1 (0) -> b2 (1)
         b1 = self.next_block(1, spend=out[0])
         self.save_spendable_output()
 
         b2 = self.next_block(2, spend=out[1])
         self.save_spendable_output()
 
         self.sync_blocks([b1, b2])
 
         # Fork like this:
         #
         #     genesis -> b1 (0) -> b2 (1)
         #                      \-> b3 (1)
         #
         # Nothing should happen at this point. We saw b2 first so it takes
         # priority.
         self.log.info("Don't reorg to a chain of the same length")
         self.move_tip(1)
         b3 = self.next_block(3, spend=out[1])
         txout_b3 = b3.vtx[1]
         self.sync_blocks([b3], False)
 
         # Now we add another block to make the alternative chain longer.
         #
         #     genesis -> b1 (0) -> b2 (1)
         #                      \-> b3 (1) -> b4 (2)
         self.log.info("Reorg to a longer chain")
         b4 = self.next_block(4, spend=out[2])
         self.sync_blocks([b4])
 
         # ... and back to the first chain.
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
         #                      \-> b3 (1) -> b4 (2)
         self.move_tip(2)
         b5 = self.next_block(5, spend=out[2])
         self.save_spendable_output()
         self.sync_blocks([b5], False)
 
         self.log.info("Reorg back to the original chain")
         b6 = self.next_block(6, spend=out[3])
         self.sync_blocks([b6], True)
 
         # Try to create a fork that double-spends
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
         #                                          \-> b7 (2) -> b8 (4)
         #                      \-> b3 (1) -> b4 (2)
         self.log.info(
             "Reject a chain with a double spend, even if it is longer")
         self.move_tip(5)
         b7 = self.next_block(7, spend=out[2])
         self.sync_blocks([b7], False)
 
         b8 = self.next_block(8, spend=out[4])
         self.sync_blocks([b8], False, reconnect=True)
 
         # Try to create a block that has too much fee
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
         #                                                    \-> b9 (4)
         #                      \-> b3 (1) -> b4 (2)
         self.log.info(
             "Reject a block where the miner creates too much coinbase reward")
         self.move_tip(6)
         b9 = self.next_block(9, spend=out[4], additional_coinbase_value=1)
         self.sync_blocks([b9], success=False,
                          reject_reason='bad-cb-amount', reconnect=True)
 
         # Create a fork that ends in a block with too much fee (the one that causes the reorg)
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
         #                                          \-> b10 (3) -> b11 (4)
         #                      \-> b3 (1) -> b4 (2)
         self.log.info(
             "Reject a chain where the miner creates too much coinbase reward, even if the chain is longer")
         self.move_tip(5)
         b10 = self.next_block(10, spend=out[3])
         self.sync_blocks([b10], False)
 
         b11 = self.next_block(11, spend=out[4], additional_coinbase_value=1)
         self.sync_blocks([b11], success=False,
                          reject_reason='bad-cb-amount', reconnect=True)
 
         # Try again, but with a valid fork first
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
         #                                          \-> b12 (3) -> b13 (4) -> b14 (5)
         #                      \-> b3 (1) -> b4 (2)
         self.log.info(
             "Reject a chain where the miner creates too much coinbase reward, even if the chain is longer (on a forked chain)")
         self.move_tip(5)
         b12 = self.next_block(12, spend=out[3])
         self.save_spendable_output()
         b13 = self.next_block(13, spend=out[4])
         self.save_spendable_output()
         b14 = self.next_block(14, spend=out[5], additional_coinbase_value=1)
         self.sync_blocks([b12, b13, b14], success=False,
                          reject_reason='bad-cb-amount', reconnect=True)
 
         # New tip should be b13.
         assert_equal(node.getbestblockhash(), b13.hash)
 
         self.log.info("Skipped sigops tests")
         # tests were moved to feature_block_sigops.py
         self.move_tip(13)
         b15 = self.next_block(15)
         self.save_spendable_output()
         self.sync_blocks([b15], True)
 
         # Attempt to spend a transaction created on a different fork
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
         #                                          \-> b12 (3) -> b13 (4) -> b15 (5) -> b17 (b3.vtx[1])
         #                      \-> b3 (1) -> b4 (2)
         self.log.info("Reject a block with a spend from a re-org'ed out tx")
         self.move_tip(15)
         b17 = self.next_block(17, spend=txout_b3)
         self.sync_blocks([b17], success=False,
                          reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
 
         # Attempt to spend a transaction created on a different fork (on a fork this time)
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
         #                                          \-> b12 (3) -> b13 (4) -> b15 (5)
         #                                                                \-> b18 (b3.vtx[1]) -> b19 (6)
         #                      \-> b3 (1) -> b4 (2)
         self.log.info(
             "Reject a block with a spend from a re-org'ed out tx (on a forked chain)")
         self.move_tip(13)
         b18 = self.next_block(18, spend=txout_b3)
         self.sync_blocks([b18], False)
 
         b19 = self.next_block(19, spend=out[6])
         self.sync_blocks([b19], success=False,
                          reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
 
         # Attempt to spend a coinbase at depth too low
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
         #                                          \-> b12 (3) -> b13 (4) -> b15 (5) -> b20 (7)
         #                      \-> b3 (1) -> b4 (2)
         self.log.info("Reject a block spending an immature coinbase.")
         self.move_tip(15)
         b20 = self.next_block(20, spend=out[7])
         self.sync_blocks([b20], success=False,
                          reject_reason='bad-txns-premature-spend-of-coinbase')
 
         # Attempt to spend a coinbase at depth too low (on a fork this time)
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
         #                                          \-> b12 (3) -> b13 (4) -> b15 (5)
         #                                                                \-> b21 (6) -> b22 (5)
         #                      \-> b3 (1) -> b4 (2)
         self.log.info(
             "Reject a block spending an immature coinbase (on a forked chain)")
         self.move_tip(13)
         b21 = self.next_block(21, spend=out[6])
         self.sync_blocks([b21], False)
 
         b22 = self.next_block(22, spend=out[5])
         self.sync_blocks([b22], success=False,
                          reject_reason='bad-txns-premature-spend-of-coinbase')
 
         # Create a block on either side of LEGACY_MAX_BLOCK_SIZE and make sure its accepted/rejected
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
         #                                          \-> b12 (3) -> b13 (4) -> b15 (5) -> b23 (6)
         #                                                                           \-> b24 (6) -> b25 (7)
         #                      \-> b3 (1) -> b4 (2)
         self.log.info("Accept a block of size LEGACY_MAX_BLOCK_SIZE")
         self.move_tip(15)
         b23 = self.next_block(23, spend=out[6])
         tx = CTransaction()
         script_length = LEGACY_MAX_BLOCK_SIZE - len(b23.serialize()) - 69
         script_output = CScript([b'\x00' * script_length])
         tx.vout.append(CTxOut(0, script_output))
         tx.vin.append(CTxIn(COutPoint(b23.vtx[1].sha256, 0)))
         b23 = self.update_block(23, [tx])
         # Make sure the math above worked out to produce a max-sized block
         assert_equal(len(b23.serialize()), LEGACY_MAX_BLOCK_SIZE)
         self.sync_blocks([b23], True)
         self.save_spendable_output()
 
         # Create blocks with a coinbase input script size out of range
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
         #                                          \-> b12 (3) -> b13 (4) -> b15 (5) -> b23 (6) -> b30 (7)
         #                                                                           \-> ... (6) -> ... (7)
         #                      \-> b3 (1) -> b4 (2)
         self.log.info(
             "Reject a block with coinbase input script size out of range")
         self.move_tip(15)
         b26 = self.next_block(26, spend=out[6])
         b26.vtx[0].vin[0].scriptSig = b'\x00'
         b26.vtx[0].rehash()
         # update_block causes the merkle root to get updated, even with no new
         # transactions, and updates the required state.
         b26 = self.update_block(26, [])
         self.sync_blocks([b26], success=False,
                          reject_reason='bad-cb-length', reconnect=True)
 
         # Extend the b26 chain to make sure bitcoind isn't accepting b26
         b27 = self.next_block(27, spend=out[7])
         self.sync_blocks([b27], False)
 
         # Now try a too-large-coinbase script
         self.move_tip(15)
         b28 = self.next_block(28, spend=out[6])
         b28.vtx[0].vin[0].scriptSig = b'\x00' * 101
         b28.vtx[0].rehash()
         b28 = self.update_block(28, [])
         self.sync_blocks([b28], success=False,
                          reject_reason='bad-cb-length', reconnect=True)
 
         # Extend the b28 chain to make sure bitcoind isn't accepting b28
         b29 = self.next_block(29, spend=out[7])
         self.sync_blocks([b29], False)
 
         # b30 has a max-sized coinbase scriptSig.
         self.move_tip(23)
         b30 = self.next_block(30)
         b30.vtx[0].vin[0].scriptSig = b'\x00' * 100
         b30.vtx[0].rehash()
         b30 = self.update_block(30, [])
         self.sync_blocks([b30], True)
         self.save_spendable_output()
 
         self.log.info("Skipped sigops tests")
         # tests were moved to feature_block_sigops.py
         b31 = self.next_block(31)
         self.save_spendable_output()
         b33 = self.next_block(33)
         self.save_spendable_output()
         b35 = self.next_block(35)
         self.save_spendable_output()
         self.sync_blocks([b31, b33, b35], True)
 
         # Check spending of a transaction in a block which failed to connect
         #
         # b6  (3)
         # b12 (3) -> b13 (4) -> b15 (5) -> b23 (6) -> b30 (7) -> b31 (8) -> b33 (9) -> b35 (10)
         #                                                                                     \-> b37 (11)
         #                                                                                     \-> b38 (11/37)
         #
 
         # save 37's spendable output, but then double-spend out11 to invalidate
         # the block
         self.log.info(
             "Reject a block spending transaction from a block which failed to connect")
         self.move_tip(35)
         b37 = self.next_block(37, spend=out[11])
         txout_b37 = b37.vtx[1]
         tx = self.create_and_sign_transaction(out[11], 0)
         b37 = self.update_block(37, [tx])
         self.sync_blocks([b37], success=False,
                          reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
 
         # attempt to spend b37's first non-coinbase tx, at which point b37 was
         # still considered valid
         self.move_tip(35)
         b38 = self.next_block(38, spend=txout_b37)
         self.sync_blocks([b38], success=False,
                          reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
 
         self.log.info("Skipped sigops tests")
         # tests were moved to feature_block_sigops.py
         self.move_tip(35)
         b39 = self.next_block(39)
         self.save_spendable_output()
         b41 = self.next_block(41)
         self.sync_blocks([b39, b41], True)
 
         # Fork off of b39 to create a constant base again
         #
         # b23 (6) -> b30 (7) -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13)
         #                                                                  \-> b41 (12)
         #
         self.move_tip(39)
         b42 = self.next_block(42, spend=out[12])
         self.save_spendable_output()
 
         b43 = self.next_block(43, spend=out[13])
         self.save_spendable_output()
         self.sync_blocks([b42, b43], True)
 
         # Test a number of really invalid scenarios
         #
         #  -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13) -> b44 (14)
         #                                                                                   \-> ??? (15)
 
         # The next few blocks are going to be created "by hand" since they'll do funky things, such as having
         # the first transaction be non-coinbase, etc.  The purpose of b44 is to
         # make sure this works.
         self.log.info("Build block 44 manually")
         height = self.block_heights[self.tip.sha256] + 1
         coinbase = create_coinbase(height, self.coinbase_pubkey)
         b44 = CBlock()
         b44.nTime = self.tip.nTime + 1
         b44.hashPrevBlock = self.tip.sha256
         b44.nBits = 0x207fffff
         b44.vtx.append(coinbase)
         b44.hashMerkleRoot = b44.calc_merkle_root()
         b44.solve()
         self.tip = b44
         self.block_heights[b44.sha256] = height
         self.blocks[44] = b44
         self.sync_blocks([b44], True)
 
         self.log.info("Reject a block with a non-coinbase as the first tx")
         non_coinbase = self.create_tx(out[15], 0, 1)
         b45 = CBlock()
         b45.nTime = self.tip.nTime + 1
         b45.hashPrevBlock = self.tip.sha256
         b45.nBits = 0x207fffff
         b45.vtx.append(non_coinbase)
         b45.hashMerkleRoot = b45.calc_merkle_root()
         b45.calc_sha256()
         b45.solve()
         self.block_heights[b45.sha256] = self.block_heights[
             self.tip.sha256] + 1
         self.tip = b45
         self.blocks[45] = b45
         self.sync_blocks([b45], success=False,
                          reject_reason='bad-cb-missing', reconnect=True)
 
         self.log.info("Reject a block with no transactions")
         self.move_tip(44)
         b46 = CBlock()
         b46.nTime = b44.nTime + 1
         b46.hashPrevBlock = b44.sha256
         b46.nBits = 0x207fffff
         b46.vtx = []
         b46.hashMerkleRoot = 0
         b46.solve()
         self.block_heights[b46.sha256] = self.block_heights[b44.sha256] + 1
         self.tip = b46
         assert 46 not in self.blocks
         self.blocks[46] = b46
         self.sync_blocks([b46], success=False,
                          reject_reason='bad-cb-missing', reconnect=True)
 
         self.log.info("Reject a block with invalid work")
         self.move_tip(44)
         b47 = self.next_block(47, solve=False)
         target = uint256_from_compact(b47.nBits)
         while b47.sha256 < target:
             b47.nNonce += 1
             b47.rehash()
         self.sync_blocks([b47], False, request_block=False)
 
         self.log.info("Reject a block with a timestamp >2 hours in the future")
         self.move_tip(44)
         b48 = self.next_block(48, solve=False)
         b48.nTime = int(time.time()) + 60 * 60 * 3
         b48.solve()
         self.sync_blocks([b48], False, request_block=False)
 
         self.log.info("Reject a block with invalid merkle hash")
         self.move_tip(44)
         b49 = self.next_block(49)
         b49.hashMerkleRoot += 1
         b49.solve()
         self.sync_blocks([b49], success=False,
                          reject_reason='bad-txnmrklroot', reconnect=True)
 
         self.log.info("Reject a block with incorrect POW limit")
         self.move_tip(44)
         b50 = self.next_block(50)
         b50.nBits = b50.nBits - 1
         b50.solve()
         self.sync_blocks([b50], False, request_block=False, reconnect=True)
 
         self.log.info("Reject a block with two coinbase transactions")
         self.move_tip(44)
         b51 = self.next_block(51)
         cb2 = create_coinbase(51, self.coinbase_pubkey)
         b51 = self.update_block(51, [cb2])
         self.sync_blocks([b51], success=False,
                          reject_reason='bad-tx-coinbase', reconnect=True)
 
         self.log.info("Reject a block with duplicate transactions")
         self.move_tip(44)
         b52 = self.next_block(52, spend=out[15])
         b52 = self.update_block(52, [b52.vtx[1]])
         self.sync_blocks([b52], success=False,
                          reject_reason='tx-duplicate', reconnect=True)
 
         # Test block timestamps
         #  -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15)
         #                                                                                   \-> b54 (15)
         #
         self.move_tip(43)
         b53 = self.next_block(53, spend=out[14])
         self.sync_blocks([b53], False)
         self.save_spendable_output()
 
         self.log.info("Reject a block with timestamp before MedianTimePast")
         b54 = self.next_block(54, spend=out[15])
         b54.nTime = b35.nTime - 1
         b54.solve()
         self.sync_blocks([b54], False, request_block=False)
 
         # valid timestamp
         self.move_tip(53)
         b55 = self.next_block(55, spend=out[15])
         b55.nTime = b35.nTime
         self.update_block(55, [])
         self.sync_blocks([b55], True)
         self.save_spendable_output()
 
         # Test Merkle tree malleability
         #
         # -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57p2 (16)
         #                                                \-> b57   (16)
         #                                                \-> b56p2 (16)
         #                                                \-> b56   (16)
         #
         # Merkle tree malleability (CVE-2012-2459): repeating sequences of transactions in a block without
         #                           affecting the merkle root of a block, while still invalidating it.
         #                           See:  src/consensus/merkle.h
         #
         #  b57 has three txns:  coinbase, tx, tx1.  The merkle root computation will duplicate tx.
         #  Result:  OK
         #
         #  b56 copies b57 but duplicates tx1 and does not recalculate the block hash.  So it has a valid merkle
         #  root but duplicate transactions.
         #  Result:  Fails
         #
         #  b57p2 has six transactions in its merkle tree:
         #       - coinbase, tx, tx1, tx2, tx3, tx4
         #  Merkle root calculation will duplicate as necessary.
         #  Result:  OK.
         #
         #  b56p2 copies b57p2 but adds both tx3 and tx4.  The purpose of the test is to make sure the code catches
         #  duplicate txns that are not next to one another with the "bad-txns-duplicate" error (which indicates
         #  that the error was caught early, avoiding a DOS vulnerability.)
 
         # b57 - a good block with 2 txs, don't submit until end
         self.move_tip(55)
         b57 = self.next_block(57)
         tx = self.create_and_sign_transaction(out[16], 1)
         tx1 = self.create_tx(tx, 0, 1)
         b57 = self.update_block(57, [tx, tx1])
 
         # b56 - copy b57, add a duplicate tx
         self.log.info(
             "Reject a block with a duplicate transaction in the Merkle Tree (but with a valid Merkle Root)")
         self.move_tip(55)
         b56 = copy.deepcopy(b57)
         self.blocks[56] = b56
         assert_equal(len(b56.vtx), 3)
         b56 = self.update_block(56, [b57.vtx[2]])
         assert_equal(b56.hash, b57.hash)
         self.sync_blocks([b56], success=False,
                          reject_reason='bad-txns-duplicate', reconnect=True)
 
         # b57p2 - a good block with 6 tx'es, don't submit until end
         self.move_tip(55)
         b57p2 = self.next_block("57p2")
         tx = self.create_and_sign_transaction(out[16], 1)
         tx1 = self.create_tx(tx, 0, 1)
         tx2 = self.create_tx(tx1, 0, 1)
         tx3 = self.create_tx(tx2, 0, 1)
         tx4 = self.create_tx(tx3, 0, 1)
         b57p2 = self.update_block("57p2", [tx, tx1, tx2, tx3, tx4])
 
         # b56p2 - copy b57p2, duplicate two non-consecutive tx's
         self.log.info(
             "Reject a block with two duplicate transactions in the Merkle Tree (but with a valid Merkle Root)")
         self.move_tip(55)
         b56p2 = copy.deepcopy(b57p2)
         self.blocks["b56p2"] = b56p2
         assert_equal(len(b56p2.vtx), 6)
         b56p2 = self.update_block("b56p2", b56p2.vtx[4:6], reorder=False)
         assert_equal(b56p2.hash, b57p2.hash)
         self.sync_blocks([b56p2], success=False,
                          reject_reason='bad-txns-duplicate', reconnect=True)
 
         self.move_tip("57p2")
         self.sync_blocks([b57p2], True)
 
         self.move_tip(57)
         # The tip is not updated because 57p2 seen first
         self.sync_blocks([b57], False)
         self.save_spendable_output()
 
         # Test a few invalid tx types
         #
         # -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17)
         #                                                                                    \-> ??? (17)
         #
 
         # tx with prevout.n out of range
         self.log.info(
             "Reject a block with a transaction with prevout.n out of range")
         self.move_tip(57)
         b58 = self.next_block(58, spend=out[17])
         tx = CTransaction()
         assert(len(out[17].vout) < 42)
         tx.vin.append(
             CTxIn(COutPoint(out[17].sha256, 42), CScript([OP_TRUE]), 0xffffffff))
         tx.vout.append(CTxOut(0, b""))
         pad_tx(tx)
         tx.calc_sha256()
         b58 = self.update_block(58, [tx])
         self.sync_blocks([b58], success=False,
                          reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
 
         # tx with output value > input value
         self.log.info(
             "Reject a block with a transaction with outputs > inputs")
         self.move_tip(57)
         b59 = self.next_block(59)
         tx = self.create_and_sign_transaction(out[17], 51 * COIN)
         b59 = self.update_block(59, [tx])
         self.sync_blocks([b59], success=False,
                          reject_reason='bad-txns-in-belowout', reconnect=True)
 
         # reset to good chain
         self.move_tip(57)
         b60 = self.next_block(60, spend=out[17])
         self.sync_blocks([b60], True)
         self.save_spendable_output()
 
         # Test BIP30
         #
         # -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17)
         #                                                                                    \-> b61 (18)
         #
         # Blocks are not allowed to contain a transaction whose id matches that of an earlier,
         # not-fully-spent transaction in the same chain. To test, make identical coinbases;
         # the second one should be rejected.
         #
         self.log.info(
             "Reject a block with a transaction with a duplicate hash of a previous transaction (BIP30)")
         self.move_tip(60)
         b61 = self.next_block(61, spend=out[18])
         # Equalize the coinbases
         b61.vtx[0].vin[0].scriptSig = b60.vtx[0].vin[0].scriptSig
         b61.vtx[0].rehash()
         b61 = self.update_block(61, [])
         assert_equal(b60.vtx[0].serialize(), b61.vtx[0].serialize())
         self.sync_blocks([b61], success=False,
                          reject_reason='bad-txns-BIP30', reconnect=True)
 
         # Test tx.isFinal is properly rejected (not an exhaustive tx.isFinal test, that should be in data-driven transaction tests)
         #
         #   -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17)
         #                                                                                     \-> b62 (18)
         #
         self.log.info(
             "Reject a block with a transaction with a nonfinal locktime")
         self.move_tip(60)
         b62 = self.next_block(62)
         tx = CTransaction()
         tx.nLockTime = 0xffffffff  # this locktime is non-final
         # don't set nSequence
         tx.vin.append(CTxIn(COutPoint(out[18].sha256, 0)))
         tx.vout.append(CTxOut(0, CScript([OP_TRUE])))
         assert tx.vin[0].nSequence < 0xffffffff
         tx.calc_sha256()
         b62 = self.update_block(62, [tx])
         self.sync_blocks([b62], success=False,
                          reject_reason='bad-txns-nonfinal')
 
         # Test a non-final coinbase is also rejected
         #
         #   -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17)
         #                                                                                     \-> b63 (-)
         #
         self.log.info(
             "Reject a block with a coinbase transaction with a nonfinal locktime")
         self.move_tip(60)
         b63 = self.next_block(63)
         b63.vtx[0].nLockTime = 0xffffffff
         b63.vtx[0].vin[0].nSequence = 0xDEADBEEF
         b63.vtx[0].rehash()
         b63 = self.update_block(63, [])
         self.sync_blocks([b63], success=False,
                          reject_reason='bad-txns-nonfinal')
 
         #  This checks that a block with a bloated VARINT between the block_header and the array of tx such that
         #  the block is > LEGACY_MAX_BLOCK_SIZE with the bloated varint, but <= LEGACY_MAX_BLOCK_SIZE without the bloated varint,
         #  does not cause a subsequent, identical block with canonical encoding to be rejected.  The test does not
         #  care whether the bloated block is accepted or rejected; it only cares that the second block is accepted.
         #
         #  What matters is that the receiving node should not reject the bloated block, and then reject the canonical
         #  block on the basis that it's the same as an already-rejected block (which would be a consensus failure.)
         #
         #  -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18)
         #                                                                                        \
         #                                                                                         b64a (18)
         #  b64a is a bloated block (non-canonical varint)
         #  b64 is a good block (same as b64 but w/ canonical varint)
         #
         self.log.info(
             "Accept a valid block even if a bloated version of the block has previously been sent")
         self.move_tip(60)
         regular_block = self.next_block("64a", spend=out[18])
 
         # make it a "broken_block," with non-canonical serialization
         b64a = CBrokenBlock(regular_block)
         b64a.initialize(regular_block)
         self.blocks["64a"] = b64a
         self.tip = b64a
         tx = CTransaction()
 
         # use canonical serialization to calculate size
         script_length = LEGACY_MAX_BLOCK_SIZE - \
             len(b64a.normal_serialize()) - 69
         script_output = CScript([b'\x00' * script_length])
         tx.vout.append(CTxOut(0, script_output))
         tx.vin.append(CTxIn(COutPoint(b64a.vtx[1].sha256, 0)))
         b64a = self.update_block("64a", [tx])
         assert_equal(len(b64a.serialize()), LEGACY_MAX_BLOCK_SIZE + 8)
         self.sync_blocks([b64a], success=False,
                          reject_reason='non-canonical ReadCompactSize(): iostream error')
 
         # bitcoind doesn't disconnect us for sending a bloated block, but if we subsequently
         # resend the header message, it won't send us the getdata message again. Just
         # disconnect and reconnect and then call sync_blocks.
         # TODO: improve this test to be less dependent on P2P DOS behaviour.
         node.disconnect_p2ps()
         self.reconnect_p2p()
 
         self.move_tip(60)
         b64 = CBlock(b64a)
         b64.vtx = copy.deepcopy(b64a.vtx)
         assert_equal(b64.hash, b64a.hash)
         assert_equal(len(b64.serialize()), LEGACY_MAX_BLOCK_SIZE)
         self.blocks[64] = b64
         b64 = self.update_block(64, [])
         self.sync_blocks([b64], True)
         self.save_spendable_output()
 
         # Spend an output created in the block itself
         #
         # -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19)
         #
         self.log.info(
             "Accept a block with a transaction spending an output created in the same block")
         self.move_tip(64)
         b65 = self.next_block(65)
         tx1 = self.create_and_sign_transaction(out[19], out[19].vout[0].nValue)
         tx2 = self.create_and_sign_transaction(tx1, 0)
         b65 = self.update_block(65, [tx1, tx2])
         self.sync_blocks([b65], True)
         self.save_spendable_output()
 
         # Attempt to double-spend a transaction created in a block
         #
         # -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19)
         #                                                                                    \-> b67 (20)
         #
         #
         self.log.info(
             "Reject a block with a transaction double spending a transaction created in the same block")
         self.move_tip(65)
         b67 = self.next_block(67)
         tx1 = self.create_and_sign_transaction(out[20], out[20].vout[0].nValue)
         tx2 = self.create_and_sign_transaction(tx1, 1)
         tx3 = self.create_and_sign_transaction(tx1, 2)
         b67 = self.update_block(67, [tx1, tx2, tx3])
         self.sync_blocks([b67], success=False,
                          reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
 
         # More tests of block subsidy
         #
         # -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19) -> b69 (20)
         #                                                                                    \-> b68 (20)
         #
         # b68 - coinbase with an extra 10 satoshis,
         #       creates a tx that has 9 satoshis from out[20] go to fees
         #       this fails because the coinbase is trying to claim 1 satoshi too much in fees
         #
         # b69 - coinbase with extra 10 satoshis, and a tx that gives a 10 satoshi fee
         #       this succeeds
         #
         self.log.info(
             "Reject a block trying to claim too much subsidy in the coinbase transaction")
         self.move_tip(65)
         b68 = self.next_block(68, additional_coinbase_value=10)
         tx = self.create_and_sign_transaction(
             out[20], out[20].vout[0].nValue - 9)
         b68 = self.update_block(68, [tx])
         self.sync_blocks([b68], success=False,
                          reject_reason='bad-cb-amount', reconnect=True)
 
         self.log.info(
             "Accept a block claiming the correct subsidy in the coinbase transaction")
         self.move_tip(65)
         b69 = self.next_block(69, additional_coinbase_value=10)
         tx = self.create_and_sign_transaction(
             out[20], out[20].vout[0].nValue - 10)
         self.update_block(69, [tx])
         self.sync_blocks([b69], True)
         self.save_spendable_output()
 
         # Test spending the outpoint of a non-existent transaction
         #
         # -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19) -> b69 (20)
         #                                                                                    \-> b70 (21)
         #
         self.log.info(
             "Reject a block containing a transaction spending from a non-existent input")
         self.move_tip(69)
         b70 = self.next_block(70, spend=out[21])
         bogus_tx = CTransaction()
         bogus_tx.sha256 = uint256_from_str(
             b"23c70ed7c0506e9178fc1a987f40a33946d4ad4c962b5ae3a52546da53af0c5c")
         tx = CTransaction()
         tx.vin.append(CTxIn(COutPoint(bogus_tx.sha256, 0), b"", 0xffffffff))
         tx.vout.append(CTxOut(1, b""))
         pad_tx(tx)
         b70 = self.update_block(70, [tx])
         self.sync_blocks([b70], success=False,
                          reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
 
         # Test accepting an invalid block which has the same hash as a valid one (via merkle tree tricks)
         #
         #  -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19) -> b69 (20) -> b72 (21)
         #                                                                                      \-> b71 (21)
         #
         # b72 is a good block.
         # b71 is a copy of 72, but re-adds one of its transactions.  However,
         # it has the same hash as b72.
         self.log.info(
             "Reject a block containing a duplicate transaction but with the same Merkle root (Merkle tree malleability")
         self.move_tip(69)
         b72 = self.next_block(72)
         tx1 = self.create_and_sign_transaction(out[21], 2)
         tx2 = self.create_and_sign_transaction(tx1, 1)
         b72 = self.update_block(72, [tx1, tx2])  # now tip is 72
         b71 = copy.deepcopy(b72)
         # add duplicate last transaction
         b71.vtx.append(b72.vtx[-1])
         # b71 builds off b69
         self.block_heights[b71.sha256] = self.block_heights[b69.sha256] + 1
         self.blocks[71] = b71
 
         assert_equal(len(b71.vtx), 4)
         assert_equal(len(b72.vtx), 3)
         assert_equal(b72.sha256, b71.sha256)
 
         self.move_tip(71)
         self.sync_blocks([b71], success=False,
                          reject_reason='bad-txns-duplicate', reconnect=True)
 
         self.move_tip(72)
         self.sync_blocks([b72], True)
         self.save_spendable_output()
 
         self.log.info("Skipped sigops tests")
         # tests were moved to feature_block_sigops.py
         b75 = self.next_block(75)
         self.save_spendable_output()
         b76 = self.next_block(76)
         self.save_spendable_output()
         self.sync_blocks([b75, b76], True)
 
         # Test transaction resurrection
         #
         # -> b77 (24) -> b78 (25) -> b79 (26)
         #            \-> b80 (25) -> b81 (26) -> b82 (27)
         #
         #    b78 creates a tx, which is spent in b79. After b82, both should be in mempool
         #
         #    The tx'es must be unsigned and pass the node's mempool policy.  It is unsigned for the
         #    rather obscure reason that the Python signature code does not distinguish between
         #    Low-S and High-S values (whereas the bitcoin code has custom code which does so);
         #    as a result of which, the odds are 50% that the python code will use the right
         #    value and the transaction will be accepted into the mempool. Until we modify the
         #    test framework to support low-S signing, we are out of luck.
         #
         #    To get around this issue, we construct transactions which are not signed and which
         #    spend to OP_TRUE.  If the standard-ness rules change, this test would need to be
         #    updated.  (Perhaps to spend to a P2SH OP_TRUE script)
         self.log.info("Test transaction resurrection during a re-org")
         self.move_tip(76)
         b77 = self.next_block(77)
         tx77 = self.create_and_sign_transaction(out[24], 10 * COIN)
         b77 = self.update_block(77, [tx77])
         self.sync_blocks([b77], True)
         self.save_spendable_output()
 
         b78 = self.next_block(78)
         tx78 = self.create_tx(tx77, 0, 9 * COIN)
         b78 = self.update_block(78, [tx78])
         self.sync_blocks([b78], True)
 
         b79 = self.next_block(79)
         tx79 = self.create_tx(tx78, 0, 8 * COIN)
         b79 = self.update_block(79, [tx79])
         self.sync_blocks([b79], True)
 
         # mempool should be empty
         assert_equal(len(self.nodes[0].getrawmempool()), 0)
 
         self.move_tip(77)
         b80 = self.next_block(80, spend=out[25])
         self.sync_blocks([b80], False, request_block=False)
         self.save_spendable_output()
 
         b81 = self.next_block(81, spend=out[26])
         # other chain is same length
         self.sync_blocks([b81], False, request_block=False)
         self.save_spendable_output()
 
         b82 = self.next_block(82, spend=out[27])
         # now this chain is longer, triggers re-org
         self.sync_blocks([b82], True)
         self.save_spendable_output()
 
         # now check that tx78 and tx79 have been put back into the peer's
         # mempool
         mempool = self.nodes[0].getrawmempool()
         assert_equal(len(mempool), 2)
         assert tx78.hash in mempool
         assert tx79.hash in mempool
 
         # Test invalid opcodes in dead execution paths.
         #
         #  -> b81 (26) -> b82 (27) -> b83 (28)
         #
         self.log.info(
             "Accept a block with invalid opcodes in dead execution paths")
         b83 = self.next_block(83)
         op_codes = [OP_IF, OP_INVALIDOPCODE, OP_ELSE, OP_TRUE, OP_ENDIF]
         script = CScript(op_codes)
         tx1 = self.create_and_sign_transaction(
             out[28], out[28].vout[0].nValue, script)
 
         tx2 = self.create_and_sign_transaction(tx1, 0, CScript([OP_TRUE]))
         tx2.vin[0].scriptSig = CScript([OP_FALSE])
         tx2.rehash()
 
         b83 = self.update_block(83, [tx1, tx2])
         self.sync_blocks([b83], True)
         self.save_spendable_output()
 
         # Reorg on/off blocks that have OP_RETURN in them (and try to spend them)
         #
         #  -> b81 (26) -> b82 (27) -> b83 (28) -> b84 (29) -> b87 (30) -> b88 (31)
         #                                    \-> b85 (29) -> b86 (30)            \-> b89a (32)
         #
         self.log.info("Test re-orging blocks with OP_RETURN in them")
         b84 = self.next_block(84)
         tx1 = self.create_tx(out[29], 0, 0, CScript([OP_RETURN]))
         vout_offset = len(tx1.vout)
         tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
         tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
         tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
         tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
         tx1.calc_sha256()
         self.sign_tx(tx1, out[29])
         tx1.rehash()
         tx2 = self.create_tx(tx1, vout_offset, 0, CScript([OP_RETURN]))
         tx2.vout.append(CTxOut(0, CScript([OP_RETURN])))
         tx3 = self.create_tx(tx1, vout_offset + 1, 0, CScript([OP_RETURN]))
         tx3.vout.append(CTxOut(0, CScript([OP_TRUE])))
         tx4 = self.create_tx(tx1, vout_offset + 2, 0, CScript([OP_TRUE]))
         tx4.vout.append(CTxOut(0, CScript([OP_RETURN])))
         tx5 = self.create_tx(tx1, vout_offset + 3, 0, CScript([OP_RETURN]))
 
         b84 = self.update_block(84, [tx1, tx2, tx3, tx4, tx5])
         self.sync_blocks([b84], True)
         self.save_spendable_output()
 
         self.move_tip(83)
         b85 = self.next_block(85, spend=out[29])
         self.sync_blocks([b85], False)  # other chain is same length
 
         b86 = self.next_block(86, spend=out[30])
         self.sync_blocks([b86], True)
 
         self.move_tip(84)
         b87 = self.next_block(87, spend=out[30])
         self.sync_blocks([b87], False)  # other chain is same length
         self.save_spendable_output()
 
         b88 = self.next_block(88, spend=out[31])
         self.sync_blocks([b88], True)
         self.save_spendable_output()
 
         # trying to spend the OP_RETURN output is rejected
         b89a = self.next_block("89a", spend=out[32])
         tx = self.create_tx(tx1, 0, 0, CScript([OP_TRUE]))
         b89a = self.update_block("89a", [tx])
         self.sync_blocks([b89a], success=False,
                          reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
 
         self.log.info(
             "Test a re-org of one week's worth of blocks (1088 blocks)")
 
         self.move_tip(88)
         LARGE_REORG_SIZE = 1088
         blocks = []
         spend = out[32]
         for i in range(89, LARGE_REORG_SIZE + 89):
             b = self.next_block(i, spend)
             tx = CTransaction()
             script_length = LEGACY_MAX_BLOCK_SIZE - len(b.serialize()) - 69
             script_output = CScript([b'\x00' * script_length])
             tx.vout.append(CTxOut(0, script_output))
             tx.vin.append(CTxIn(COutPoint(b.vtx[1].sha256, 0)))
             b = self.update_block(i, [tx])
             assert_equal(len(b.serialize()), LEGACY_MAX_BLOCK_SIZE)
             blocks.append(b)
             self.save_spendable_output()
             spend = self.get_spendable_output()
 
         self.sync_blocks(blocks, True, timeout=960)
         chain1_tip = i
 
         # now create alt chain of same length
         self.move_tip(88)
         blocks2 = []
         for i in range(89, LARGE_REORG_SIZE + 89):
             blocks2.append(self.next_block("alt" + str(i)))
         self.sync_blocks(blocks2, False, request_block=False)
 
         # extend alt chain to trigger re-org
         block = self.next_block("alt" + str(chain1_tip + 1))
         self.sync_blocks([block], True, timeout=960)
 
         # ... and re-org back to the first chain
         self.move_tip(chain1_tip)
         block = self.next_block(chain1_tip + 1)
         self.sync_blocks([block], False, request_block=False)
         block = self.next_block(chain1_tip + 2)
         self.sync_blocks([block], True, timeout=960)
 
     # 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(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__':
     FullBlockTest().main()
diff --git a/test/functional/feature_cltv.py b/test/functional/feature_cltv.py
index cc71bad81..99329fd4d 100755
--- a/test/functional/feature_cltv.py
+++ b/test/functional/feature_cltv.py
@@ -1,219 +1,223 @@
 #!/usr/bin/env python3
 # Copyright (c) 2015-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 BIP65 (CHECKLOCKTIMEVERIFY).
 
 Test that the CHECKLOCKTIMEVERIFY soft-fork activates at (regtest) block height
 1351.
 """
 
 from test_framework.blocktools import create_block, create_coinbase, create_transaction, make_conform_to_ctor
 from test_framework.messages import (
     CTransaction,
     FromHex,
     msg_block,
     msg_tx,
     ToHex,
 )
 from test_framework.mininode import (
     P2PInterface,
 )
 from test_framework.script import (
     CScript,
     CScriptNum,
     OP_1NEGATE,
     OP_CHECKLOCKTIMEVERIFY,
     OP_DROP,
     OP_TRUE,
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.txtools import pad_tx
 from test_framework.util import assert_equal
 
 CLTV_HEIGHT = 1351
 
 # Reject codes that we might receive in this test
 REJECT_INVALID = 16
 REJECT_OBSOLETE = 17
 REJECT_NONSTANDARD = 64
 
 
 def cltv_lock_to_height(node, tx, to_address, amount, height=-1):
     '''Modify the scriptPubKey to add an OP_CHECKLOCKTIMEVERIFY, and make
     a transaction that spends it.
 
     This transforms the output script to anyone can spend (OP_TRUE) if the
     lock time condition is valid.
 
     Default height is -1 which leads CLTV to fail
 
     TODO: test more ways that transactions using CLTV could be invalid (eg
     locktime requirements fail, sequence time requirements fail, etc).
     '''
     height_op = OP_1NEGATE
     if(height > 0):
         tx.vin[0].nSequence = 0
         tx.nLockTime = height
         height_op = CScriptNum(height)
 
     tx.vout[0].scriptPubKey = CScript(
         [height_op, OP_CHECKLOCKTIMEVERIFY, OP_DROP, OP_TRUE])
 
     pad_tx(tx)
     fundtx_raw = node.signrawtransactionwithwallet(ToHex(tx))['hex']
 
     fundtx = FromHex(CTransaction(), fundtx_raw)
     fundtx.rehash()
 
     # make spending tx
     inputs = [{
         "txid": fundtx.hash,
         "vout": 0
     }]
     output = {to_address: amount}
 
     spendtx_raw = node.createrawtransaction(inputs, output)
 
     spendtx = FromHex(CTransaction(), spendtx_raw)
     pad_tx(spendtx)
 
     return fundtx, spendtx
 
 
 class BIP65Test(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
-        self.extra_args = [['-whitelist=127.0.0.1']]
+        self.extra_args = [[
+            '-whitelist=127.0.0.1',
+            '-par=1',  # Use only one script thread to get the exact reject reason for testing
+            '-acceptnonstdtxn=1',  # cltv_invalidate is nonstandard
+        ]]
         self.setup_clean_chain = True
         self.rpc_timeout = 120
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def run_test(self):
         self.nodes[0].add_p2p_connection(P2PInterface())
 
         self.log.info("Mining {} blocks".format(CLTV_HEIGHT - 2))
         self.coinbase_txids = [self.nodes[0].getblock(
             b)['tx'][0] for b in self.nodes[0].generate(CLTV_HEIGHT - 2)]
         self.nodeaddress = self.nodes[0].getnewaddress()
 
         self.log.info(
             "Test that an invalid-according-to-CLTV transaction can still appear in a block")
 
         fundtx = create_transaction(self.nodes[0], self.coinbase_txids[0],
                                     self.nodeaddress, 49.99)
         fundtx, spendtx = cltv_lock_to_height(
             self.nodes[0], fundtx, self.nodeaddress, 49.98)
 
         tip = self.nodes[0].getbestblockhash()
         block_time = self.nodes[0].getblockheader(tip)['mediantime'] + 1
         block = create_block(int(tip, 16), create_coinbase(
             CLTV_HEIGHT - 1), block_time)
         block.nVersion = 3
         block.vtx.append(fundtx)
         # include the -1 CLTV in block
         block.vtx.append(spendtx)
         make_conform_to_ctor(block)
         block.hashMerkleRoot = block.calc_merkle_root()
         block.solve()
 
         self.nodes[0].p2p.send_and_ping(msg_block(block))
         # This block is valid
         assert_equal(self.nodes[0].getbestblockhash(), block.hash)
 
         self.log.info("Test that blocks must now be at least version 4")
         tip = block.sha256
         block_time += 1
         block = create_block(tip, create_coinbase(CLTV_HEIGHT), block_time)
         block.nVersion = 3
         block.solve()
 
         with self.nodes[0].assert_debug_log(expected_msgs=['{}, bad-version(0x00000003)'.format(block.hash)]):
             self.nodes[0].p2p.send_and_ping(msg_block(block))
             assert_equal(int(self.nodes[0].getbestblockhash(), 16), tip)
             self.nodes[0].p2p.sync_with_ping()
 
         self.log.info(
             "Test that invalid-according-to-cltv transactions cannot appear in a block")
         block.nVersion = 4
 
         fundtx = create_transaction(self.nodes[0], self.coinbase_txids[1],
                                     self.nodeaddress, 49.99)
         fundtx, spendtx = cltv_lock_to_height(
             self.nodes[0], fundtx, self.nodeaddress, 49.98)
 
         # The funding tx only has unexecuted bad CLTV, in scriptpubkey; this is
         # valid.
         self.nodes[0].p2p.send_and_ping(msg_tx(fundtx))
         assert fundtx.hash in self.nodes[0].getrawmempool()
 
         # Mine a block containing the funding transaction
         block.vtx.append(fundtx)
         block.hashMerkleRoot = block.calc_merkle_root()
         block.solve()
 
         self.nodes[0].p2p.send_and_ping(msg_block(block))
         # This block is valid
         assert_equal(self.nodes[0].getbestblockhash(), block.hash)
 
         # We show that this tx is invalid due to CLTV by getting it
         # rejected from the mempool for exactly that reason.
         assert_equal(
             [{'txid': spendtx.hash, 'allowed': False,
                 'reject-reason': '64: non-mandatory-script-verify-flag (Negative locktime)'}],
             self.nodes[0].testmempoolaccept(
                 rawtxs=[spendtx.serialize().hex()], allowhighfees=True)
         )
 
         rejectedtx_signed = self.nodes[0].signrawtransactionwithwallet(
             ToHex(spendtx))
 
         # Couldn't complete signature due to CLTV
         assert rejectedtx_signed['errors'][0]['error'] == 'Negative locktime'
 
         tip = block.hash
         block_time += 1
         block = create_block(
             block.sha256, create_coinbase(CLTV_HEIGHT + 1), block_time)
         block.nVersion = 4
         block.vtx.append(spendtx)
         block.hashMerkleRoot = block.calc_merkle_root()
         block.solve()
 
         with self.nodes[0].assert_debug_log(expected_msgs=['ConnectBlock {} failed (blk-bad-inputs'.format(block.hash)]):
             self.nodes[0].p2p.send_and_ping(msg_block(block))
             assert_equal(self.nodes[0].getbestblockhash(), tip)
             self.nodes[0].p2p.sync_with_ping()
 
         self.log.info(
             "Test that a version 4 block with a valid-according-to-CLTV transaction is accepted")
         fundtx = create_transaction(self.nodes[0], self.coinbase_txids[2],
                                     self.nodeaddress, 49.99)
         fundtx, spendtx = cltv_lock_to_height(
             self.nodes[0], fundtx, self.nodeaddress, 49.98, CLTV_HEIGHT)
 
         # make sure sequence is nonfinal and locktime is good
         spendtx.vin[0].nSequence = 0xfffffffe
         spendtx.nLockTime = CLTV_HEIGHT
 
         # both transactions are fully valid
         self.nodes[0].sendrawtransaction(ToHex(fundtx))
         self.nodes[0].sendrawtransaction(ToHex(spendtx))
 
         # Modify the transactions in the block to be valid against CLTV
         block.vtx.pop(1)
         block.vtx.append(fundtx)
         block.vtx.append(spendtx)
         make_conform_to_ctor(block)
         block.hashMerkleRoot = block.calc_merkle_root()
         block.solve()
 
         self.nodes[0].p2p.send_and_ping(msg_block(block))
         # This block is now valid
         assert_equal(self.nodes[0].getbestblockhash(), block.hash)
 
 
 if __name__ == '__main__':
     BIP65Test().main()
diff --git a/test/functional/feature_config_args.py b/test/functional/feature_config_args.py
index 4668b0fec..e8e421e43 100755
--- a/test/functional/feature_config_args.py
+++ b/test/functional/feature_config_args.py
@@ -1,146 +1,152 @@
 #!/usr/bin/env python3
 # Copyright (c) 2017-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 various command line arguments and configuration file parameters."""
 import os
 
 from test_framework.test_framework import BitcoinTestFramework
 
 
 class ConfArgsTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def test_config_file_parser(self):
         # Assume node is stopped
 
         inc_conf_file_path = os.path.join(
             self.nodes[0].datadir, 'include.conf')
         with open(os.path.join(self.nodes[0].datadir, 'bitcoin.conf'), 'a', encoding='utf-8') as conf:
             conf.write('includeconf={}\n'.format(inc_conf_file_path))
 
         self.nodes[0].assert_start_raises_init_error(
             expected_msg='Error parsing command line arguments: Invalid parameter -dash_cli',
             extra_args=['-dash_cli=1'],
         )
         with open(inc_conf_file_path, 'w', encoding='utf-8') as conf:
             conf.write('dash_conf=1\n')
         with self.nodes[0].assert_debug_log(expected_msgs=['Ignoring unknown configuration value dash_conf']):
             self.start_node(0)
         self.stop_node(0)
 
         with open(inc_conf_file_path, 'w', encoding='utf-8') as conf:
             conf.write('-dash=1\n')
         self.nodes[0].assert_start_raises_init_error(
             expected_msg='Error reading configuration file: parse error on line 1: -dash=1, options in configuration file must be specified without leading -')
 
         if self.is_wallet_compiled():
             with open(inc_conf_file_path, 'w', encoding='utf8') as conf:
                 conf.write("wallet=foo\n")
             self.nodes[0].assert_start_raises_init_error(
                 expected_msg='Error: Config setting for -wallet only applied on regtest network when in [regtest] section.')
 
+        with open(inc_conf_file_path, 'w', encoding='utf-8') as conf:
+            conf.write('regtest=0\n')  # mainnet
+            conf.write('acceptnonstdtxn=1\n')
+        self.nodes[0].assert_start_raises_init_error(
+            expected_msg='Error: acceptnonstdtxn is not currently supported for main chain')
+
         with open(inc_conf_file_path, 'w', encoding='utf-8') as conf:
             conf.write('nono\n')
         self.nodes[0].assert_start_raises_init_error(
             expected_msg='Error reading configuration file: parse error on line 1: nono, if you intended to specify a negated option, use nono=1 instead')
 
         with open(inc_conf_file_path, 'w', encoding='utf-8') as conf:
             conf.write('server=1\nrpcuser=someuser\nrpcpassword=some#pass')
         self.nodes[0].assert_start_raises_init_error(
             expected_msg='Error reading configuration file: parse error on line 3, using # in rpcpassword can be ambiguous and should be avoided')
 
         with open(inc_conf_file_path, 'w', encoding='utf-8') as conf:
             conf.write('server=1\nrpcuser=someuser\nmain.rpcpassword=some#pass')
         self.nodes[0].assert_start_raises_init_error(
             expected_msg='Error reading configuration file: parse error on line 3, using # in rpcpassword can be ambiguous and should be avoided')
 
         with open(inc_conf_file_path, 'w', encoding='utf-8') as conf:
             conf.write(
                 'server=1\nrpcuser=someuser\n[main]\nrpcpassword=some#pass')
         self.nodes[0].assert_start_raises_init_error(
             expected_msg='Error reading configuration file: parse error on line 4, using # in rpcpassword can be ambiguous and should be avoided')
 
         inc_conf_file2_path = os.path.join(
             self.nodes[0].datadir, 'include2.conf')
         with open(os.path.join(self.nodes[0].datadir, 'bitcoin.conf'), 'a', encoding='utf-8') as conf:
             conf.write('includeconf={}\n'.format(inc_conf_file2_path))
 
         with open(inc_conf_file_path, 'w', encoding='utf-8') as conf:
             conf.write('testnot.datadir=1\n')
         with open(inc_conf_file2_path, 'w', encoding='utf-8') as conf:
             conf.write('[testnet]\n')
         self.restart_node(0)
         self.nodes[0].stop_node(
             expected_stderr='Warning: ' +
             inc_conf_file_path +
             ':1 Section [testnot] is not recognized.' +
             os.linesep +
             'Warning: ' +
             inc_conf_file2_path +
             ':1 Section [testnet] is not recognized.')
 
         with open(inc_conf_file_path, 'w', encoding='utf-8') as conf:
             conf.write('')  # clear
         with open(inc_conf_file2_path, 'w', encoding='utf-8') as conf:
             conf.write('')  # clear
 
     def test_log_buffer(self):
         with self.nodes[0].assert_debug_log(expected_msgs=['Warning: parsed potentially confusing double-negative -connect=0']):
             self.start_node(0, extra_args=['-noconnect=0'])
         self.stop_node(0)
 
     def run_test(self):
         self.stop_node(0)
 
         self.test_log_buffer()
 
         self.test_config_file_parser()
 
         # Remove the -datadir argument so it doesn't override the config file
         self.nodes[0].remove_default_args(["-datadir"])
 
         default_data_dir = self.nodes[0].datadir
         new_data_dir = os.path.join(default_data_dir, 'newdatadir')
         new_data_dir_2 = os.path.join(default_data_dir, 'newdatadir2')
 
         # Check that using -datadir argument on non-existent directory fails
         self.nodes[0].datadir = new_data_dir
         self.nodes[0].assert_start_raises_init_error(
             ['-datadir=' + new_data_dir], 'Error: Specified data directory "' + new_data_dir + '" does not exist.')
 
         # Check that using non-existent datadir in conf file fails
         conf_file = os.path.join(default_data_dir, "bitcoin.conf")
 
         # datadir needs to be set before [regtest] section
         conf_file_contents = open(conf_file, encoding='utf8').read()
         with open(conf_file, 'w', encoding='utf8') as f:
             f.write("datadir=" + new_data_dir + "\n")
             f.write(conf_file_contents)
 
         self.nodes[0].assert_start_raises_init_error(
             ['-conf=' + conf_file], 'Error reading configuration file: specified data directory "' + new_data_dir + '" does not exist.')
 
         # Create the directory and ensure the config file now works
         os.mkdir(new_data_dir)
         self.start_node(0, ['-conf=' + conf_file, '-wallet=w1'])
         self.stop_node(0)
         assert os.path.exists(os.path.join(
             new_data_dir, 'regtest', 'wallets', 'w1'))
 
         # Ensure command line argument overrides datadir in conf
         os.mkdir(new_data_dir_2)
         self.nodes[0].datadir = new_data_dir_2
         self.start_node(0, ['-datadir=' + new_data_dir_2,
                             '-conf=' + conf_file, '-wallet=w2'])
         assert os.path.exists(os.path.join(
             new_data_dir_2, 'regtest', 'wallets', 'w2'))
 
 
 if __name__ == '__main__':
     ConfArgsTest().main()
diff --git a/test/functional/feature_maxuploadtarget.py b/test/functional/feature_maxuploadtarget.py
index 1c0ca96c1..abb856a1d 100755
--- a/test/functional/feature_maxuploadtarget.py
+++ b/test/functional/feature_maxuploadtarget.py
@@ -1,177 +1,177 @@
 #!/usr/bin/env python3
 # Copyright (c) 2015-2016 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test behavior of -maxuploadtarget.
 
 * Verify that getdata requests for old blocks (>1week) are dropped
 if uploadtarget has been reached.
 * Verify that getdata requests for recent blocks are respected even
 if uploadtarget has been reached.
 * Verify that the upload counters are reset after 24 hours.
 """
 
 from collections import defaultdict
 import time
 
 from test_framework.cdefs import LEGACY_MAX_BLOCK_SIZE
 from test_framework.blocktools import mine_big_block
 from test_framework.messages import CInv, msg_getdata
 from test_framework.mininode import P2PInterface
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal
 
 
 class TestP2PConn(P2PInterface):
     def __init__(self):
         super().__init__()
         self.block_receive_map = defaultdict(int)
 
     def on_inv(self, message):
         pass
 
     def on_block(self, message):
         message.block.calc_sha256()
         self.block_receive_map[message.block.sha256] += 1
 
 
 class MaxUploadTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
         # Start a node with maxuploadtarget of 200 MB (/24h)
-        self.extra_args = [["-maxuploadtarget=200"]]
+        self.extra_args = [["-maxuploadtarget=200", "-acceptnonstdtxn=1"]]
 
         # Cache for utxos, as the listunspent may take a long time later in the
         # test
         self.utxo_cache = []
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def run_test(self):
         # Before we connect anything, we first set the time on the node
         # to be in the past, otherwise things break because the CNode
         # time counters can't be reset backward after initialization
         old_time = int(time.time() - 2 * 60 * 60 * 24 * 7)
         self.nodes[0].setmocktime(old_time)
 
         # Generate some old blocks
         self.nodes[0].generate(130)
 
         # p2p_conns[0] will only request old blocks
         # p2p_conns[1] will only request new blocks
         # p2p_conns[2] will test resetting the counters
         p2p_conns = []
 
         for _ in range(3):
             p2p_conns.append(self.nodes[0].add_p2p_connection(TestP2PConn()))
 
         # Now mine a big block
         mine_big_block(self.nodes[0], self.utxo_cache)
 
         # Store the hash; we'll request this later
         big_old_block = self.nodes[0].getbestblockhash()
         old_block_size = self.nodes[0].getblock(big_old_block, True)['size']
         big_old_block = int(big_old_block, 16)
 
         # Advance to two days ago
         self.nodes[0].setmocktime(int(time.time()) - 2 * 60 * 60 * 24)
 
         # Mine one more block, so that the prior block looks old
         mine_big_block(self.nodes[0], self.utxo_cache)
 
         # We'll be requesting this new block too
         big_new_block = self.nodes[0].getbestblockhash()
         big_new_block = int(big_new_block, 16)
 
         # p2p_conns[0] will test what happens if we just keep requesting the
         # the same big old block too many times (expect: disconnect)
 
         getdata_request = msg_getdata()
         getdata_request.inv.append(CInv(2, big_old_block))
 
         max_bytes_per_day = 200 * 1024 * 1024
         daily_buffer = 144 * LEGACY_MAX_BLOCK_SIZE
         max_bytes_available = max_bytes_per_day - daily_buffer
         success_count = max_bytes_available // old_block_size
 
         # 144MB will be reserved for relaying new blocks, so expect this to
         # succeed for ~70 tries.
         for i in range(success_count):
             p2p_conns[0].send_message(getdata_request)
             p2p_conns[0].sync_with_ping()
             assert_equal(p2p_conns[0].block_receive_map[big_old_block], i + 1)
 
         assert_equal(len(self.nodes[0].getpeerinfo()), 3)
         # At most a couple more tries should succeed (depending on how long
         # the test has been running so far).
         for i in range(3):
             p2p_conns[0].send_message(getdata_request)
         p2p_conns[0].wait_for_disconnect()
         assert_equal(len(self.nodes[0].getpeerinfo()), 2)
         self.log.info(
             "Peer 0 disconnected after downloading old block too many times")
 
         # Requesting the current block on p2p_conns[1] should succeed indefinitely,
         # even when over the max upload target.
         # We'll try 200 times
         getdata_request.inv = [CInv(2, big_new_block)]
         for i in range(200):
             p2p_conns[1].send_message(getdata_request)
             p2p_conns[1].sync_with_ping()
             assert_equal(p2p_conns[1].block_receive_map[big_new_block], i + 1)
 
         self.log.info("Peer 1 able to repeatedly download new block")
 
         # But if p2p_conns[1] tries for an old block, it gets disconnected
         # too.
         getdata_request.inv = [CInv(2, big_old_block)]
         p2p_conns[1].send_message(getdata_request)
         p2p_conns[1].wait_for_disconnect()
         assert_equal(len(self.nodes[0].getpeerinfo()), 1)
 
         self.log.info("Peer 1 disconnected after trying to download old block")
 
         self.log.info("Advancing system time on node to clear counters...")
 
         # If we advance the time by 24 hours, then the counters should reset,
         # and p2p_conns[2] should be able to retrieve the old block.
         self.nodes[0].setmocktime(int(time.time()))
         p2p_conns[2].sync_with_ping()
         p2p_conns[2].send_message(getdata_request)
         p2p_conns[2].sync_with_ping()
         assert_equal(p2p_conns[2].block_receive_map[big_old_block], 1)
 
         self.log.info("Peer 2 able to download old block")
 
         self.nodes[0].disconnect_p2ps()
 
         # stop and start node 0 with 1MB maxuploadtarget, whitelist 127.0.0.1
         self.log.info("Restarting nodes with -whitelist=127.0.0.1")
         self.stop_node(0)
         self.start_node(0, ["-whitelist=127.0.0.1",
                             "-maxuploadtarget=1", "-blockmaxsize=999000"])
 
         # Reconnect to self.nodes[0]
         self.nodes[0].add_p2p_connection(TestP2PConn())
 
         # retrieve 20 blocks which should be enough to break the 1MB limit
         getdata_request.inv = [CInv(2, big_new_block)]
         for i in range(20):
             self.nodes[0].p2p.send_message(getdata_request)
             self.nodes[0].p2p.sync_with_ping()
             assert_equal(
                 self.nodes[0].p2p.block_receive_map[big_new_block], i + 1)
 
         getdata_request.inv = [CInv(2, big_old_block)]
         self.nodes[0].p2p.send_and_ping(getdata_request)
         # node is still connected because of the whitelist
         assert_equal(len(self.nodes[0].getpeerinfo()), 1)
 
         self.log.info(
             "Peer still connected after trying to download old block (whitelisted)")
 
 
 if __name__ == '__main__':
     MaxUploadTest().main()
diff --git a/test/functional/mempool_limit.py b/test/functional/mempool_limit.py
index abf1c6352..1d08caea4 100755
--- a/test/functional/mempool_limit.py
+++ b/test/functional/mempool_limit.py
@@ -1,88 +1,91 @@
 #!/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 limiting together/eviction with the wallet."""
 
 from decimal import Decimal
 
 from test_framework.blocktools import (
     create_confirmed_utxos,
     send_big_transactions,
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     assert_greater_than,
     assert_raises_rpc_error,
 )
 
 
 class MempoolLimitTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
-
-        self.extra_args = [["-maxmempool=5", "-spendzeroconfchange=0"]]
+        self.extra_args = [[
+            "-acceptnonstdtxn=1",
+            "-maxmempool=5",
+            "-spendzeroconfchange=0",
+        ]]
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def run_test(self):
         relayfee = self.nodes[0].getnetworkinfo()['relayfee']
 
         self.log.info('Check that mempoolminfee is minrelytxfee')
         assert_equal(self.nodes[0].getmempoolinfo()[
                      'minrelaytxfee'], Decimal('0.00001000'))
         assert_equal(self.nodes[0].getmempoolinfo()[
                      'mempoolminfee'], Decimal('0.00001000'))
 
         txids = []
         utxo_groups = 4
         utxos = create_confirmed_utxos(self.nodes[0], 1 + 30 * utxo_groups)
 
         self.log.info('Create a mempool tx that will be evicted')
         us0 = utxos.pop()
         inputs = [{"txid": us0["txid"], "vout": us0["vout"]}]
         outputs = {self.nodes[0].getnewaddress(): 0.0001}
         tx = self.nodes[0].createrawtransaction(inputs, outputs)
         # specifically fund this tx with low fee
         self.nodes[0].settxfee(relayfee)
         txF = self.nodes[0].fundrawtransaction(tx)
         # return to automatic fee selection
         self.nodes[0].settxfee(0)
         txFS = self.nodes[0].signrawtransactionwithwallet(txF['hex'])
         txid = self.nodes[0].sendrawtransaction(txFS['hex'])
 
         for i in range(utxo_groups):
             txids.append([])
             txids[i] = send_big_transactions(
                 self.nodes[0], utxos[30 * i:30 * i + 30], 30, 10 * (i + 1))
 
         self.log.info('The tx should be evicted by now')
         assert txid not in self.nodes[0].getrawmempool()
         txdata = self.nodes[0].gettransaction(txid)
         # confirmation should still be 0
         assert txdata['confirmations'] == 0
 
         self.log.info('Check that mempoolminfee is larger than minrelytxfee')
         assert_equal(self.nodes[0].getmempoolinfo()[
                      'minrelaytxfee'], Decimal('0.00001000'))
         assert_greater_than(self.nodes[0].getmempoolinfo()[
                             'mempoolminfee'], Decimal('0.00001000'))
 
         self.log.info('Create a mempool tx that will not pass mempoolminfee')
         us0 = utxos.pop()
         inputs = [{"txid": us0["txid"], "vout": us0["vout"]}]
         outputs = {self.nodes[0].getnewaddress(): 0.0001}
         tx = self.nodes[0].createrawtransaction(inputs, outputs)
         # specifically fund this tx with a fee < mempoolminfee, >= than
         # minrelaytxfee
         txF = self.nodes[0].fundrawtransaction(tx, {'feeRate': relayfee})
         txFS = self.nodes[0].signrawtransactionwithwallet(txF['hex'])
         assert_raises_rpc_error(-26, "mempool min fee not met",
                                 self.nodes[0].sendrawtransaction, txFS['hex'])
 
 
 if __name__ == '__main__':
     MempoolLimitTest().main()
diff --git a/test/functional/mining_prioritisetransaction.py b/test/functional/mining_prioritisetransaction.py
index f8c13098b..1b888d283 100755
--- a/test/functional/mining_prioritisetransaction.py
+++ b/test/functional/mining_prioritisetransaction.py
@@ -1,215 +1,218 @@
 #!/usr/bin/env python3
 # Copyright (c) 2015-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 the prioritisetransaction mining RPC."""
 
 import time
 
 from test_framework.blocktools import (
     create_confirmed_utxos,
     send_big_transactions,
 )
 # FIXME: review how this test needs to be adapted w.r.t _LEGACY_MAX_BLOCK_SIZE
 from test_framework.cdefs import LEGACY_MAX_BLOCK_SIZE
 from test_framework.messages import COIN
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, assert_raises_rpc_error
 
 
 class PrioritiseTransactionTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
-        self.extra_args = [["-printpriority=1"], ["-printpriority=1"]]
+        self.extra_args = [[
+            "-printpriority=1",
+            "-acceptnonstdtxn=1",
+        ]] * self.num_nodes
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def run_test(self):
         # Test `prioritisetransaction` required parameters
         assert_raises_rpc_error(-1,
                                 "prioritisetransaction",
                                 self.nodes[0].prioritisetransaction)
         assert_raises_rpc_error(-1,
                                 "prioritisetransaction",
                                 self.nodes[0].prioritisetransaction,
                                 '')
         assert_raises_rpc_error(-1,
                                 "prioritisetransaction",
                                 self.nodes[0].prioritisetransaction,
                                 '',
                                 0)
 
         # Test `prioritisetransaction` invalid extra parameters
         assert_raises_rpc_error(-1,
                                 "prioritisetransaction",
                                 self.nodes[0].prioritisetransaction,
                                 '',
                                 0,
                                 0,
                                 0)
 
         # Test `prioritisetransaction` invalid `txid`
         assert_raises_rpc_error(-8,
                                 "txid must be of length 64 (not 3, for 'foo')",
                                 self.nodes[0].prioritisetransaction,
                                 txid='foo',
                                 fee_delta=0)
         assert_raises_rpc_error(
             -8,
             "txid must be hexadecimal string (not 'Zd1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000')",
             self.nodes[0].prioritisetransaction,
             txid='Zd1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000',
             fee_delta=0)
 
         # Test `prioritisetransaction` invalid `dummy`
         txid = '1d1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000'
         assert_raises_rpc_error(-1,
                                 "JSON value is not a number as expected",
                                 self.nodes[0].prioritisetransaction,
                                 txid,
                                 'foo',
                                 0)
         assert_raises_rpc_error(
             -8,
             "Priority is no longer supported, dummy argument to prioritisetransaction must be 0.",
             self.nodes[0].prioritisetransaction,
             txid,
             1,
             0)
 
         # Test `prioritisetransaction` invalid `fee_delta`
         assert_raises_rpc_error(-1,
                                 "JSON value is not an integer as expected",
                                 self.nodes[0].prioritisetransaction,
                                 txid=txid,
                                 fee_delta='foo')
 
         self.relayfee = self.nodes[0].getnetworkinfo()['relayfee']
 
         utxo_count = 90
         utxos = create_confirmed_utxos(self.nodes[0], utxo_count)
         txids = []
 
         # Create 3 batches of transactions at 3 different fee rate levels
         range_size = utxo_count // 3
         for i in range(3):
             txids.append([])
             start_range = i * range_size
             end_range = start_range + range_size
             txids[i] = send_big_transactions(self.nodes[0], utxos[start_range:end_range],
                                              end_range - start_range, 10 * (i + 1))
 
         # Make sure that the size of each group of transactions exceeds
         # LEGACY_MAX_BLOCK_SIZE -- otherwise the test needs to be revised to create
         # more transactions.
         mempool = self.nodes[0].getrawmempool(True)
         sizes = [0, 0, 0]
         for i in range(3):
             for j in txids[i]:
                 assert j in mempool
                 sizes[i] += mempool[j]['size']
             # Fail => raise utxo_count
             assert sizes[i] > LEGACY_MAX_BLOCK_SIZE
 
         # add a fee delta to something in the cheapest bucket and make sure it gets mined
         # also check that a different entry in the cheapest bucket is NOT mined
         self.nodes[0].prioritisetransaction(
             txid=txids[0][0], fee_delta=100 * self.nodes[0].calculate_fee_from_txid(txids[0][0]))
 
         self.nodes[0].generate(1)
 
         mempool = self.nodes[0].getrawmempool()
         self.log.info("Assert that prioritised transaction was mined")
         assert txids[0][0] not in mempool
         assert txids[0][1] in mempool
 
         confirmed_transactions = self.nodes[0].getblock(
             self.nodes[0].getbestblockhash())['tx']
 
         # Pull the highest fee-rate transaction from a block
         high_fee_tx = confirmed_transactions[1]
 
         # Something high-fee should have been mined!
         assert high_fee_tx is not None
 
         # Add a prioritisation before a tx is in the mempool (de-prioritising a
         # high-fee transaction so that it's now low fee).
         #
         # NOTE WELL: gettransaction returns the fee as a negative number and
         # as fractional coins. However, the prioritisetransaction expects a
         # number of satoshi to add or subtract from the actual fee.
         # Thus the conversation here is simply int(tx_fee*COIN) to remove all fees, and then
         # we add the minimum fee back.
         tx_fee = self.nodes[0].gettransaction(high_fee_tx)['fee']
         self.nodes[0].prioritisetransaction(
             txid=high_fee_tx, fee_delta=int(tx_fee * COIN) + self.nodes[0].calculate_fee_from_txid(high_fee_tx))
 
         # Add everything back to mempool
         self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
 
         # Check to make sure our high fee rate tx is back in the mempool
         mempool = self.nodes[0].getrawmempool()
         assert high_fee_tx in mempool
 
         # Now verify the modified-high feerate transaction isn't mined before
         # the other high fee transactions. Keep mining until our mempool has
         # decreased by all the high fee size that we calculated above.
         while (self.nodes[0].getmempoolinfo()['bytes'] > sizes[0] + sizes[1]):
             self.nodes[0].generate(1)
 
         # High fee transaction should not have been mined, but other high fee rate
         # transactions should have been.
         mempool = self.nodes[0].getrawmempool()
         self.log.info(
             "Assert that de-prioritised transaction is still in mempool")
         assert high_fee_tx in mempool
         for x in txids[2]:
             if (x != high_fee_tx):
                 assert x not in mempool
 
         # Create a free transaction.  Should be rejected.
         utxo_list = self.nodes[0].listunspent()
         assert len(utxo_list) > 0
         utxo = utxo_list[0]
 
         inputs = []
         outputs = {}
         inputs.append({"txid": utxo["txid"], "vout": utxo["vout"]})
         outputs[self.nodes[0].getnewaddress()] = utxo["amount"]
         raw_tx = self.nodes[0].createrawtransaction(inputs, outputs)
         tx_hex = self.nodes[0].signrawtransactionwithwallet(raw_tx)["hex"]
         tx_id = self.nodes[0].decoderawtransaction(tx_hex)["txid"]
 
         # This will raise an exception due to min relay fee not being met
         assert_raises_rpc_error(-26, "min relay fee not met (code 66)",
                                 self.nodes[0].sendrawtransaction, tx_hex)
         assert tx_id not in self.nodes[0].getrawmempool()
 
         # This is a less than 1000-byte transaction, so just set the fee
         # to be the minimum for a 1000-byte transaction and check that it is
         # accepted.
         self.nodes[0].prioritisetransaction(
             txid=tx_id, fee_delta=int(self.relayfee * COIN))
 
         self.log.info(
             "Assert that prioritised free transaction is accepted to mempool")
         assert_equal(self.nodes[0].sendrawtransaction(tx_hex), tx_id)
         assert tx_id in self.nodes[0].getrawmempool()
 
         # Test that calling prioritisetransaction is sufficient to trigger
         # getblocktemplate to (eventually) return a new block.
         mock_time = int(time.time())
         self.nodes[0].setmocktime(mock_time)
         template = self.nodes[0].getblocktemplate()
         self.nodes[0].prioritisetransaction(
             txid=tx_id, fee_delta=-int(self.relayfee * COIN))
         self.nodes[0].setmocktime(mock_time + 10)
         new_template = self.nodes[0].getblocktemplate()
 
         assert template != new_template
 
 
 if __name__ == '__main__':
     PrioritiseTransactionTest().main()
diff --git a/test/functional/p2p_compactblocks.py b/test/functional/p2p_compactblocks.py
index 16098f421..9a716516e 100755
--- a/test/functional/p2p_compactblocks.py
+++ b/test/functional/p2p_compactblocks.py
@@ -1,933 +1,934 @@
 #!/usr/bin/env python3
 # Copyright (c) 2016-2019 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 compact blocks (BIP 152).
 
 Only testing Version 1 compact blocks (txids)
 """
 
 import random
 
 from test_framework.blocktools import create_block, create_coinbase
 from test_framework.messages import (
     BlockTransactions,
     BlockTransactionsRequest,
     calculate_shortid,
     CBlock,
     CBlockHeader,
     CInv,
     COutPoint,
     CTransaction,
     CTxIn,
     CTxOut,
     FromHex,
     HeaderAndShortIDs,
     msg_block,
     msg_blocktxn,
     msg_cmpctblock,
     msg_getblocktxn,
     msg_getdata,
     msg_getheaders,
     msg_headers,
     msg_inv,
     msg_sendcmpct,
     msg_sendheaders,
     msg_tx,
     NODE_NETWORK,
     P2PHeaderAndShortIDs,
     PrefilledTransaction,
     ToHex,
 )
 from test_framework.mininode import (
     mininode_lock,
     P2PInterface,
 )
 from test_framework.script import CScript, OP_TRUE
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.txtools import pad_tx
 from test_framework.util import assert_equal, sync_blocks, wait_until
 
 # TestP2PConn: A peer we use to send messages to bitcoind, and store responses.
 
 
 class TestP2PConn(P2PInterface):
     def __init__(self):
         super().__init__()
         self.last_sendcmpct = []
         self.block_announced = False
         # Store the hashes of blocks we've seen announced.
         # This is for synchronizing the p2p message traffic,
         # so we can eg wait until a particular block is announced.
         self.announced_blockhashes = set()
 
     def on_sendcmpct(self, message):
         self.last_sendcmpct.append(message)
 
     def on_cmpctblock(self, message):
         self.block_announced = True
         self.last_message["cmpctblock"].header_and_shortids.header.calc_sha256()
         self.announced_blockhashes.add(
             self.last_message["cmpctblock"].header_and_shortids.header.sha256)
 
     def on_headers(self, message):
         self.block_announced = True
         for x in self.last_message["headers"].headers:
             x.calc_sha256()
             self.announced_blockhashes.add(x.sha256)
 
     def on_inv(self, message):
         for x in self.last_message["inv"].inv:
             if x.type == 2:
                 self.block_announced = True
                 self.announced_blockhashes.add(x.hash)
 
     # Requires caller to hold mininode_lock
     def received_block_announcement(self):
         return self.block_announced
 
     def clear_block_announcement(self):
         with mininode_lock:
             self.block_announced = False
             self.last_message.pop("inv", None)
             self.last_message.pop("headers", None)
             self.last_message.pop("cmpctblock", None)
 
     def get_headers(self, locator, hashstop):
         msg = msg_getheaders()
         msg.locator.vHave = locator
         msg.hashstop = hashstop
         self.send_message(msg)
 
     def send_header_for_blocks(self, new_blocks):
         headers_message = msg_headers()
         headers_message.headers = [CBlockHeader(b) for b in new_blocks]
         self.send_message(headers_message)
 
     def request_headers_and_sync(self, locator, hashstop=0):
         self.clear_block_announcement()
         self.get_headers(locator, hashstop)
         wait_until(self.received_block_announcement,
                    timeout=30, lock=mininode_lock)
         self.clear_block_announcement()
 
     # Block until a block announcement for a particular block hash is
     # received.
     def wait_for_block_announcement(self, block_hash, timeout=30):
         def received_hash():
             return (block_hash in self.announced_blockhashes)
         wait_until(received_hash, timeout=timeout, lock=mininode_lock)
 
     def send_await_disconnect(self, message, timeout=30):
         """Sends a message to the node and wait for disconnect.
 
         This is used when we want to send a message into the node that we expect
         will get us disconnected, eg an invalid block."""
         self.send_message(message)
         wait_until(lambda: not self.is_connected,
                    timeout=timeout, lock=mininode_lock)
 
 
 class CompactBlocksTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
-        self.extra_args = [[], ["-txindex"]]
+        self.extra_args = [["-acceptnonstdtxn=1"],
+                           ["-txindex", "-acceptnonstdtxn=1"]]
         self.utxos = []
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def build_block_on_tip(self, node):
         height = node.getblockcount()
         tip = node.getbestblockhash()
         mtp = node.getblockheader(tip)['mediantime']
         block = create_block(
             int(tip, 16), create_coinbase(height + 1), mtp + 1)
         block.nVersion = 4
         block.solve()
         return block
 
     # Create 10 more anyone-can-spend utxo's for testing.
     def make_utxos(self):
         # Doesn't matter which node we use, just use node0.
         block = self.build_block_on_tip(self.nodes[0])
         self.test_node.send_and_ping(msg_block(block))
         assert int(self.nodes[0].getbestblockhash(), 16) == block.sha256
         self.nodes[0].generate(100)
 
         total_value = block.vtx[0].vout[0].nValue
         out_value = total_value // 10
         tx = CTransaction()
         tx.vin.append(CTxIn(COutPoint(block.vtx[0].sha256, 0), b''))
         for i in range(10):
             tx.vout.append(CTxOut(out_value, CScript([OP_TRUE])))
         tx.rehash()
 
         block2 = self.build_block_on_tip(self.nodes[0])
         block2.vtx.append(tx)
         block2.hashMerkleRoot = block2.calc_merkle_root()
         block2.solve()
         self.test_node.send_and_ping(msg_block(block2))
         assert_equal(int(self.nodes[0].getbestblockhash(), 16), block2.sha256)
         self.utxos.extend([[tx.sha256, i, out_value] for i in range(10)])
         return
 
     # Test "sendcmpct" (between peers preferring the same version):
     # - No compact block announcements unless sendcmpct is sent.
     # - If sendcmpct is sent with version > preferred_version, the message is ignored.
     # - If sendcmpct is sent with boolean 0, then block announcements are not
     #   made with compact blocks.
     # - If sendcmpct is then sent with boolean 1, then new block announcements
     #   are made with compact blocks.
     # If old_node is passed in, request compact blocks with version=preferred-1
     # and verify that it receives block announcements via compact block.
     def test_sendcmpct(self, node, test_node,
                        preferred_version, old_node=None):
         # Make sure we get a SENDCMPCT message from our peer
         def received_sendcmpct():
             return (len(test_node.last_sendcmpct) > 0)
         wait_until(received_sendcmpct, timeout=30, lock=mininode_lock)
         with mininode_lock:
             # Check that the first version received is the preferred one
             assert_equal(
                 test_node.last_sendcmpct[0].version, preferred_version)
             # And that we receive versions down to 1.
             assert_equal(test_node.last_sendcmpct[-1].version, 1)
             test_node.last_sendcmpct = []
 
         tip = int(node.getbestblockhash(), 16)
 
         def check_announcement_of_new_block(node, peer, predicate):
             peer.clear_block_announcement()
             block_hash = int(node.generate(1)[0], 16)
             peer.wait_for_block_announcement(block_hash, timeout=30)
             assert peer.block_announced
 
             with mininode_lock:
                 assert predicate(peer), (
                     "block_hash={!r}, cmpctblock={!r}, inv={!r}".format(
                         block_hash, peer.last_message.get("cmpctblock", None), peer.last_message.get("inv", None)))
 
         # We shouldn't get any block announcements via cmpctblock yet.
         check_announcement_of_new_block(
             node, test_node, lambda p: "cmpctblock" not in p.last_message)
 
         # Try one more time, this time after requesting headers.
         test_node.request_headers_and_sync(locator=[tip])
         check_announcement_of_new_block(
             node, test_node, lambda p: "cmpctblock" not in p.last_message and "inv" in p.last_message)
 
         # Test a few ways of using sendcmpct that should NOT
         # result in compact block announcements.
         # Before each test, sync the headers chain.
         test_node.request_headers_and_sync(locator=[tip])
 
         # Now try a SENDCMPCT message with too-high version
         sendcmpct = msg_sendcmpct()
         sendcmpct.version = 999  # was: preferred_version+1
         sendcmpct.announce = True
         test_node.send_and_ping(sendcmpct)
         check_announcement_of_new_block(
             node, test_node, lambda p: "cmpctblock" not in p.last_message)
 
         # Headers sync before next test.
         test_node.request_headers_and_sync(locator=[tip])
 
         # Now try a SENDCMPCT message with valid version, but announce=False
         sendcmpct.version = preferred_version
         sendcmpct.announce = False
         test_node.send_and_ping(sendcmpct)
         check_announcement_of_new_block(
             node, test_node, lambda p: "cmpctblock" not in p.last_message)
 
         # Headers sync before next test.
         test_node.request_headers_and_sync(locator=[tip])
 
         # Finally, try a SENDCMPCT message with announce=True
         sendcmpct.version = preferred_version
         sendcmpct.announce = True
         test_node.send_and_ping(sendcmpct)
         check_announcement_of_new_block(
             node, test_node, lambda p: "cmpctblock" in p.last_message)
 
         # Try one more time (no headers sync should be needed!)
         check_announcement_of_new_block(
             node, test_node, lambda p: "cmpctblock" in p.last_message)
 
         # Try one more time, after turning on sendheaders
         test_node.send_and_ping(msg_sendheaders())
         check_announcement_of_new_block(
             node, test_node, lambda p: "cmpctblock" in p.last_message)
 
         # Try one more time, after sending a version-1, announce=false message.
         sendcmpct.version = preferred_version - 1
         sendcmpct.announce = False
         test_node.send_and_ping(sendcmpct)
         check_announcement_of_new_block(
             node, test_node, lambda p: "cmpctblock" in p.last_message)
 
         # Now turn off announcements
         sendcmpct.version = preferred_version
         sendcmpct.announce = False
         test_node.send_and_ping(sendcmpct)
         check_announcement_of_new_block(
             node, test_node, lambda p: "cmpctblock" not in p.last_message and "headers" in p.last_message)
 
         if old_node is not None:
             # Verify that a peer using an older protocol version can receive
             # announcements from this node.
             sendcmpct.version = 1  # preferred_version-1
             sendcmpct.announce = True
             old_node.send_and_ping(sendcmpct)
             # Header sync
             old_node.request_headers_and_sync(locator=[tip])
             check_announcement_of_new_block(
                 node, old_node, lambda p: "cmpctblock" in p.last_message)
 
     # This test actually causes bitcoind to (reasonably!) disconnect us, so do
     # this last.
     def test_invalid_cmpctblock_message(self):
         self.nodes[0].generate(101)
         block = self.build_block_on_tip(self.nodes[0])
 
         cmpct_block = P2PHeaderAndShortIDs()
         cmpct_block.header = CBlockHeader(block)
         cmpct_block.prefilled_txn_length = 1
         # This index will be too high
         prefilled_txn = PrefilledTransaction(1, block.vtx[0])
         cmpct_block.prefilled_txn = [prefilled_txn]
         self.test_node.send_await_disconnect(msg_cmpctblock(cmpct_block))
         assert_equal(
             int(self.nodes[0].getbestblockhash(), 16), block.hashPrevBlock)
 
     # Compare the generated shortids to what we expect based on BIP 152, given
     # bitcoind's choice of nonce.
     def test_compactblock_construction(self, node, test_node):
         # Generate a bunch of transactions.
         node.generate(101)
         num_transactions = 25
         address = node.getnewaddress()
 
         for i in range(num_transactions):
             txid = node.sendtoaddress(address, 0.1)
             hex_tx = node.gettransaction(txid)["hex"]
             tx = FromHex(CTransaction(), hex_tx)
 
         # Wait until we've seen the block announcement for the resulting tip
         tip = int(node.getbestblockhash(), 16)
         test_node.wait_for_block_announcement(tip)
 
         # Make sure we will receive a fast-announce compact block
         self.request_cb_announcements(test_node, node)
 
         # Now mine a block, and look at the resulting compact block.
         test_node.clear_block_announcement()
         block_hash = int(node.generate(1)[0], 16)
 
         # Store the raw block in our internal format.
         block = FromHex(CBlock(), node.getblock(
             "{:064x}".format(block_hash), False))
         for tx in block.vtx:
             tx.calc_sha256()
         block.rehash()
 
         # Wait until the block was announced (via compact blocks)
         wait_until(test_node.received_block_announcement,
                    timeout=30, lock=mininode_lock)
 
         # Now fetch and check the compact block
         header_and_shortids = None
         with mininode_lock:
             assert "cmpctblock" in test_node.last_message
             # Convert the on-the-wire representation to absolute indexes
             header_and_shortids = HeaderAndShortIDs(
                 test_node.last_message["cmpctblock"].header_and_shortids)
         self.check_compactblock_construction_from_block(
             header_and_shortids, block_hash, block)
 
         # Now fetch the compact block using a normal non-announce getdata
         with mininode_lock:
             test_node.clear_block_announcement()
             inv = CInv(4, block_hash)  # 4 == "CompactBlock"
             test_node.send_message(msg_getdata([inv]))
 
         wait_until(test_node.received_block_announcement,
                    timeout=30, lock=mininode_lock)
 
         # Now fetch and check the compact block
         header_and_shortids = None
         with mininode_lock:
             assert "cmpctblock" in test_node.last_message
             # Convert the on-the-wire representation to absolute indexes
             header_and_shortids = HeaderAndShortIDs(
                 test_node.last_message["cmpctblock"].header_and_shortids)
         self.check_compactblock_construction_from_block(
             header_and_shortids, block_hash, block)
 
     def check_compactblock_construction_from_block(
             self, header_and_shortids, block_hash, block):
         # Check that we got the right block!
         header_and_shortids.header.calc_sha256()
         assert_equal(header_and_shortids.header.sha256, block_hash)
 
         # Make sure the prefilled_txn appears to have included the coinbase
         assert len(header_and_shortids.prefilled_txn) >= 1
         assert_equal(header_and_shortids.prefilled_txn[0].index, 0)
 
         # Check that all prefilled_txn entries match what's in the block.
         for entry in header_and_shortids.prefilled_txn:
             entry.tx.calc_sha256()
             # This checks the tx agree
             assert_equal(entry.tx.sha256, block.vtx[entry.index].sha256)
 
         # Check that the cmpctblock message announced all the transactions.
         assert_equal(len(header_and_shortids.prefilled_txn)
                      + len(header_and_shortids.shortids), len(block.vtx))
 
         # And now check that all the shortids are as expected as well.
         # Determine the siphash keys to use.
         [k0, k1] = header_and_shortids.get_siphash_keys()
 
         index = 0
         while index < len(block.vtx):
             if (len(header_and_shortids.prefilled_txn) > 0 and
                     header_and_shortids.prefilled_txn[0].index == index):
                 # Already checked prefilled transactions above
                 header_and_shortids.prefilled_txn.pop(0)
             else:
                 tx_hash = block.vtx[index].sha256
                 shortid = calculate_shortid(k0, k1, tx_hash)
                 assert_equal(shortid, header_and_shortids.shortids[0])
                 header_and_shortids.shortids.pop(0)
             index += 1
 
     # Test that bitcoind requests compact blocks when we announce new blocks
     # via header or inv, and that responding to getblocktxn causes the block
     # to be successfully reconstructed.
     def test_compactblock_requests(self, node, test_node, version):
         # Try announcing a block with an inv or header, expect a compactblock
         # request
         for announce in ["inv", "header"]:
             block = self.build_block_on_tip(node)
             with mininode_lock:
                 test_node.last_message.pop("getdata", None)
 
             if announce == "inv":
                 test_node.send_message(msg_inv([CInv(2, block.sha256)]))
                 wait_until(lambda: "getheaders" in test_node.last_message,
                            timeout=30, lock=mininode_lock)
                 test_node.send_header_for_blocks([block])
             else:
                 test_node.send_header_for_blocks([block])
             wait_until(lambda: "getdata" in test_node.last_message,
                        timeout=30, lock=mininode_lock)
             assert_equal(len(test_node.last_message["getdata"].inv), 1)
             assert_equal(test_node.last_message["getdata"].inv[0].type, 4)
             assert_equal(
                 test_node.last_message["getdata"].inv[0].hash, block.sha256)
 
             # Send back a compactblock message that omits the coinbase
             comp_block = HeaderAndShortIDs()
             comp_block.header = CBlockHeader(block)
             comp_block.nonce = 0
             [k0, k1] = comp_block.get_siphash_keys()
             coinbase_hash = block.vtx[0].sha256
             comp_block.shortids = [
                 calculate_shortid(k0, k1, coinbase_hash)]
             test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
             assert_equal(int(node.getbestblockhash(), 16), block.hashPrevBlock)
             # Expect a getblocktxn message.
             with mininode_lock:
                 assert "getblocktxn" in test_node.last_message
                 absolute_indexes = test_node.last_message["getblocktxn"].block_txn_request.to_absolute(
                 )
             assert_equal(absolute_indexes, [0])  # should be a coinbase request
 
             # Send the coinbase, and verify that the tip advances.
             msg = msg_blocktxn()
             msg.block_transactions.blockhash = block.sha256
             msg.block_transactions.transactions = [block.vtx[0]]
             test_node.send_and_ping(msg)
             assert_equal(int(node.getbestblockhash(), 16), block.sha256)
 
     # Create a chain of transactions from given utxo, and add to a new block.
     # Note that num_transactions is number of transactions not including the
     # coinbase.
     def build_block_with_transactions(self, node, utxo, num_transactions):
         block = self.build_block_on_tip(node)
 
         for i in range(num_transactions):
             tx = CTransaction()
             tx.vin.append(CTxIn(COutPoint(utxo[0], utxo[1]), b''))
             tx.vout.append(CTxOut(utxo[2] - 1000, CScript([OP_TRUE])))
             pad_tx(tx)
             tx.rehash()
             utxo = [tx.sha256, 0, tx.vout[0].nValue]
             block.vtx.append(tx)
 
         ordered_txs = block.vtx
         block.vtx = [block.vtx[0]] + \
             sorted(block.vtx[1:], key=lambda tx: tx.get_id())
         block.hashMerkleRoot = block.calc_merkle_root()
         block.solve()
         return block, ordered_txs
 
     # Test that we only receive getblocktxn requests for transactions that the
     # node needs, and that responding to them causes the block to be
     # reconstructed.
     def test_getblocktxn_requests(self, node, test_node, version):
         def test_getblocktxn_response(compact_block, peer, expected_result):
             msg = msg_cmpctblock(compact_block.to_p2p())
             peer.send_and_ping(msg)
             with mininode_lock:
                 assert "getblocktxn" in peer.last_message
                 absolute_indexes = peer.last_message["getblocktxn"].block_txn_request.to_absolute(
                 )
             assert_equal(absolute_indexes, expected_result)
 
         def test_tip_after_message(node, peer, msg, tip):
             peer.send_and_ping(msg)
             assert_equal(int(node.getbestblockhash(), 16), tip)
 
         # First try announcing compactblocks that won't reconstruct, and verify
         # that we receive getblocktxn messages back.
         utxo = self.utxos.pop(0)
 
         block, ordered_txs = self.build_block_with_transactions(node, utxo, 5)
         self.utxos.append(
             [ordered_txs[-1].sha256, 0, ordered_txs[-1].vout[0].nValue])
         comp_block = HeaderAndShortIDs()
         comp_block.initialize_from_block(block)
 
         test_getblocktxn_response(comp_block, test_node, [1, 2, 3, 4, 5])
 
         msg_bt = msg_blocktxn()
         msg_bt.block_transactions = BlockTransactions(
             block.sha256, block.vtx[1:])
         test_tip_after_message(node, test_node, msg_bt, block.sha256)
 
         utxo = self.utxos.pop(0)
         block, ordered_txs = self.build_block_with_transactions(node, utxo, 5)
         self.utxos.append(
             [ordered_txs[-1].sha256, 0, ordered_txs[-1].vout[0].nValue])
 
         # Now try interspersing the prefilled transactions
         comp_block.initialize_from_block(
             block, prefill_list=[0, 1, 5])
         test_getblocktxn_response(comp_block, test_node, [2, 3, 4])
         msg_bt.block_transactions = BlockTransactions(
             block.sha256, block.vtx[2:5])
         test_tip_after_message(node, test_node, msg_bt, block.sha256)
 
         # Now try giving one transaction ahead of time.
         utxo = self.utxos.pop(0)
         block, ordered_txs = self.build_block_with_transactions(node, utxo, 5)
         self.utxos.append(
             [ordered_txs[-1].sha256, 0, ordered_txs[-1].vout[0].nValue])
         test_node.send_and_ping(msg_tx(ordered_txs[1]))
         assert ordered_txs[1].hash in node.getrawmempool()
         test_node.send_and_ping(msg_tx(ordered_txs[1]))
 
         # Prefill 4 out of the 6 transactions, and verify that only the one
         # that was not in the mempool is requested.
         prefill_list = [0, 1, 2, 3, 4, 5]
         prefill_list.remove(block.vtx.index(ordered_txs[1]))
         expected_index = block.vtx.index(ordered_txs[-1])
         prefill_list.remove(expected_index)
         comp_block.initialize_from_block(block, prefill_list=prefill_list)
         test_getblocktxn_response(comp_block, test_node, [expected_index])
 
         msg_bt.block_transactions = BlockTransactions(
             block.sha256, [ordered_txs[5]])
         test_tip_after_message(node, test_node, msg_bt, block.sha256)
 
         # Now provide all transactions to the node before the block is
         # announced and verify reconstruction happens immediately.
         utxo = self.utxos.pop(0)
         block, ordered_txs = self.build_block_with_transactions(node, utxo, 10)
         self.utxos.append(
             [ordered_txs[-1].sha256, 0, ordered_txs[-1].vout[0].nValue])
         for tx in ordered_txs[1:]:
             test_node.send_message(msg_tx(tx))
         test_node.sync_with_ping()
         # Make sure all transactions were accepted.
         mempool = node.getrawmempool()
         for tx in block.vtx[1:]:
             assert tx.hash in mempool
 
         # Clear out last request.
         with mininode_lock:
             test_node.last_message.pop("getblocktxn", None)
 
         # Send compact block
         comp_block.initialize_from_block(block, prefill_list=[0])
         test_tip_after_message(
             node, test_node, msg_cmpctblock(comp_block.to_p2p()), block.sha256)
         with mininode_lock:
             # Shouldn't have gotten a request for any transaction
             assert "getblocktxn" not in test_node.last_message
 
     # Incorrectly responding to a getblocktxn shouldn't cause the block to be
     # permanently failed.
     def test_incorrect_blocktxn_response(self, node, test_node, version):
         if (len(self.utxos) == 0):
             self.make_utxos()
         utxo = self.utxos.pop(0)
 
         block, ordered_txs = self.build_block_with_transactions(node, utxo, 10)
         self.utxos.append(
             [ordered_txs[-1].sha256, 0, ordered_txs[-1].vout[0].nValue])
         # Relay the first 5 transactions from the block in advance
         for tx in ordered_txs[1:6]:
             test_node.send_message(msg_tx(tx))
         test_node.sync_with_ping()
         # Make sure all transactions were accepted.
         mempool = node.getrawmempool()
         for tx in ordered_txs[1:6]:
             assert tx.hash in mempool
 
         # Send compact block
         comp_block = HeaderAndShortIDs()
         comp_block.initialize_from_block(block, prefill_list=[0])
         test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
         absolute_indices = []
         with mininode_lock:
             assert "getblocktxn" in test_node.last_message
             absolute_indices = test_node.last_message["getblocktxn"].block_txn_request.to_absolute(
             )
         expected_indices = []
         for i in [6, 7, 8, 9, 10]:
             expected_indices.append(block.vtx.index(ordered_txs[i]))
         assert_equal(absolute_indices, sorted(expected_indices))
 
         # Now give an incorrect response.
         # Note that it's possible for bitcoind to be smart enough to know we're
         # lying, since it could check to see if the shortid matches what we're
         # sending, and eg disconnect us for misbehavior.  If that behavior
         # change was made, we could just modify this test by having a
         # different peer provide the block further down, so that we're still
         # verifying that the block isn't marked bad permanently. This is good
         # enough for now.
         msg = msg_blocktxn()
         msg.block_transactions = BlockTransactions(
             block.sha256, [ordered_txs[5]] + ordered_txs[7:])
         test_node.send_and_ping(msg)
 
         # Tip should not have updated
         assert_equal(int(node.getbestblockhash(), 16), block.hashPrevBlock)
 
         # We should receive a getdata request
         wait_until(lambda: "getdata" in test_node.last_message,
                    timeout=10, lock=mininode_lock)
         assert_equal(len(test_node.last_message["getdata"].inv), 1)
         assert test_node.last_message["getdata"].inv[0].type == 2
         assert_equal(
             test_node.last_message["getdata"].inv[0].hash, block.sha256)
 
         # Deliver the block
         test_node.send_and_ping(msg_block(block))
         assert_equal(int(node.getbestblockhash(), 16), block.sha256)
 
     def test_getblocktxn_handler(self, node, test_node, version):
         # bitcoind will not send blocktxn responses for blocks whose height is
         # more than 10 blocks deep.
         MAX_GETBLOCKTXN_DEPTH = 10
         chain_height = node.getblockcount()
         current_height = chain_height
         while (current_height >= chain_height - MAX_GETBLOCKTXN_DEPTH):
             block_hash = node.getblockhash(current_height)
             block = FromHex(CBlock(), node.getblock(block_hash, False))
 
             msg = msg_getblocktxn()
             msg.block_txn_request = BlockTransactionsRequest(
                 int(block_hash, 16), [])
             num_to_request = random.randint(1, len(block.vtx))
             msg.block_txn_request.from_absolute(
                 sorted(random.sample(range(len(block.vtx)), num_to_request)))
             test_node.send_message(msg)
             wait_until(lambda: "blocktxn" in test_node.last_message,
                        timeout=10, lock=mininode_lock)
 
             [tx.calc_sha256() for tx in block.vtx]
             with mininode_lock:
                 assert_equal(test_node.last_message["blocktxn"].block_transactions.blockhash, int(
                     block_hash, 16))
                 all_indices = msg.block_txn_request.to_absolute()
                 for index in all_indices:
                     tx = test_node.last_message["blocktxn"].block_transactions.transactions.pop(
                         0)
                     tx.calc_sha256()
                     assert_equal(tx.sha256, block.vtx[index].sha256)
                 test_node.last_message.pop("blocktxn", None)
             current_height -= 1
 
         # Next request should send a full block response, as we're past the
         # allowed depth for a blocktxn response.
         block_hash = node.getblockhash(current_height)
         msg.block_txn_request = BlockTransactionsRequest(
             int(block_hash, 16), [0])
         with mininode_lock:
             test_node.last_message.pop("block", None)
             test_node.last_message.pop("blocktxn", None)
         test_node.send_and_ping(msg)
         with mininode_lock:
             test_node.last_message["block"].block.calc_sha256()
             assert_equal(
                 test_node.last_message["block"].block.sha256, int(block_hash, 16))
             assert "blocktxn" not in test_node.last_message
 
     def test_compactblocks_not_at_tip(self, node, test_node):
         # Test that requesting old compactblocks doesn't work.
         MAX_CMPCTBLOCK_DEPTH = 5
         new_blocks = []
         for i in range(MAX_CMPCTBLOCK_DEPTH + 1):
             test_node.clear_block_announcement()
             new_blocks.append(node.generate(1)[0])
             wait_until(test_node.received_block_announcement,
                        timeout=30, lock=mininode_lock)
 
         test_node.clear_block_announcement()
         test_node.send_message(msg_getdata([CInv(4, int(new_blocks[0], 16))]))
         wait_until(lambda: "cmpctblock" in test_node.last_message,
                    timeout=30, lock=mininode_lock)
 
         test_node.clear_block_announcement()
         node.generate(1)
         wait_until(test_node.received_block_announcement,
                    timeout=30, lock=mininode_lock)
         test_node.clear_block_announcement()
         with mininode_lock:
             test_node.last_message.pop("block", None)
         test_node.send_message(msg_getdata([CInv(4, int(new_blocks[0], 16))]))
         wait_until(lambda: "block" in test_node.last_message,
                    timeout=30, lock=mininode_lock)
         with mininode_lock:
             test_node.last_message["block"].block.calc_sha256()
             assert_equal(
                 test_node.last_message["block"].block.sha256, int(new_blocks[0], 16))
 
         # Generate an old compactblock, and verify that it's not accepted.
         cur_height = node.getblockcount()
         hashPrevBlock = int(node.getblockhash(cur_height - 5), 16)
         block = self.build_block_on_tip(node)
         block.hashPrevBlock = hashPrevBlock
         block.solve()
 
         comp_block = HeaderAndShortIDs()
         comp_block.initialize_from_block(block)
         test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
 
         tips = node.getchaintips()
         found = False
         for x in tips:
             if x["hash"] == block.hash:
                 assert_equal(x["status"], "headers-only")
                 found = True
                 break
         assert found
 
         # Requesting this block via getblocktxn should silently fail
         # (to avoid fingerprinting attacks).
         msg = msg_getblocktxn()
         msg.block_txn_request = BlockTransactionsRequest(block.sha256, [0])
         with mininode_lock:
             test_node.last_message.pop("blocktxn", None)
         test_node.send_and_ping(msg)
         with mininode_lock:
             assert "blocktxn" not in test_node.last_message
 
     def test_end_to_end_block_relay(self, node, listeners):
         utxo = self.utxos.pop(0)
 
         block, _ = self.build_block_with_transactions(node, utxo, 10)
 
         [l.clear_block_announcement() for l in listeners]
 
         node.submitblock(ToHex(block))
 
         for l in listeners:
             wait_until(lambda: l.received_block_announcement(),
                        timeout=30, lock=mininode_lock)
         with mininode_lock:
             for l in listeners:
                 assert "cmpctblock" in l.last_message
                 l.last_message["cmpctblock"].header_and_shortids.header.calc_sha256(
                 )
                 assert_equal(
                     l.last_message["cmpctblock"].header_and_shortids.header.sha256, block.sha256)
 
     # Test that we don't get disconnected if we relay a compact block with valid header,
     # but invalid transactions.
     def test_invalid_tx_in_compactblock(self, node, test_node):
         assert len(self.utxos)
         utxo = self.utxos[0]
 
         block, ordered_txs = self.build_block_with_transactions(node, utxo, 5)
         block.vtx.remove(ordered_txs[3])
         block.hashMerkleRoot = block.calc_merkle_root()
         block.solve()
 
         # Now send the compact block with all transactions prefilled, and
         # verify that we don't get disconnected.
         comp_block = HeaderAndShortIDs()
         comp_block.initialize_from_block(block, prefill_list=[0, 1, 2, 3, 4])
         msg = msg_cmpctblock(comp_block.to_p2p())
         test_node.send_and_ping(msg)
 
         # Check that the tip didn't advance
         assert int(node.getbestblockhash(), 16) is not block.sha256
         test_node.sync_with_ping()
 
     # Helper for enabling cb announcements
     # Send the sendcmpct request and sync headers
     def request_cb_announcements(self, peer, node, version=1):
         tip = node.getbestblockhash()
         peer.get_headers(locator=[int(tip, 16)], hashstop=0)
 
         msg = msg_sendcmpct()
         msg.version = version
         msg.announce = True
         peer.send_and_ping(msg)
 
     def test_compactblock_reconstruction_multiple_peers(
             self, node, stalling_peer, delivery_peer):
         assert len(self.utxos)
 
         def announce_cmpct_block(node, peer):
             utxo = self.utxos.pop(0)
             block, _ = self.build_block_with_transactions(node, utxo, 5)
 
             cmpct_block = HeaderAndShortIDs()
             cmpct_block.initialize_from_block(block)
             msg = msg_cmpctblock(cmpct_block.to_p2p())
             peer.send_and_ping(msg)
             with mininode_lock:
                 assert "getblocktxn" in peer.last_message
             return block, cmpct_block
 
         block, cmpct_block = announce_cmpct_block(node, stalling_peer)
 
         for tx in block.vtx[1:]:
             delivery_peer.send_message(msg_tx(tx))
         delivery_peer.sync_with_ping()
         mempool = node.getrawmempool()
         for tx in block.vtx[1:]:
             assert tx.hash in mempool
 
         delivery_peer.send_and_ping(msg_cmpctblock(cmpct_block.to_p2p()))
         assert_equal(int(node.getbestblockhash(), 16), block.sha256)
 
         self.utxos.append(
             [block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue])
 
         # Now test that delivering an invalid compact block won't break relay
         block, cmpct_block = announce_cmpct_block(node, stalling_peer)
         for tx in block.vtx[1:]:
             delivery_peer.send_message(msg_tx(tx))
         delivery_peer.sync_with_ping()
 
         # TODO: modify txhash in a way that doesn't impact txid.
         delivery_peer.send_and_ping(msg_cmpctblock(cmpct_block.to_p2p()))
         # Because txhash isn't modified, we end up reconstructing the same block
         # assert int(node.getbestblockhash(), 16) != block.sha256
 
         msg = msg_blocktxn()
         msg.block_transactions.blockhash = block.sha256
         msg.block_transactions.transactions = block.vtx[1:]
         stalling_peer.send_and_ping(msg)
         assert_equal(int(node.getbestblockhash(), 16), block.sha256)
 
     def run_test(self):
         # Setup the p2p connections
         self.test_node = self.nodes[0].add_p2p_connection(TestP2PConn())
         self.ex_softfork_node = self.nodes[1].add_p2p_connection(
             TestP2PConn(), services=NODE_NETWORK)
         self.old_node = self.nodes[1].add_p2p_connection(
             TestP2PConn(), services=NODE_NETWORK)
 
         # We will need UTXOs to construct transactions in later tests.
         self.make_utxos()
 
         self.log.info("Running tests:")
 
         self.log.info("\tTesting SENDCMPCT p2p message... ")
         self.test_sendcmpct(self.nodes[0], self.test_node, 1)
         sync_blocks(self.nodes)
         self.test_sendcmpct(
             self.nodes[1], self.ex_softfork_node, 1, old_node=self.old_node)
         sync_blocks(self.nodes)
 
         self.log.info("\tTesting compactblock construction...")
         self.test_compactblock_construction(self.nodes[0], self.test_node)
         sync_blocks(self.nodes)
         self.test_compactblock_construction(
             self.nodes[1], self.ex_softfork_node)
         sync_blocks(self.nodes)
 
         self.log.info("\tTesting compactblock requests... ")
         self.test_compactblock_requests(self.nodes[0], self.test_node, 1)
         sync_blocks(self.nodes)
         self.test_compactblock_requests(
             self.nodes[1], self.ex_softfork_node, 2)
         sync_blocks(self.nodes)
 
         self.log.info("\tTesting getblocktxn requests...")
         self.test_getblocktxn_requests(self.nodes[0], self.test_node, 1)
         sync_blocks(self.nodes)
         self.test_getblocktxn_requests(self.nodes[1], self.ex_softfork_node, 2)
         sync_blocks(self.nodes)
 
         self.log.info("\tTesting getblocktxn handler...")
         self.test_getblocktxn_handler(self.nodes[0], self.test_node, 1)
         sync_blocks(self.nodes)
         self.test_getblocktxn_handler(self.nodes[1], self.ex_softfork_node, 2)
         self.test_getblocktxn_handler(self.nodes[1], self.old_node, 1)
         sync_blocks(self.nodes)
 
         self.log.info(
             "\tTesting compactblock requests/announcements not at chain tip...")
         self.test_compactblocks_not_at_tip(self.nodes[0], self.test_node)
         sync_blocks(self.nodes)
         self.test_compactblocks_not_at_tip(
             self.nodes[1], self.ex_softfork_node)
         self.test_compactblocks_not_at_tip(self.nodes[1], self.old_node)
         sync_blocks(self.nodes)
 
         self.log.info("\tTesting handling of incorrect blocktxn responses...")
         self.test_incorrect_blocktxn_response(self.nodes[0], self.test_node, 1)
         sync_blocks(self.nodes)
         self.test_incorrect_blocktxn_response(
             self.nodes[1], self.ex_softfork_node, 2)
         sync_blocks(self.nodes)
 
         # End-to-end block relay tests
         self.log.info("\tTesting end-to-end block relay...")
         self.request_cb_announcements(self.test_node, self.nodes[0])
         self.request_cb_announcements(self.old_node, self.nodes[1])
         self.request_cb_announcements(
             self.ex_softfork_node, self.nodes[1], version=2)
         self.test_end_to_end_block_relay(
             self.nodes[0], [self.ex_softfork_node, self.test_node, self.old_node])
         self.test_end_to_end_block_relay(
             self.nodes[1], [self.ex_softfork_node, self.test_node, self.old_node])
 
         self.log.info("\tTesting handling of invalid compact blocks...")
         self.test_invalid_tx_in_compactblock(self.nodes[0], self.test_node)
         self.test_invalid_tx_in_compactblock(
             self.nodes[1], self.ex_softfork_node)
         self.test_invalid_tx_in_compactblock(self.nodes[1], self.old_node)
 
         self.log.info(
             "\tTesting reconstructing compact blocks from all peers...")
         self.test_compactblock_reconstruction_multiple_peers(
             self.nodes[1], self.ex_softfork_node, self.old_node)
         sync_blocks(self.nodes)
 
         self.log.info("\tTesting invalid index in cmpctblock message...")
         self.test_invalid_cmpctblock_message()
 
 
 if __name__ == '__main__':
     CompactBlocksTest().main()
diff --git a/test/functional/p2p_invalid_tx.py b/test/functional/p2p_invalid_tx.py
index 88fe23499..a42fb9c67 100755
--- a/test/functional/p2p_invalid_tx.py
+++ b/test/functional/p2p_invalid_tx.py
@@ -1,180 +1,184 @@
 #!/usr/bin/env python3
 # Copyright (c) 2015-2017 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 node responses to invalid transactions.
 
 In this test we connect to one node over p2p, and test tx requests.
 """
 
 from test_framework.blocktools import (
     create_block,
     create_coinbase,
     create_tx_with_script,
 )
 from test_framework.txtools import pad_tx
 from test_framework.messages import (
     COIN,
     COutPoint,
     CTransaction,
     CTxIn,
     CTxOut,
 )
 from test_framework.mininode import P2PDataStore
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     wait_until,
 )
 
 
 class InvalidTxRequestTest(BitcoinTestFramework):
 
     def set_test_params(self):
         self.num_nodes = 1
+        self.extra_args = [
+            ["-acceptnonstdtxn=1", ]
+        ]
         self.setup_clean_chain = True
 
     def bootstrap_p2p(self, *, num_connections=1):
         """Add a P2P connection to the node.
 
         Helper to connect and wait for version handshake."""
         for _ in range(num_connections):
             self.nodes[0].add_p2p_connection(P2PDataStore())
 
     def reconnect_p2p(self, **kwargs):
         """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(**kwargs)
 
     def run_test(self):
         node = self.nodes[0]  # convenience reference to the node
 
         self.bootstrap_p2p()  # Add one p2p connection to the node
 
         best_block = self.nodes[0].getbestblockhash()
         tip = int(best_block, 16)
         best_block_time = self.nodes[0].getblock(best_block)['time']
         block_time = best_block_time + 1
 
         self.log.info("Create a new block with an anyone-can-spend coinbase.")
         height = 1
         block = create_block(tip, create_coinbase(height), block_time)
         block.solve()
         # Save the coinbase for later
         block1 = block
         tip = block.sha256
         node.p2p.send_blocks_and_test([block], node, success=True)
 
         self.log.info("Mature the block.")
         self.nodes[0].generatetoaddress(
             100, self.nodes[0].get_deterministic_priv_key().address)
 
         # b'\x64' is OP_NOTIF
         # Transaction will be rejected with code 16 (REJECT_INVALID)
         # and we get disconnected immediately
         self.log.info('Test a transaction that is rejected')
         tx1 = create_tx_with_script(
             block1.vtx[0], 0, script_sig=b'\x64' * 35, amount=50 * COIN - 12000)
         node.p2p.send_txs_and_test(
             [tx1], node, success=False, expect_disconnect=True)
 
         # Make two p2p connections to provide the node with orphans
         # * p2ps[0] will send valid orphan txs (one with low fee)
         # * p2ps[1] will send an invalid orphan tx (and is later disconnected for that)
         self.reconnect_p2p(num_connections=2)
 
         self.log.info('Test orphan transaction handling ... ')
         # Create a root transaction that we withold until all dependend transactions
         # are sent out and in the orphan cache
         tx_withhold = CTransaction()
         tx_withhold.vin.append(
             CTxIn(outpoint=COutPoint(block1.vtx[0].sha256, 0)))
         tx_withhold.vout.append(
             CTxOut(nValue=50 * COIN - 12000, scriptPubKey=b'\x51'))
         pad_tx(tx_withhold)
         tx_withhold.calc_sha256()
 
         # Our first orphan tx with some outputs to create further orphan txs
         tx_orphan_1 = CTransaction()
         tx_orphan_1.vin.append(
             CTxIn(outpoint=COutPoint(tx_withhold.sha256, 0)))
         tx_orphan_1.vout = [CTxOut(nValue=10 * COIN, scriptPubKey=b'\x51')] * 3
         pad_tx(tx_orphan_1)
         tx_orphan_1.calc_sha256()
 
         # A valid transaction with low fee
         tx_orphan_2_no_fee = CTransaction()
         tx_orphan_2_no_fee.vin.append(
             CTxIn(outpoint=COutPoint(tx_orphan_1.sha256, 0)))
         tx_orphan_2_no_fee.vout.append(
             CTxOut(nValue=10 * COIN, scriptPubKey=b'\x51'))
         pad_tx(tx_orphan_2_no_fee)
 
         # A valid transaction with sufficient fee
         tx_orphan_2_valid = CTransaction()
         tx_orphan_2_valid.vin.append(
             CTxIn(outpoint=COutPoint(tx_orphan_1.sha256, 1)))
         tx_orphan_2_valid.vout.append(
             CTxOut(nValue=10 * COIN - 12000, scriptPubKey=b'\x51'))
         tx_orphan_2_valid.calc_sha256()
         pad_tx(tx_orphan_2_valid)
 
         # An invalid transaction with negative fee
         tx_orphan_2_invalid = CTransaction()
         tx_orphan_2_invalid.vin.append(
             CTxIn(outpoint=COutPoint(tx_orphan_1.sha256, 2)))
         tx_orphan_2_invalid.vout.append(
             CTxOut(nValue=11 * COIN, scriptPubKey=b'\x51'))
         pad_tx(tx_orphan_2_invalid)
 
         self.log.info('Send the orphans ... ')
         # Send valid orphan txs from p2ps[0]
         node.p2p.send_txs_and_test(
             [tx_orphan_1, tx_orphan_2_no_fee, tx_orphan_2_valid], node, success=False)
         # Send invalid tx from p2ps[1]
         node.p2ps[1].send_txs_and_test(
             [tx_orphan_2_invalid], node, success=False)
 
         # Mempool should be empty
         assert_equal(0, node.getmempoolinfo()['size'])
         # p2ps[1] is still connected
         assert_equal(2, len(node.getpeerinfo()))
 
         self.log.info('Send the withhold tx ... ')
         with node.assert_debug_log(expected_msgs=["bad-txns-in-belowout"]):
             node.p2p.send_txs_and_test([tx_withhold], node, success=True)
 
         # Transactions that should end up in the mempool
         expected_mempool = {
             t.hash
             for t in [
                 tx_withhold,  # The transaction that is the root for all orphans
                 tx_orphan_1,  # The orphan transaction that splits the coins
                 # The valid transaction (with sufficient fee)
                 tx_orphan_2_valid,
             ]
         }
         # Transactions that do not end up in the mempool
         # tx_orphan_no_fee, because it has too low fee (p2ps[0] is not disconnected for relaying that tx)
         # tx_orphan_invaid, because it has negative fee (p2ps[1] is
         # disconnected for relaying that tx)
 
         # p2ps[1] is no longer connected
         wait_until(lambda: 1 == len(node.getpeerinfo()), timeout=12)
         assert_equal(expected_mempool, set(node.getrawmempool()))
 
         # restart node with sending BIP61 messages disabled, check that it
         # disconnects without sending the reject message
         self.log.info(
             'Test a transaction that is rejected, with BIP61 disabled')
-        self.restart_node(0, ['-enablebip61=0', '-persistmempool=0'])
+        self.restart_node(
+            0, self.extra_args[0] + ['-enablebip61=0', '-persistmempool=0'])
         self.reconnect_p2p(num_connections=1)
         node.p2p.send_txs_and_test(
             [tx1], node, success=False, reject_reason="{} from peer=0 was not accepted: mandatory-script-verify-flag-failed (Invalid OP_IF construction) (code 16)".format(tx1.hash), expect_disconnect=True)
 
 
 if __name__ == '__main__':
     InvalidTxRequestTest().main()
diff --git a/test/functional/wallet_basic.py b/test/functional/wallet_basic.py
index 5a48ceebd..0603f782e 100755
--- a/test/functional/wallet_basic.py
+++ b/test/functional/wallet_basic.py
@@ -1,553 +1,560 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-2016 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the wallet."""
 from decimal import Decimal
 import time
 
 from test_framework.messages import FromHex, CTransaction
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_array_result,
     assert_equal,
     assert_fee_amount,
     assert_raises_rpc_error,
     connect_nodes_bi,
     count_bytes,
     sync_blocks,
     sync_mempools,
     wait_until,
 )
 
 
 class WalletTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 4
+        self.extra_args = [
+            ["-acceptnonstdtxn=1"],
+        ] * self.num_nodes
         self.setup_clean_chain = True
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def setup_network(self):
         self.add_nodes(4)
-        self.start_node(0)
-        self.start_node(1)
-        self.start_node(2)
+        self.start_node(0, self.extra_args[0])
+        self.start_node(1, self.extra_args[1])
+        self.start_node(2, self.extra_args[2])
         connect_nodes_bi(self.nodes[0], self.nodes[1])
         connect_nodes_bi(self.nodes[1], self.nodes[2])
         connect_nodes_bi(self.nodes[0], self.nodes[2])
         self.sync_all([self.nodes[0:3]])
 
     def check_fee_amount(self, curr_balance,
                          balance_with_fee, fee_per_byte, tx_size):
         """Return curr_balance after asserting the fee was in range"""
         fee = balance_with_fee - curr_balance
         assert_fee_amount(fee, tx_size, fee_per_byte * 1000)
         return curr_balance
 
     def run_test(self):
         # Check that there's no UTXO on none of the nodes
         assert_equal(len(self.nodes[0].listunspent()), 0)
         assert_equal(len(self.nodes[1].listunspent()), 0)
         assert_equal(len(self.nodes[2].listunspent()), 0)
 
         self.log.info("Mining blocks...")
 
         self.nodes[0].generate(1)
 
         walletinfo = self.nodes[0].getwalletinfo()
         assert_equal(walletinfo['immature_balance'], 50)
         assert_equal(walletinfo['balance'], 0)
 
         self.sync_all([self.nodes[0:3]])
         self.nodes[1].generate(101)
         self.sync_all([self.nodes[0:3]])
 
         assert_equal(self.nodes[0].getbalance(), 50)
         assert_equal(self.nodes[1].getbalance(), 50)
         assert_equal(self.nodes[2].getbalance(), 0)
 
         # Check getbalance with different arguments
         assert_equal(self.nodes[0].getbalance("*"), 50)
         assert_equal(self.nodes[0].getbalance("*", 1), 50)
         assert_equal(self.nodes[0].getbalance("*", 1, True), 50)
         assert_equal(self.nodes[0].getbalance(minconf=1), 50)
 
         # first argument of getbalance must be excluded or set to "*"
         assert_raises_rpc_error(-32, "dummy first argument must be excluded or set to \"*\"",
                                 self.nodes[0].getbalance, "")
 
         # Check that only first and second nodes have UTXOs
         utxos = self.nodes[0].listunspent()
         assert_equal(len(utxos), 1)
         assert_equal(len(self.nodes[1].listunspent()), 1)
         assert_equal(len(self.nodes[2].listunspent()), 0)
 
         self.log.info("test gettxout")
         confirmed_txid, confirmed_index = utxos[0]["txid"], utxos[0]["vout"]
         # First, outputs that are unspent both in the chain and in the
         # mempool should appear with or without include_mempool
         txout = self.nodes[0].gettxout(
             txid=confirmed_txid, n=confirmed_index, include_mempool=False)
         assert_equal(txout['value'], 50)
         txout = self.nodes[0].gettxout(
             txid=confirmed_txid, n=confirmed_index, include_mempool=True)
         assert_equal(txout['value'], 50)
 
         # Send 21 BCH from 0 to 2 using sendtoaddress call.
         self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 11)
         mempool_txid = self.nodes[0].sendtoaddress(
             self.nodes[2].getnewaddress(), 10)
 
         self.log.info("test gettxout (second part)")
         # utxo spent in mempool should be visible if you exclude mempool
         # but invisible if you include mempool
         txout = self.nodes[0].gettxout(confirmed_txid, confirmed_index, False)
         assert_equal(txout['value'], 50)
         txout = self.nodes[0].gettxout(confirmed_txid, confirmed_index, True)
         assert txout is None
         # new utxo from mempool should be invisible if you exclude mempool
         # but visible if you include mempool
         txout = self.nodes[0].gettxout(mempool_txid, 0, False)
         assert txout is None
         txout1 = self.nodes[0].gettxout(mempool_txid, 0, True)
         txout2 = self.nodes[0].gettxout(mempool_txid, 1, True)
         # note the mempool tx will have randomly assigned indices
         # but 10 will go to node2 and the rest will go to node0
         balance = self.nodes[0].getbalance()
         assert_equal(set([txout1['value'], txout2['value']]),
                      set([10, balance]))
         walletinfo = self.nodes[0].getwalletinfo()
         assert_equal(walletinfo['immature_balance'], 0)
 
         # Have node0 mine a block, thus it will collect its own fee.
         self.nodes[0].generate(1)
         self.sync_all([self.nodes[0:3]])
 
         # Exercise locking of unspent outputs
         unspent_0 = self.nodes[2].listunspent()[0]
         unspent_0 = {"txid": unspent_0["txid"], "vout": unspent_0["vout"]}
         assert_raises_rpc_error(-8, "Invalid parameter, expected locked output",
                                 self.nodes[2].lockunspent, True, [unspent_0])
         self.nodes[2].lockunspent(False, [unspent_0])
         assert_raises_rpc_error(-8, "Invalid parameter, output already locked",
                                 self.nodes[2].lockunspent, False, [unspent_0])
         assert_raises_rpc_error(-4, "Insufficient funds",
                                 self.nodes[2].sendtoaddress, self.nodes[2].getnewaddress(), 20)
         assert_equal([unspent_0], self.nodes[2].listlockunspent())
         self.nodes[2].lockunspent(True, [unspent_0])
         assert_equal(len(self.nodes[2].listlockunspent()), 0)
         assert_raises_rpc_error(-8, "txid must be of length 64 (not 34, for '0000000000000000000000000000000000')",
                                 self.nodes[2].lockunspent, False,
                                 [{"txid": "0000000000000000000000000000000000", "vout": 0}])
         assert_raises_rpc_error(-8, "txid must be hexadecimal string (not 'ZZZ0000000000000000000000000000000000000000000000000000000000000')",
                                 self.nodes[2].lockunspent, False,
                                 [{"txid": "ZZZ0000000000000000000000000000000000000000000000000000000000000", "vout": 0}])
         assert_raises_rpc_error(-8, "Invalid parameter, unknown transaction",
                                 self.nodes[2].lockunspent, False,
                                 [{"txid": "0000000000000000000000000000000000000000000000000000000000000000", "vout": 0}])
         assert_raises_rpc_error(-8, "Invalid parameter, vout index out of bounds",
                                 self.nodes[2].lockunspent, False, [{"txid": unspent_0["txid"], "vout": 999}])
 
         # Have node1 generate 100 blocks (so node0 can recover the fee)
         self.nodes[1].generate(100)
         self.sync_all([self.nodes[0:3]])
 
         # node0 should end up with 100 btc in block rewards plus fees, but
         # minus the 21 plus fees sent to node2
         assert_equal(self.nodes[0].getbalance(), 100 - 21)
         assert_equal(self.nodes[2].getbalance(), 21)
 
         # Node0 should have two unspent outputs.
         # Create a couple of transactions to send them to node2, submit them through
         # node1, and make sure both node0 and node2 pick them up properly:
         node0utxos = self.nodes[0].listunspent(1)
         assert_equal(len(node0utxos), 2)
 
         # create both transactions
         txns_to_send = []
         for utxo in node0utxos:
             inputs = []
             outputs = {}
             inputs.append({"txid": utxo["txid"], "vout": utxo["vout"]})
             outputs[self.nodes[2].getnewaddress()] = utxo["amount"] - 3
             raw_tx = self.nodes[0].createrawtransaction(inputs, outputs)
             txns_to_send.append(
                 self.nodes[0].signrawtransactionwithwallet(raw_tx))
 
         # Have node 1 (miner) send the transactions
         self.nodes[1].sendrawtransaction(txns_to_send[0]["hex"], True)
         self.nodes[1].sendrawtransaction(txns_to_send[1]["hex"], True)
 
         # Have node1 mine a block to confirm transactions:
         self.nodes[1].generate(1)
         self.sync_all([self.nodes[0:3]])
 
         assert_equal(self.nodes[0].getbalance(), 0)
         assert_equal(self.nodes[2].getbalance(), 94)
 
         # Verify that a spent output cannot be locked anymore
         spent_0 = {"txid": node0utxos[0]["txid"],
                    "vout": node0utxos[0]["vout"]}
         assert_raises_rpc_error(-8, "Invalid parameter, expected unspent output",
                                 self.nodes[0].lockunspent, False, [spent_0])
 
         # Send 10 BCH normal
         old_balance = self.nodes[2].getbalance()
         address = self.nodes[0].getnewaddress("test")
         fee_per_byte = Decimal('0.001') / 1000
         self.nodes[2].settxfee(fee_per_byte * 1000)
         txid = self.nodes[2].sendtoaddress(address, 10, "", "", False)
         self.nodes[2].generate(1)
         self.sync_all([self.nodes[0:3]])
         ctx = FromHex(CTransaction(), self.nodes[2].getrawtransaction(txid))
         node_2_bal = self.check_fee_amount(self.nodes[2].getbalance(), old_balance - Decimal('10'),
                                            fee_per_byte, ctx.billable_size())
         assert_equal(self.nodes[0].getbalance(), Decimal('10'))
 
         # Send 10 BCH with subtract fee from amount
         txid = self.nodes[2].sendtoaddress(address, 10, "", "", True)
         self.nodes[2].generate(1)
         self.sync_all([self.nodes[0:3]])
         node_2_bal -= Decimal('10')
         assert_equal(self.nodes[2].getbalance(), node_2_bal)
         node_0_bal = self.check_fee_amount(self.nodes[0].getbalance(), Decimal(
             '20'), fee_per_byte, count_bytes(self.nodes[2].getrawtransaction(txid)))
 
         # Sendmany 10 BCH
         txid = self.nodes[2].sendmany('', {address: 10}, 0, "", [])
         self.nodes[2].generate(1)
         self.sync_all([self.nodes[0:3]])
         node_0_bal += Decimal('10')
         ctx = FromHex(CTransaction(), self.nodes[2].getrawtransaction(txid))
         node_2_bal = self.check_fee_amount(self.nodes[2].getbalance(
         ), node_2_bal - Decimal('10'), fee_per_byte, ctx.billable_size())
         assert_equal(self.nodes[0].getbalance(), node_0_bal)
 
         # Sendmany 10 BCH with subtract fee from amount
         txid = self.nodes[2].sendmany('', {address: 10}, 0, "", [address])
         self.nodes[2].generate(1)
         self.sync_all([self.nodes[0:3]])
         node_2_bal -= Decimal('10')
         assert_equal(self.nodes[2].getbalance(), node_2_bal)
         ctx = FromHex(CTransaction(), self.nodes[2].getrawtransaction(txid))
         node_0_bal = self.check_fee_amount(self.nodes[0].getbalance(
         ), node_0_bal + Decimal('10'), fee_per_byte, ctx.billable_size())
 
         # Test ResendWalletTransactions:
         # Create a couple of transactions, then start up a fourth
         # node (nodes[3]) and ask nodes[0] to rebroadcast.
         # EXPECT: nodes[3] should have those transactions in its mempool.
         txid1 = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 1)
         txid2 = self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), 1)
         sync_mempools(self.nodes[0:2])
 
-        self.start_node(3)
+        self.start_node(3, self.extra_args[3])
         connect_nodes_bi(self.nodes[0], self.nodes[3])
         sync_blocks(self.nodes)
 
         relayed = self.nodes[0].resendwallettransactions()
         assert_equal(set(relayed), {txid1, txid2})
         sync_mempools(self.nodes)
 
         assert txid1 in self.nodes[3].getrawmempool()
 
         # Exercise balance rpcs
         assert_equal(self.nodes[0].getwalletinfo()["unconfirmed_balance"], 1)
         assert_equal(self.nodes[0].getunconfirmedbalance(), 1)
 
         # check if we can list zero value tx as available coins
         # 1. create rawtx
         # 2. hex-changed one output to 0.0
         # 3. sign and send
         # 4. check if recipient (node0) can list the zero value tx
         usp = self.nodes[1].listunspent()
         inputs = [{"txid": usp[0]['txid'], "vout":usp[0]['vout']}]
         outputs = {self.nodes[1].getnewaddress(): 49.998,
                    self.nodes[0].getnewaddress(): 11.11}
 
         rawTx = self.nodes[1].createrawtransaction(inputs, outputs).replace(
             "c0833842", "00000000")  # replace 11.11 with 0.0 (int32)
         decRawTx = self.nodes[1].decoderawtransaction(rawTx)
         signedRawTx = self.nodes[1].signrawtransactionwithwallet(rawTx)
         decRawTx = self.nodes[1].decoderawtransaction(signedRawTx['hex'])
         zeroValueTxid = decRawTx['txid']
         self.nodes[1].sendrawtransaction(signedRawTx['hex'])
 
         self.sync_all()
         self.nodes[1].generate(1)  # mine a block
         self.sync_all()
 
         # zero value tx must be in listunspents output
         unspentTxs = self.nodes[0].listunspent()
         found = False
         for uTx in unspentTxs:
             if uTx['txid'] == zeroValueTxid:
                 found = True
                 assert_equal(uTx['amount'], Decimal('0'))
         assert found
 
         # do some -walletbroadcast tests
         self.stop_nodes()
-        self.start_node(0, ["-walletbroadcast=0"])
-        self.start_node(1, ["-walletbroadcast=0"])
-        self.start_node(2, ["-walletbroadcast=0"])
+        self.start_node(0, self.extra_args[0] + ["-walletbroadcast=0"])
+        self.start_node(1, self.extra_args[1] + ["-walletbroadcast=0"])
+        self.start_node(2, self.extra_args[2] + ["-walletbroadcast=0"])
         connect_nodes_bi(self.nodes[0], self.nodes[1])
         connect_nodes_bi(self.nodes[1], self.nodes[2])
         connect_nodes_bi(self.nodes[0], self.nodes[2])
         self.sync_all([self.nodes[0:3]])
 
         txIdNotBroadcasted = self.nodes[0].sendtoaddress(
             self.nodes[2].getnewaddress(), 2)
         txObjNotBroadcasted = self.nodes[0].gettransaction(txIdNotBroadcasted)
         self.nodes[1].generate(1)  # mine a block, tx should not be in there
         self.sync_all([self.nodes[0:3]])
         # should not be changed because tx was not broadcasted
         assert_equal(self.nodes[2].getbalance(), node_2_bal)
 
         # now broadcast from another node, mine a block, sync, and check the
         # balance
         self.nodes[1].sendrawtransaction(txObjNotBroadcasted['hex'])
         self.nodes[1].generate(1)
         self.sync_all([self.nodes[0:3]])
         node_2_bal += 2
         txObjNotBroadcasted = self.nodes[0].gettransaction(txIdNotBroadcasted)
         assert_equal(self.nodes[2].getbalance(), node_2_bal)
 
         # create another tx
         txIdNotBroadcasted = self.nodes[0].sendtoaddress(
             self.nodes[2].getnewaddress(), 2)
 
         # restart the nodes with -walletbroadcast=1
         self.stop_nodes()
-        self.start_node(0)
-        self.start_node(1)
-        self.start_node(2)
+        self.start_node(0, self.extra_args[0])
+        self.start_node(1, self.extra_args[1])
+        self.start_node(2, self.extra_args[2])
         connect_nodes_bi(self.nodes[0], self.nodes[1])
         connect_nodes_bi(self.nodes[1], self.nodes[2])
         connect_nodes_bi(self.nodes[0], self.nodes[2])
         sync_blocks(self.nodes[0:3])
 
         self.nodes[0].generate(1)
         sync_blocks(self.nodes[0:3])
         node_2_bal += 2
 
         # tx should be added to balance because after restarting the nodes tx
         # should be broadcasted
         assert_equal(self.nodes[2].getbalance(), node_2_bal)
 
         # send a tx with value in a string (PR#6380 +)
         txId = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "2")
         txObj = self.nodes[0].gettransaction(txId)
         assert_equal(txObj['amount'], Decimal('-2'))
 
         txId = self.nodes[0].sendtoaddress(
             self.nodes[2].getnewaddress(), "0.0001")
         txObj = self.nodes[0].gettransaction(txId)
         assert_equal(txObj['amount'], Decimal('-0.0001'))
 
         # check if JSON parser can handle scientific notation in strings
         txId = self.nodes[0].sendtoaddress(
             self.nodes[2].getnewaddress(), "1e-4")
         txObj = self.nodes[0].gettransaction(txId)
         assert_equal(txObj['amount'], Decimal('-0.0001'))
 
         # This will raise an exception because the amount type is wrong
         assert_raises_rpc_error(-3, "Invalid amount",
                                 self.nodes[0].sendtoaddress, self.nodes[2].getnewaddress(), "1f-4")
 
         # This will raise an exception since generate does not accept a string
         assert_raises_rpc_error(-1, "not an integer",
                                 self.nodes[0].generate, "2")
 
         # Import address and private key to check correct behavior of spendable unspents
         # 1. Send some coins to generate new UTXO
         address_to_import = self.nodes[2].getnewaddress()
         txid = self.nodes[0].sendtoaddress(address_to_import, 1)
         self.nodes[0].generate(1)
         self.sync_all([self.nodes[0:3]])
 
         # 2. Import address from node2 to node1
         self.nodes[1].importaddress(address_to_import)
 
         # 3. Validate that the imported address is watch-only on node1
         assert self.nodes[1].getaddressinfo(address_to_import)["iswatchonly"]
 
         # 4. Check that the unspents after import are not spendable
         assert_array_result(self.nodes[1].listunspent(),
                             {"address": address_to_import},
                             {"spendable": False})
 
         # 5. Import private key of the previously imported address on node1
         priv_key = self.nodes[2].dumpprivkey(address_to_import)
         self.nodes[1].importprivkey(priv_key)
 
         # 6. Check that the unspents are now spendable on node1
         assert_array_result(self.nodes[1].listunspent(),
                             {"address": address_to_import},
                             {"spendable": True})
 
         # Mine a block from node0 to an address from node1
         cbAddr = self.nodes[1].getnewaddress()
         blkHash = self.nodes[0].generatetoaddress(1, cbAddr)[0]
         cbTxId = self.nodes[0].getblock(blkHash)['tx'][0]
         self.sync_all([self.nodes[0:3]])
 
         # Check that the txid and balance is found by node1
         self.nodes[1].gettransaction(cbTxId)
 
         # check if wallet or blockchain maintenance changes the balance
         self.sync_all([self.nodes[0:3]])
         blocks = self.nodes[0].generate(2)
         self.sync_all([self.nodes[0:3]])
         balance_nodes = [self.nodes[i].getbalance() for i in range(3)]
         block_count = self.nodes[0].getblockcount()
 
         # Check modes:
         #   - True: unicode escaped as \u....
         #   - False: unicode directly as UTF-8
         for mode in [True, False]:
             self.nodes[0].rpc.ensure_ascii = mode
             # unicode check: Basic Multilingual Plane, Supplementary Plane
             # respectively
             for label in [u'рыба', u'𝅘𝅥𝅯']:
                 addr = self.nodes[0].getnewaddress()
                 self.nodes[0].setlabel(addr, label)
                 assert_equal(self.nodes[0].getaddressinfo(
                     addr)['label'], label)
                 assert(label in self.nodes[0].listlabels())
         # restore to default
         self.nodes[0].rpc.ensure_ascii = True
 
         # maintenance tests
         maintenance = [
             '-rescan',
             '-reindex',
             '-zapwallettxes=1',
             '-zapwallettxes=2',
             # disabled until issue is fixed: https://github.com/bitcoin/bitcoin/issues/7463
             # '-salvagewallet',
         ]
         chainlimit = 6
         for m in maintenance:
             self.log.info("check " + m)
             self.stop_nodes()
             # set lower ancestor limit for later
-            self.start_node(0, [m, "-limitancestorcount=" + str(chainlimit)])
-            self.start_node(1, [m, "-limitancestorcount=" + str(chainlimit)])
-            self.start_node(2, [m, "-limitancestorcount=" + str(chainlimit)])
+            self.start_node(
+                0, self.extra_args[0] + [m, "-limitancestorcount=" + str(chainlimit)])
+            self.start_node(
+                1, self.extra_args[1] + [m, "-limitancestorcount=" + str(chainlimit)])
+            self.start_node(
+                2, self.extra_args[2] + [m, "-limitancestorcount=" + str(chainlimit)])
             if m == '-reindex':
                 # reindex will leave rpc warm up "early"; Wait for it to finish
                 wait_until(lambda: [block_count] * 3 ==
                            [self.nodes[i].getblockcount() for i in range(3)])
             assert_equal(balance_nodes, [
                          self.nodes[i].getbalance() for i in range(3)])
 
         # Exercise listsinceblock with the last two blocks
         coinbase_tx_1 = self.nodes[0].listsinceblock(blocks[0])
         assert_equal(coinbase_tx_1["lastblock"], blocks[1])
         assert_equal(len(coinbase_tx_1["transactions"]), 1)
         assert_equal(coinbase_tx_1["transactions"][0]["blockhash"], blocks[1])
         assert_equal(len(self.nodes[0].listsinceblock(
             blocks[1])["transactions"]), 0)
 
         # ==Check that wallet prefers to use coins that don't exceed mempool li
 
         # Get all non-zero utxos together
         chain_addrs = [self.nodes[0].getnewaddress(
         ), self.nodes[0].getnewaddress()]
         singletxid = self.nodes[0].sendtoaddress(
             chain_addrs[0], self.nodes[0].getbalance(), "", "", True)
         self.nodes[0].generate(1)
         node0_balance = self.nodes[0].getbalance()
         # Split into two chains
         rawtx = self.nodes[0].createrawtransaction([{"txid": singletxid, "vout": 0}], {
                                                    chain_addrs[0]: node0_balance / 2 - Decimal('0.01'), chain_addrs[1]: node0_balance / 2 - Decimal('0.01')})
         signedtx = self.nodes[0].signrawtransactionwithwallet(rawtx)
         singletxid = self.nodes[0].sendrawtransaction(signedtx["hex"])
         self.nodes[0].generate(1)
 
         # Make a long chain of unconfirmed payments without hitting mempool limit
         # Each tx we make leaves only one output of change on a chain 1 longer
         # Since the amount to send is always much less than the outputs, we only ever need one output
         # So we should be able to generate exactly chainlimit txs for each
         # original output
         sending_addr = self.nodes[1].getnewaddress()
         txid_list = []
         for i in range(chainlimit * 2):
             txid_list.append(self.nodes[0].sendtoaddress(
                 sending_addr, Decimal('0.0001')))
         assert_equal(self.nodes[0].getmempoolinfo()['size'], chainlimit * 2)
         assert_equal(len(txid_list), chainlimit * 2)
 
         # Without walletrejectlongchains, we will still generate a txid
         # The tx will be stored in the wallet but not accepted to the mempool
         extra_txid = self.nodes[0].sendtoaddress(
             sending_addr, Decimal('0.0001'))
         assert extra_txid not in self.nodes[0].getrawmempool()
         assert extra_txid in [tx["txid"]
                               for tx in self.nodes[0].listtransactions()]
         self.nodes[0].abandontransaction(extra_txid)
         total_txs = len(self.nodes[0].listtransactions("*", 99999))
 
         # Try with walletrejectlongchains
         # Double chain limit but require combining inputs, so we pass
         # SelectCoinsMinConf
         self.stop_node(0)
-        self.start_node(0, extra_args=[
-                        "-walletrejectlongchains", "-limitancestorcount=" + str(2 * chainlimit)])
+        self.start_node(0,
+                        self.extra_args[0] + ["-walletrejectlongchains",
+                                              "-limitancestorcount=" + str(2 * chainlimit)])
 
         # wait for loadmempool
         timeout = 10
         while (timeout > 0 and len(
                 self.nodes[0].getrawmempool()) < chainlimit * 2):
             time.sleep(0.5)
             timeout -= 0.5
         assert_equal(len(self.nodes[0].getrawmempool()), chainlimit * 2)
 
         node0_balance = self.nodes[0].getbalance()
         # With walletrejectlongchains we will not create the tx and store it in
         # our wallet.
         assert_raises_rpc_error(-4, "Transaction has too long of a mempool chain",
                                 self.nodes[0].sendtoaddress, sending_addr, node0_balance - Decimal('0.01'))
 
         # Verify nothing new in wallet
         assert_equal(total_txs, len(
             self.nodes[0].listtransactions("*", 99999)))
 
         # Test getaddressinfo on external address. Note that these addresses
         # are taken from disablewallet.py
         assert_raises_rpc_error(-5, "Invalid address",
                                 self.nodes[0].getaddressinfo, "3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy")
         address_info = self.nodes[0].getaddressinfo(
             "mneYUmWYsuk7kySiURxCi3AGxrAqZxLgPZ")
         assert_equal(address_info['address'],
                      "bchreg:qp8rs4qyd3aazk22eyzwg7fmdfzmxm02pywavdajx4")
         assert_equal(address_info["scriptPubKey"],
                      "76a9144e3854046c7bd1594ac904e4793b6a45b36dea0988ac")
         assert not address_info["ismine"]
         assert not address_info["iswatchonly"]
         assert not address_info["isscript"]
         assert not address_info["ischange"]
 
         # Test getaddressinfo 'ischange' field on change address.
         self.nodes[0].generate(1)
         destination = self.nodes[1].getnewaddress()
         txid = self.nodes[0].sendtoaddress(destination, 0.123)
         tx = self.nodes[0].decoderawtransaction(
             self.nodes[0].getrawtransaction(txid))
         output_addresses = [vout['scriptPubKey']['addresses'][0]
                             for vout in tx["vout"]]
         assert len(output_addresses) > 1
         for address in output_addresses:
             ischange = self.nodes[0].getaddressinfo(address)['ischange']
             assert_equal(ischange, address != destination)
             if ischange:
                 change = address
         self.nodes[0].setlabel(change, 'foobar')
         assert_equal(self.nodes[0].getaddressinfo(change)['ischange'], False)
 
 
 if __name__ == '__main__':
     WalletTest().main()