diff --git a/src/script/ismine.cpp b/src/script/ismine.cpp
index 5365f276b..80e3723b4 100644
--- a/src/script/ismine.cpp
+++ b/src/script/ismine.cpp
@@ -1,142 +1,134 @@
 // 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.
 
 #include <script/ismine.h>
 
 #include <key.h>
 #include <keystore.h>
 #include <script/script.h>
 #include <script/sign.h>
 #include <script/standard.h>
 
 typedef std::vector<uint8_t> valtype;
 
 namespace {
 
 /**
  * This is an enum that tracks the execution context of a script, similar to
  * SigVersion in script/interpreter. It is separate however because we want to
  * distinguish between top-level scriptPubKey execution and P2SH redeemScript
  * execution (a distinction that has no impact on consensus rules).
  */
 enum class IsMineSigVersion {
     TOP = 0,  //! scriptPubKey execution
     P2SH = 1, //! P2SH redeemScript
 };
 
 /**
  * This is an internal representation of isminetype + invalidity.
  * Its order is significant, as we return the max of all explored
  * possibilities.
  */
 enum class IsMineResult {
     NO = 0,         //! Not ours
     WATCH_ONLY = 1, //! Included in watch-only balance
     SPENDABLE = 2,  //! Included in all balances
-    INVALID = 3,    //! Not spendable by anyone
+    INVALID = 3,    //! Not spendable by anyone (P2SH inside P2SH)
 };
 
 bool HaveKeys(const std::vector<valtype> &pubkeys, const CKeyStore &keystore) {
     for (const valtype &pubkey : pubkeys) {
         CKeyID keyID = CPubKey(pubkey).GetID();
         if (!keystore.HaveKey(keyID)) {
             return false;
         }
     }
     return true;
 }
 
 IsMineResult IsMineInner(const CKeyStore &keystore, const CScript &scriptPubKey,
                          IsMineSigVersion sigversion) {
     IsMineResult ret = IsMineResult::NO;
 
     std::vector<valtype> vSolutions;
     txnouttype whichType = Solver(scriptPubKey, vSolutions);
 
     CKeyID keyID;
     switch (whichType) {
         case TX_NONSTANDARD:
         case TX_NULL_DATA:
             break;
         case TX_PUBKEY:
             keyID = CPubKey(vSolutions[0]).GetID();
             if (keystore.HaveKey(keyID)) {
                 ret = std::max(ret, IsMineResult::SPENDABLE);
             }
             break;
         case TX_PUBKEYHASH:
             keyID = CKeyID(uint160(vSolutions[0]));
             if (keystore.HaveKey(keyID)) {
                 ret = std::max(ret, IsMineResult::SPENDABLE);
             }
             break;
         case TX_SCRIPTHASH: {
             if (sigversion != IsMineSigVersion::TOP) {
                 // P2SH inside P2SH is invalid.
                 return IsMineResult::INVALID;
             }
             CScriptID scriptID = CScriptID(uint160(vSolutions[0]));
             CScript subscript;
             if (keystore.GetCScript(scriptID, subscript)) {
                 ret = std::max(ret, IsMineInner(keystore, subscript,
                                                 IsMineSigVersion::P2SH));
             }
             break;
         }
         case TX_MULTISIG: {
             // Never treat bare multisig outputs as ours (they can still be made
             // watchonly-though)
             if (sigversion == IsMineSigVersion::TOP) {
                 break;
             }
 
             // Only consider transactions "mine" if we own ALL the keys
             // involved. Multi-signature transactions that are partially owned
             // (somebody else has a key that can spend them) enable
             // spend-out-from-under-you attacks, especially in shared-wallet
             // situations.
             std::vector<valtype> keys(vSolutions.begin() + 1,
                                       vSolutions.begin() + vSolutions.size() -
                                           1);
             if (HaveKeys(keys, keystore)) {
                 ret = std::max(ret, IsMineResult::SPENDABLE);
             }
             break;
         }
     }
 
     if (ret == IsMineResult::NO && keystore.HaveWatchOnly(scriptPubKey)) {
         ret = std::max(ret, IsMineResult::WATCH_ONLY);
     }
     return ret;
 }
 
 } // namespace
 
-isminetype IsMine(const CKeyStore &keystore, const CScript &scriptPubKey,
-                  bool &isInvalid) {
-    isInvalid = false;
+isminetype IsMine(const CKeyStore &keystore, const CScript &scriptPubKey) {
     switch (IsMineInner(keystore, scriptPubKey, IsMineSigVersion::TOP)) {
         case IsMineResult::INVALID:
-            isInvalid = true;
         case IsMineResult::NO:
             return ISMINE_NO;
         case IsMineResult::WATCH_ONLY:
             return ISMINE_WATCH_ONLY;
         case IsMineResult::SPENDABLE:
             return ISMINE_SPENDABLE;
     }
     assert(false);
 }
 
-isminetype IsMine(const CKeyStore &keystore, const CScript &scriptPubKey) {
-    bool isInvalid = false;
-    return IsMine(keystore, scriptPubKey, isInvalid);
-}
-
 isminetype IsMine(const CKeyStore &keystore, const CTxDestination &dest) {
     CScript script = GetScriptForDestination(dest);
     return IsMine(keystore, script);
 }
diff --git a/src/script/ismine.h b/src/script/ismine.h
index 0d6e4d88e..eac3c19b6 100644
--- a/src/script/ismine.h
+++ b/src/script/ismine.h
@@ -1,55 +1,46 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_SCRIPT_ISMINE_H
 #define BITCOIN_SCRIPT_ISMINE_H
 
 #include <script/standard.h>
 
 #include <bitset>
 #include <cstdint>
 
 class CKeyStore;
 class CScript;
 
 /** IsMine() return codes */
 enum isminetype {
     ISMINE_NO = 0,
     ISMINE_WATCH_ONLY = 1 << 0,
     ISMINE_SPENDABLE = 1 << 1,
     ISMINE_ALL = ISMINE_WATCH_ONLY | ISMINE_SPENDABLE,
     ISMINE_ENUM_ELEMENTS,
 };
 
 /** used for bitflags of isminetype */
 typedef uint8_t isminefilter;
 
-/**
- * isInvalid becomes true when the script is found invalid by consensus or
- * policy. This will terminate the recursion and return ISMINE_NO immediately,
- * as an invalid script should never be considered as "mine". Currently the only
- * use of isInvalid is for P2SH-inside-P2SH scripts (as a technicality, to
- * prevent infinite recursion).
- */
-isminetype IsMine(const CKeyStore &keystore, const CScript &scriptPubKey,
-                  bool &isInvalid);
 isminetype IsMine(const CKeyStore &keystore, const CScript &scriptPubKey);
 isminetype IsMine(const CKeyStore &keystore, const CTxDestination &dest);
 
 /**
  * Cachable amount subdivided into watchonly and spendable parts.
  */
 struct CachableAmount {
     // NO and ALL are never (supposed to be) cached
     std::bitset<ISMINE_ENUM_ELEMENTS> m_cached;
     Amount m_value[ISMINE_ENUM_ELEMENTS];
     inline void Reset() { m_cached.reset(); }
     void Set(isminefilter filter, Amount value) {
         m_cached.set(filter);
         m_value[filter] = value;
     }
 };
 
 #endif // BITCOIN_SCRIPT_ISMINE_H
diff --git a/src/script/standard.cpp b/src/script/standard.cpp
index 02988d8d8..f4305bc37 100644
--- a/src/script/standard.cpp
+++ b/src/script/standard.cpp
@@ -1,268 +1,269 @@
 // 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.
 
 #include <script/standard.h>
 
+#include <crypto/sha256.h>
 #include <pubkey.h>
 #include <script/script.h>
 
 typedef std::vector<uint8_t> valtype;
 
 bool fAcceptDatacarrier = DEFAULT_ACCEPT_DATACARRIER;
 
 CScriptID::CScriptID(const CScript &in)
     : uint160(Hash160(in.begin(), in.end())) {}
 
 const char *GetTxnOutputType(txnouttype t) {
     switch (t) {
         case TX_NONSTANDARD:
             return "nonstandard";
         case TX_PUBKEY:
             return "pubkey";
         case TX_PUBKEYHASH:
             return "pubkeyhash";
         case TX_SCRIPTHASH:
             return "scripthash";
         case TX_MULTISIG:
             return "multisig";
         case TX_NULL_DATA:
             return "nulldata";
     }
     return nullptr;
 }
 
 static bool MatchPayToPubkey(const CScript &script, valtype &pubkey) {
     if (script.size() == CPubKey::PUBLIC_KEY_SIZE + 2 &&
         script[0] == CPubKey::PUBLIC_KEY_SIZE && script.back() == OP_CHECKSIG) {
         pubkey = valtype(script.begin() + 1,
                          script.begin() + CPubKey::PUBLIC_KEY_SIZE + 1);
         return CPubKey::ValidSize(pubkey);
     }
     if (script.size() == CPubKey::COMPRESSED_PUBLIC_KEY_SIZE + 2 &&
         script[0] == CPubKey::COMPRESSED_PUBLIC_KEY_SIZE &&
         script.back() == OP_CHECKSIG) {
         pubkey =
             valtype(script.begin() + 1,
                     script.begin() + CPubKey::COMPRESSED_PUBLIC_KEY_SIZE + 1);
         return CPubKey::ValidSize(pubkey);
     }
     return false;
 }
 
 static bool MatchPayToPubkeyHash(const CScript &script, valtype &pubkeyhash) {
     if (script.size() == 25 && script[0] == OP_DUP && script[1] == OP_HASH160 &&
         script[2] == 20 && script[23] == OP_EQUALVERIFY &&
         script[24] == OP_CHECKSIG) {
         pubkeyhash = valtype(script.begin() + 3, script.begin() + 23);
         return true;
     }
     return false;
 }
 
 /** Test for "small positive integer" script opcodes - OP_1 through OP_16. */
 static constexpr bool IsSmallInteger(opcodetype opcode) {
     return opcode >= OP_1 && opcode <= OP_16;
 }
 
 static bool MatchMultisig(const CScript &script, unsigned int &required,
                           std::vector<valtype> &pubkeys) {
     opcodetype opcode;
     valtype data;
     CScript::const_iterator it = script.begin();
     if (script.size() < 1 || script.back() != OP_CHECKMULTISIG) {
         return false;
     }
 
     if (!script.GetOp(it, opcode, data) || !IsSmallInteger(opcode)) {
         return false;
     }
     required = CScript::DecodeOP_N(opcode);
     while (script.GetOp(it, opcode, data) && CPubKey::ValidSize(data)) {
         if (opcode < 0 || opcode > OP_PUSHDATA4 ||
             !CheckMinimalPush(data, opcode)) {
             return false;
         }
         pubkeys.emplace_back(std::move(data));
     }
     if (!IsSmallInteger(opcode)) {
         return false;
     }
     unsigned int keys = CScript::DecodeOP_N(opcode);
     if (pubkeys.size() != keys || keys < required) {
         return false;
     }
     return (it + 1 == script.end());
 }
 
 txnouttype Solver(const CScript &scriptPubKey,
                   std::vector<std::vector<uint8_t>> &vSolutionsRet) {
     vSolutionsRet.clear();
 
     // Shortcut for pay-to-script-hash, which are more constrained than the
     // other types:
     // it is always OP_HASH160 20 [20 byte hash] OP_EQUAL
     if (scriptPubKey.IsPayToScriptHash()) {
         std::vector<uint8_t> hashBytes(scriptPubKey.begin() + 2,
                                        scriptPubKey.begin() + 22);
         vSolutionsRet.push_back(hashBytes);
         return TX_SCRIPTHASH;
     }
 
     // Provably prunable, data-carrying output
     //
     // So long as script passes the IsUnspendable() test and all but the first
     // byte passes the IsPushOnly() test we don't care what exactly is in the
     // script.
     if (scriptPubKey.size() >= 1 && scriptPubKey[0] == OP_RETURN &&
         scriptPubKey.IsPushOnly(scriptPubKey.begin() + 1)) {
         return TX_NULL_DATA;
     }
 
     std::vector<uint8_t> data;
     if (MatchPayToPubkey(scriptPubKey, data)) {
         vSolutionsRet.push_back(std::move(data));
         return TX_PUBKEY;
     }
 
     if (MatchPayToPubkeyHash(scriptPubKey, data)) {
         vSolutionsRet.push_back(std::move(data));
         return TX_PUBKEYHASH;
     }
 
     unsigned int required;
     std::vector<std::vector<uint8_t>> keys;
     if (MatchMultisig(scriptPubKey, required, keys)) {
         // safe as required is in range 1..16
         vSolutionsRet.push_back({static_cast<uint8_t>(required)});
         vSolutionsRet.insert(vSolutionsRet.end(), keys.begin(), keys.end());
         // safe as size is in range 1..16
         vSolutionsRet.push_back({static_cast<uint8_t>(keys.size())});
         return TX_MULTISIG;
     }
 
     vSolutionsRet.clear();
     return TX_NONSTANDARD;
 }
 
 bool ExtractDestination(const CScript &scriptPubKey,
                         CTxDestination &addressRet) {
     std::vector<valtype> vSolutions;
     txnouttype whichType = Solver(scriptPubKey, vSolutions);
 
     if (whichType == TX_PUBKEY) {
         CPubKey pubKey(vSolutions[0]);
         if (!pubKey.IsValid()) {
             return false;
         }
 
         addressRet = pubKey.GetID();
         return true;
     }
     if (whichType == TX_PUBKEYHASH) {
         addressRet = CKeyID(uint160(vSolutions[0]));
         return true;
     }
     if (whichType == TX_SCRIPTHASH) {
         addressRet = CScriptID(uint160(vSolutions[0]));
         return true;
     }
     // Multisig txns have more than one address...
     return false;
 }
 
 bool ExtractDestinations(const CScript &scriptPubKey, txnouttype &typeRet,
                          std::vector<CTxDestination> &addressRet,
                          int &nRequiredRet) {
     addressRet.clear();
     std::vector<valtype> vSolutions;
     typeRet = Solver(scriptPubKey, vSolutions);
     if (typeRet == TX_NONSTANDARD) {
         return false;
     } else if (typeRet == TX_NULL_DATA) {
         // This is data, not addresses
         return false;
     }
 
     if (typeRet == TX_MULTISIG) {
         nRequiredRet = vSolutions.front()[0];
         for (size_t i = 1; i < vSolutions.size() - 1; i++) {
             CPubKey pubKey(vSolutions[i]);
             if (!pubKey.IsValid()) {
                 continue;
             }
 
             CTxDestination address = pubKey.GetID();
             addressRet.push_back(address);
         }
 
         if (addressRet.empty()) {
             return false;
         }
     } else {
         nRequiredRet = 1;
         CTxDestination address;
         if (!ExtractDestination(scriptPubKey, address)) {
             return false;
         }
         addressRet.push_back(address);
     }
 
     return true;
 }
 
 namespace {
 class CScriptVisitor : public boost::static_visitor<bool> {
 private:
     CScript *script;
 
 public:
     explicit CScriptVisitor(CScript *scriptin) { script = scriptin; }
 
     bool operator()(const CNoDestination &dest) const {
         script->clear();
         return false;
     }
 
     bool operator()(const CKeyID &keyID) const {
         script->clear();
         *script << OP_DUP << OP_HASH160 << ToByteVector(keyID) << OP_EQUALVERIFY
                 << OP_CHECKSIG;
         return true;
     }
 
     bool operator()(const CScriptID &scriptID) const {
         script->clear();
         *script << OP_HASH160 << ToByteVector(scriptID) << OP_EQUAL;
         return true;
     }
 };
 } // namespace
 
 CScript GetScriptForDestination(const CTxDestination &dest) {
     CScript script;
 
     boost::apply_visitor(CScriptVisitor(&script), dest);
     return script;
 }
 
 CScript GetScriptForRawPubKey(const CPubKey &pubKey) {
     return CScript() << std::vector<uint8_t>(pubKey.begin(), pubKey.end())
                      << OP_CHECKSIG;
 }
 
 CScript GetScriptForMultisig(int nRequired, const std::vector<CPubKey> &keys) {
     CScript script;
 
     script << CScript::EncodeOP_N(nRequired);
     for (const CPubKey &key : keys) {
         script << ToByteVector(key);
     }
     script << CScript::EncodeOP_N(keys.size()) << OP_CHECKMULTISIG;
     return script;
 }
 
 bool IsValidDestination(const CTxDestination &dest) {
     return dest.which() != 0;
 }
diff --git a/src/test/script_standard_tests.cpp b/src/test/script_standard_tests.cpp
index 3387c04e7..5efc91691 100644
--- a/src/test/script_standard_tests.cpp
+++ b/src/test/script_standard_tests.cpp
@@ -1,643 +1,624 @@
 // 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.
 
 #include <key.h>
 #include <keystore.h>
 #include <script/ismine.h>
 #include <script/script.h>
 #include <script/standard.h>
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 // Append given push onto a script, using specific opcode (not necessarily
 // the minimal one, but must be able to contain the given data.)
 void AppendPush(CScript &script, opcodetype opcode,
                 const std::vector<uint8_t> &b) {
     assert(opcode <= OP_PUSHDATA4);
     script.push_back(opcode);
     if (opcode < OP_PUSHDATA1) {
         assert(b.size() == opcode);
     } else if (opcode == OP_PUSHDATA1) {
         assert(b.size() <= 0xff);
         script.push_back(uint8_t(b.size()));
     } else if (opcode == OP_PUSHDATA2) {
         assert(b.size() <= 0xffff);
         uint8_t _data[2];
         WriteLE16(_data, b.size());
         script.insert(script.end(), _data, _data + sizeof(_data));
     } else if (opcode == OP_PUSHDATA4) {
         uint8_t _data[4];
         WriteLE32(_data, b.size());
         script.insert(script.end(), _data, _data + sizeof(_data));
     }
     script.insert(script.end(), b.begin(), b.end());
 }
 
 BOOST_FIXTURE_TEST_SUITE(script_standard_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(script_standard_Solver_success) {
     CKey keys[3];
     CPubKey pubkeys[3];
     for (int i = 0; i < 3; i++) {
         keys[i].MakeNewKey(true);
         pubkeys[i] = keys[i].GetPubKey();
     }
 
     CScript s;
     std::vector<std::vector<uint8_t>> solutions;
 
     // TX_PUBKEY
     s.clear();
     s << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_PUBKEY);
     BOOST_CHECK_EQUAL(solutions.size(), 1U);
     BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0]));
 
     // TX_PUBKEYHASH
     s.clear();
     s << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID())
       << OP_EQUALVERIFY << OP_CHECKSIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_PUBKEYHASH);
     BOOST_CHECK_EQUAL(solutions.size(), 1U);
     BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0].GetID()));
 
     // TX_SCRIPTHASH
     CScript redeemScript(s); // initialize with leftover P2PKH script
     s.clear();
     s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_SCRIPTHASH);
     BOOST_CHECK_EQUAL(solutions.size(), 1U);
     BOOST_CHECK(solutions[0] == ToByteVector(CScriptID(redeemScript)));
 
     // TX_MULTISIG
     s.clear();
     s << OP_1 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]) << OP_2
       << OP_CHECKMULTISIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_MULTISIG);
     BOOST_CHECK_EQUAL(solutions.size(), 4U);
     BOOST_CHECK(solutions[0] == std::vector<uint8_t>({1}));
     BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0]));
     BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1]));
     BOOST_CHECK(solutions[3] == std::vector<uint8_t>({2}));
 
     s.clear();
     s << OP_2 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1])
       << ToByteVector(pubkeys[2]) << OP_3 << OP_CHECKMULTISIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_MULTISIG);
     BOOST_CHECK_EQUAL(solutions.size(), 5U);
     BOOST_CHECK(solutions[0] == std::vector<uint8_t>({2}));
     BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0]));
     BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1]));
     BOOST_CHECK(solutions[3] == ToByteVector(pubkeys[2]));
     BOOST_CHECK(solutions[4] == std::vector<uint8_t>({3}));
 
     // TX_NULL_DATA
     s.clear();
     s << OP_RETURN << std::vector<uint8_t>({0}) << std::vector<uint8_t>({75})
       << std::vector<uint8_t>({255});
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NULL_DATA);
     BOOST_CHECK_EQUAL(solutions.size(), 0U);
 
     // TX_WITNESS_V0_KEYHASH
     s.clear();
     s << OP_0 << ToByteVector(pubkeys[0].GetID());
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
     BOOST_CHECK_EQUAL(solutions.size(), 0U);
 
     // TX_WITNESS_V0_SCRIPTHASH
     uint256 scriptHash;
     CSHA256()
         .Write(&redeemScript[0], redeemScript.size())
         .Finalize(scriptHash.begin());
 
     s.clear();
     s << OP_0 << ToByteVector(scriptHash);
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
     BOOST_CHECK_EQUAL(solutions.size(), 0U);
 
     // TX_NONSTANDARD
     s.clear();
     s << OP_9 << OP_ADD << OP_11 << OP_EQUAL;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
     BOOST_CHECK_EQUAL(solutions.size(), 0);
 
     // Try some non-minimal PUSHDATA pushes in various standard scripts
     for (auto pushdataop : {OP_PUSHDATA1, OP_PUSHDATA2, OP_PUSHDATA4}) {
         // mutated TX_PUBKEY
         s.clear();
         AppendPush(s, pushdataop, ToByteVector(pubkeys[0]));
         s << OP_CHECKSIG;
         BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
         BOOST_CHECK_EQUAL(solutions.size(), 0);
 
         // mutated TX_PUBKEYHASH
         s.clear();
         s << OP_DUP << OP_HASH160;
         AppendPush(s, pushdataop, ToByteVector(pubkeys[0].GetID()));
         s << OP_EQUALVERIFY << OP_CHECKSIG;
         BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
         BOOST_CHECK_EQUAL(solutions.size(), 0);
 
         // mutated TX_SCRIPTHASH
         s.clear();
         s << OP_HASH160;
         AppendPush(s, pushdataop, ToByteVector(CScriptID(redeemScript)));
         s << OP_EQUAL;
         BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
         BOOST_CHECK_EQUAL(solutions.size(), 0);
 
         // mutated TX_MULTISIG -- pubkey
         s.clear();
         s << OP_1;
         AppendPush(s, pushdataop, ToByteVector(pubkeys[0]));
         s << ToByteVector(pubkeys[1]) << OP_2 << OP_CHECKMULTISIG;
         BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
         BOOST_CHECK_EQUAL(solutions.size(), 0);
 
         // mutated TX_MULTISIG -- num_signatures
         s.clear();
         AppendPush(s, pushdataop, {1});
         s << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]) << OP_2
           << OP_CHECKMULTISIG;
         BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
         BOOST_CHECK_EQUAL(solutions.size(), 0);
 
         // mutated TX_MULTISIG -- num_pubkeys
         s.clear();
         s << OP_1 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]);
         AppendPush(s, pushdataop, {2});
         s << OP_CHECKMULTISIG;
         BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
         BOOST_CHECK_EQUAL(solutions.size(), 0);
     }
 
     // also try pushing the num_signatures and num_pubkeys using PUSH_N opcode
     // instead of OP_N opcode:
     s.clear();
     s << std::vector<uint8_t>{1} << ToByteVector(pubkeys[0])
       << ToByteVector(pubkeys[1]) << OP_2 << OP_CHECKMULTISIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
     BOOST_CHECK_EQUAL(solutions.size(), 0);
     s.clear();
     s << OP_1 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1])
       << std::vector<uint8_t>{2} << OP_CHECKMULTISIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
     BOOST_CHECK_EQUAL(solutions.size(), 0);
 
     // Non-minimal pushes in OP_RETURN scripts are standard (some OP_RETURN
     // protocols like SLP rely on this). Also it turns out OP_RESERVED gets past
     // IsPushOnly and thus is standard here.
     std::vector<uint8_t> op_return_nonminimal{
         OP_RETURN,    OP_RESERVED, OP_PUSHDATA1, 0x00, 0x01, 0x01,
         OP_PUSHDATA4, 0x01,        0x00,         0x00, 0x00, 0xaa};
     s.assign(op_return_nonminimal.begin(), op_return_nonminimal.end());
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NULL_DATA);
     BOOST_CHECK_EQUAL(solutions.size(), 0);
 }
 
 BOOST_AUTO_TEST_CASE(script_standard_Solver_failure) {
     CKey key;
     CPubKey pubkey;
     key.MakeNewKey(true);
     pubkey = key.GetPubKey();
 
     CScript s;
     std::vector<std::vector<uint8_t>> solutions;
 
     // TX_PUBKEY with incorrectly sized pubkey
     s.clear();
     s << std::vector<uint8_t>(30, 0x01) << OP_CHECKSIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
 
     // TX_PUBKEYHASH with incorrectly sized key hash
     s.clear();
     s << OP_DUP << OP_HASH160 << ToByteVector(pubkey) << OP_EQUALVERIFY
       << OP_CHECKSIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
 
     // TX_SCRIPTHASH with incorrectly sized script hash
     s.clear();
     s << OP_HASH160 << std::vector<uint8_t>(21, 0x01) << OP_EQUAL;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
 
     // TX_MULTISIG 0/2
     s.clear();
     s << OP_0 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
 
     // TX_MULTISIG 2/1
     s.clear();
     s << OP_2 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
 
     // TX_MULTISIG n = 2 with 1 pubkey
     s.clear();
     s << OP_1 << ToByteVector(pubkey) << OP_2 << OP_CHECKMULTISIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
 
     // TX_MULTISIG n = 1 with 0 pubkeys
     s.clear();
     s << OP_1 << OP_1 << OP_CHECKMULTISIG;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
 
     // TX_NULL_DATA with other opcodes
     s.clear();
     s << OP_RETURN << std::vector<uint8_t>({75}) << OP_ADD;
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
 
     // TX_WITNESS with unknown version
     s.clear();
     s << OP_1 << ToByteVector(pubkey);
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
 
     // TX_WITNESS with incorrect program size
     s.clear();
     s << OP_0 << std::vector<uint8_t>(19, 0x01);
     BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD);
 }
 
 BOOST_AUTO_TEST_CASE(script_standard_ExtractDestination) {
     CKey key;
     CPubKey pubkey;
     key.MakeNewKey(true);
     pubkey = key.GetPubKey();
 
     CScript s;
     CTxDestination address;
 
     // TX_PUBKEY
     s.clear();
     s << ToByteVector(pubkey) << OP_CHECKSIG;
     BOOST_CHECK(ExtractDestination(s, address));
     BOOST_CHECK(boost::get<CKeyID>(&address) &&
                 *boost::get<CKeyID>(&address) == pubkey.GetID());
 
     // TX_PUBKEYHASH
     s.clear();
     s << OP_DUP << OP_HASH160 << ToByteVector(pubkey.GetID()) << OP_EQUALVERIFY
       << OP_CHECKSIG;
     BOOST_CHECK(ExtractDestination(s, address));
     BOOST_CHECK(boost::get<CKeyID>(&address) &&
                 *boost::get<CKeyID>(&address) == pubkey.GetID());
 
     // TX_SCRIPTHASH
     CScript redeemScript(s); // initialize with leftover P2PKH script
     s.clear();
     s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
     BOOST_CHECK(ExtractDestination(s, address));
     BOOST_CHECK(boost::get<CScriptID>(&address) &&
                 *boost::get<CScriptID>(&address) == CScriptID(redeemScript));
 
     // TX_MULTISIG
     s.clear();
     s << OP_1 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
     BOOST_CHECK(!ExtractDestination(s, address));
 
     // TX_NULL_DATA
     s.clear();
     s << OP_RETURN << std::vector<uint8_t>({75});
     BOOST_CHECK(!ExtractDestination(s, address));
 
     // TX_WITNESS_V0_KEYHASH
     s.clear();
     s << OP_0 << ToByteVector(pubkey);
     BOOST_CHECK(!ExtractDestination(s, address));
 
     // TX_WITNESS_V0_SCRIPTHASH
     s.clear();
     s << OP_0 << ToByteVector(CScriptID(redeemScript));
     BOOST_CHECK(!ExtractDestination(s, address));
 }
 
 BOOST_AUTO_TEST_CASE(script_standard_ExtractDestinations) {
     CKey keys[3];
     CPubKey pubkeys[3];
     for (int i = 0; i < 3; i++) {
         keys[i].MakeNewKey(true);
         pubkeys[i] = keys[i].GetPubKey();
     }
 
     CScript s;
     txnouttype whichType;
     std::vector<CTxDestination> addresses;
     int nRequired;
 
     // TX_PUBKEY
     s.clear();
     s << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
     BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
     BOOST_CHECK_EQUAL(whichType, TX_PUBKEY);
     BOOST_CHECK_EQUAL(addresses.size(), 1U);
     BOOST_CHECK_EQUAL(nRequired, 1);
     BOOST_CHECK(boost::get<CKeyID>(&addresses[0]) &&
                 *boost::get<CKeyID>(&addresses[0]) == pubkeys[0].GetID());
 
     // TX_PUBKEYHASH
     s.clear();
     s << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID())
       << OP_EQUALVERIFY << OP_CHECKSIG;
     BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
     BOOST_CHECK_EQUAL(whichType, TX_PUBKEYHASH);
     BOOST_CHECK_EQUAL(addresses.size(), 1U);
     BOOST_CHECK_EQUAL(nRequired, 1);
     BOOST_CHECK(boost::get<CKeyID>(&addresses[0]) &&
                 *boost::get<CKeyID>(&addresses[0]) == pubkeys[0].GetID());
 
     // TX_SCRIPTHASH
     // initialize with leftover P2PKH script
     CScript redeemScript(s);
     s.clear();
     s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
     BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
     BOOST_CHECK_EQUAL(whichType, TX_SCRIPTHASH);
     BOOST_CHECK_EQUAL(addresses.size(), 1U);
     BOOST_CHECK_EQUAL(nRequired, 1);
     BOOST_CHECK(boost::get<CScriptID>(&addresses[0]) &&
                 *boost::get<CScriptID>(&addresses[0]) ==
                     CScriptID(redeemScript));
 
     // TX_MULTISIG
     s.clear();
     s << OP_2 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]) << OP_2
       << OP_CHECKMULTISIG;
     BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
     BOOST_CHECK_EQUAL(whichType, TX_MULTISIG);
     BOOST_CHECK_EQUAL(addresses.size(), 2U);
     BOOST_CHECK_EQUAL(nRequired, 2);
     BOOST_CHECK(boost::get<CKeyID>(&addresses[0]) &&
                 *boost::get<CKeyID>(&addresses[0]) == pubkeys[0].GetID());
     BOOST_CHECK(boost::get<CKeyID>(&addresses[1]) &&
                 *boost::get<CKeyID>(&addresses[1]) == pubkeys[1].GetID());
 
     // TX_NULL_DATA
     s.clear();
     s << OP_RETURN << std::vector<uint8_t>({75});
     BOOST_CHECK(!ExtractDestinations(s, whichType, addresses, nRequired));
 
     // TX_WITNESS_V0_KEYHASH
     s.clear();
     s << OP_0 << ToByteVector(pubkeys[0].GetID());
     BOOST_CHECK(!ExtractDestinations(s, whichType, addresses, nRequired));
 
     // TX_WITNESS_V0_SCRIPTHASH
     s.clear();
     s << OP_0 << ToByteVector(CScriptID(redeemScript));
     BOOST_CHECK(!ExtractDestinations(s, whichType, addresses, nRequired));
 }
 
 BOOST_AUTO_TEST_CASE(script_standard_GetScriptFor_) {
     CKey keys[3];
     CPubKey pubkeys[3];
     for (int i = 0; i < 3; i++) {
         keys[i].MakeNewKey(true);
         pubkeys[i] = keys[i].GetPubKey();
     }
 
     CScript expected, result;
 
     // CKeyID
     expected.clear();
     expected << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID())
              << OP_EQUALVERIFY << OP_CHECKSIG;
     result = GetScriptForDestination(pubkeys[0].GetID());
     BOOST_CHECK(result == expected);
 
     // CScriptID
     CScript redeemScript(result);
     expected.clear();
     expected << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
     result = GetScriptForDestination(CScriptID(redeemScript));
     BOOST_CHECK(result == expected);
 
     // CNoDestination
     expected.clear();
     result = GetScriptForDestination(CNoDestination());
     BOOST_CHECK(result == expected);
 
     // GetScriptForRawPubKey
     expected.clear();
     expected << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
     result = GetScriptForRawPubKey(pubkeys[0]);
     BOOST_CHECK(result == expected);
 
     // GetScriptForMultisig
     expected.clear();
     expected << OP_2 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1])
              << ToByteVector(pubkeys[2]) << OP_3 << OP_CHECKMULTISIG;
     result =
         GetScriptForMultisig(2, std::vector<CPubKey>(pubkeys, pubkeys + 3));
     BOOST_CHECK(result == expected);
 }
 
 BOOST_AUTO_TEST_CASE(script_standard_IsMine) {
     CKey keys[2];
     CPubKey pubkeys[2];
     for (int i = 0; i < 2; i++) {
         keys[i].MakeNewKey(true);
         pubkeys[i] = keys[i].GetPubKey();
     }
 
     CKey uncompressedKey;
     uncompressedKey.MakeNewKey(false);
     CPubKey uncompressedPubkey = uncompressedKey.GetPubKey();
 
     CScript scriptPubKey;
     isminetype result;
-    bool isInvalid;
 
     // P2PK compressed
     {
         CBasicKeyStore keystore;
-        scriptPubKey.clear();
-        scriptPubKey << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
+        scriptPubKey = GetScriptForRawPubKey(pubkeys[0]);
 
         // Keystore does not have key
-        result = IsMine(keystore, scriptPubKey, isInvalid);
+        result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
-        BOOST_CHECK(!isInvalid);
 
         // Keystore has key
         keystore.AddKey(keys[0]);
-        result = IsMine(keystore, scriptPubKey, isInvalid);
+        result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
-        BOOST_CHECK(!isInvalid);
     }
 
     // P2PK uncompressed
     {
         CBasicKeyStore keystore;
-        scriptPubKey.clear();
-        scriptPubKey << ToByteVector(uncompressedPubkey) << OP_CHECKSIG;
+        scriptPubKey = GetScriptForRawPubKey(uncompressedPubkey);
 
         // Keystore does not have key
-        result = IsMine(keystore, scriptPubKey, isInvalid);
+        result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
-        BOOST_CHECK(!isInvalid);
 
         // Keystore has key
         keystore.AddKey(uncompressedKey);
-        result = IsMine(keystore, scriptPubKey, isInvalid);
+        result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
-        BOOST_CHECK(!isInvalid);
     }
 
     // P2PKH compressed
     {
         CBasicKeyStore keystore;
-        scriptPubKey.clear();
-        scriptPubKey << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID())
-                     << OP_EQUALVERIFY << OP_CHECKSIG;
+        scriptPubKey = GetScriptForDestination(pubkeys[0].GetID());
 
         // Keystore does not have key
-        result = IsMine(keystore, scriptPubKey, isInvalid);
+        result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
-        BOOST_CHECK(!isInvalid);
 
         // Keystore has key
         keystore.AddKey(keys[0]);
-        result = IsMine(keystore, scriptPubKey, isInvalid);
+        result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
-        BOOST_CHECK(!isInvalid);
     }
 
     // P2PKH uncompressed
     {
         CBasicKeyStore keystore;
-        scriptPubKey.clear();
-        scriptPubKey << OP_DUP << OP_HASH160
-                     << ToByteVector(uncompressedPubkey.GetID())
-                     << OP_EQUALVERIFY << OP_CHECKSIG;
+        scriptPubKey = GetScriptForDestination(uncompressedPubkey.GetID());
 
         // Keystore does not have key
-        result = IsMine(keystore, scriptPubKey, isInvalid);
+        result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
-        BOOST_CHECK(!isInvalid);
 
         // Keystore has key
         keystore.AddKey(uncompressedKey);
-        result = IsMine(keystore, scriptPubKey, isInvalid);
+        result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
-        BOOST_CHECK(!isInvalid);
     }
 
     // P2SH
     {
         CBasicKeyStore keystore;
 
-        CScript redeemScript;
-        redeemScript << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID())
-                     << OP_EQUALVERIFY << OP_CHECKSIG;
-
-        scriptPubKey.clear();
-        scriptPubKey << OP_HASH160 << ToByteVector(CScriptID(redeemScript))
-                     << OP_EQUAL;
+        CScript redeemScript = GetScriptForDestination(pubkeys[0].GetID());
+        scriptPubKey = GetScriptForDestination(CScriptID(redeemScript));
 
         // Keystore does not have redeemScript or key
-        result = IsMine(keystore, scriptPubKey, isInvalid);
+        result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
-        BOOST_CHECK(!isInvalid);
 
         // Keystore has redeemScript but no key
         keystore.AddCScript(redeemScript);
-        result = IsMine(keystore, scriptPubKey, isInvalid);
+        result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
-        BOOST_CHECK(!isInvalid);
 
         // Keystore has redeemScript and key
         keystore.AddKey(keys[0]);
-        result = IsMine(keystore, scriptPubKey, isInvalid);
+        result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
-        BOOST_CHECK(!isInvalid);
+    }
+
+    // (P2PKH inside) P2SH inside P2SH (invalid)
+    {
+        CBasicKeyStore keystore;
+
+        CScript redeemscript_inner =
+            GetScriptForDestination(pubkeys[0].GetID());
+        CScript redeemscript =
+            GetScriptForDestination(CScriptID(redeemscript_inner));
+        scriptPubKey = GetScriptForDestination(CScriptID(redeemscript));
+
+        keystore.AddCScript(redeemscript);
+        keystore.AddCScript(redeemscript_inner);
+        keystore.AddCScript(scriptPubKey);
+        keystore.AddKey(keys[0]);
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
     }
 
     // scriptPubKey multisig
     {
         CBasicKeyStore keystore;
 
-        scriptPubKey.clear();
-        scriptPubKey << OP_2 << ToByteVector(uncompressedPubkey)
-                     << ToByteVector(pubkeys[1]) << OP_2 << OP_CHECKMULTISIG;
+        scriptPubKey =
+            GetScriptForMultisig(2, {uncompressedPubkey, pubkeys[1]});
 
         // Keystore does not have any keys
-        result = IsMine(keystore, scriptPubKey, isInvalid);
+        result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
-        BOOST_CHECK(!isInvalid);
 
         // Keystore has 1/2 keys
         keystore.AddKey(uncompressedKey);
 
-        result = IsMine(keystore, scriptPubKey, isInvalid);
+        result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
-        BOOST_CHECK(!isInvalid);
 
         // Keystore has 2/2 keys
         keystore.AddKey(keys[1]);
 
-        result = IsMine(keystore, scriptPubKey, isInvalid);
+        result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
-        BOOST_CHECK(!isInvalid);
 
         // Keystore has 2/2 keys and the script
         keystore.AddCScript(scriptPubKey);
 
-        result = IsMine(keystore, scriptPubKey, isInvalid);
+        result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
-        BOOST_CHECK(!isInvalid);
     }
 
     // P2SH multisig
     {
         CBasicKeyStore keystore;
         keystore.AddKey(uncompressedKey);
         keystore.AddKey(keys[1]);
 
-        CScript redeemScript;
-        redeemScript << OP_2 << ToByteVector(uncompressedPubkey)
-                     << ToByteVector(pubkeys[1]) << OP_2 << OP_CHECKMULTISIG;
-
-        scriptPubKey.clear();
-        scriptPubKey << OP_HASH160 << ToByteVector(CScriptID(redeemScript))
-                     << OP_EQUAL;
+        CScript redeemScript =
+            GetScriptForMultisig(2, {uncompressedPubkey, pubkeys[1]});
+        scriptPubKey = GetScriptForDestination(CScriptID(redeemScript));
 
         // Keystore has no redeemScript
-        result = IsMine(keystore, scriptPubKey, isInvalid);
+        result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
-        BOOST_CHECK(!isInvalid);
 
         // Keystore has redeemScript
         keystore.AddCScript(redeemScript);
-        result = IsMine(keystore, scriptPubKey, isInvalid);
+        result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
-        BOOST_CHECK(!isInvalid);
     }
 
     // OP_RETURN
     {
         CBasicKeyStore keystore;
         keystore.AddKey(keys[0]);
 
         scriptPubKey.clear();
         scriptPubKey << OP_RETURN << ToByteVector(pubkeys[0]);
 
-        result = IsMine(keystore, scriptPubKey, isInvalid);
+        result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
-        BOOST_CHECK(!isInvalid);
     }
 
     // Nonstandard
     {
         CBasicKeyStore keystore;
         keystore.AddKey(keys[0]);
 
         scriptPubKey.clear();
         scriptPubKey << OP_9 << OP_ADD << OP_11 << OP_EQUAL;
 
-        result = IsMine(keystore, scriptPubKey, isInvalid);
+        result = IsMine(keystore, scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
-        BOOST_CHECK(!isInvalid);
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()