Merge #16226: Move ismine to the wallet module

e61de6306fd89fe9aae90253062e7b1b20343f8a Change ismine to take a CWallet instead of CKeyStore (Andrew Chow)
7c611e20007bf5face34d33dffa26c8db67e29ec Move ismine to wallet module (Andrew Chow)

Pull request description:

  `IsMine` isn't used outside of the wallet except for the tests. It also doesn't make sense to be outside of the wallet. This PR moves `IsMine` into the wallet module and for it to take a `CWallet` instead of `CKeyStore`. The test that used `IsMine` is also moved to the wallet tests.

  This is first [prerequisites](https://github.com/bitcoin-core/bitcoin-devwiki/wiki/Wallet-Class-Structure-Changes#ismine) for the wallet structure changes.

ACKs for commit e61de6:
  MarcoFalke:
    re-ACK e61de6306f (only change is rebase with git auto-merge)
  meshcollider:
    Very light code review ACK https://github.com/bitcoin/bitcoin/pull/16226/commits/e61de6306fd89fe9aae90253062e7b1b20343f8a

Tree-SHA512: 1cb4ad12652aef7922ab7460c6d413e8b9d1855dca78c0a286ae49d5c0765bc7996c55f262c742001d434eb9bd4215dc2cc7aae1b371ee1a82d46b32c17e6341

5 files changed, 646 insertions, 2 deletions

diff --git a/src/wallet/ismine.cpp b/src/wallet/ismine.cpp
new file mode 100644
index 0000000000..6138d4ae44
--- /dev/null
+++ b/src/wallet/ismine.cpp
@@ -0,0 +1,192 @@
+// 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.
+
+#include <wallet/ismine.h>
+
+#include <key.h>
+#include <script/script.h>
+#include <script/sign.h>
+#include <wallet/wallet.h>
+
+typedef std::vector<unsigned char> 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
+    WITNESS_V0 = 2, //!< P2WSH witness script execution
+};
+
+/**
+ * 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 (uncompressed pubkey in segwit, P2SH inside P2SH or witness, witness inside witness)
+};
+
+bool PermitsUncompressed(IsMineSigVersion sigversion)
+{
+    return sigversion == IsMineSigVersion::TOP || sigversion == IsMineSigVersion::P2SH;
+}
+
+bool HaveKeys(const std::vector<valtype>& pubkeys, const CWallet& keystore)
+{
+    for (const valtype& pubkey : pubkeys) {
+        CKeyID keyID = CPubKey(pubkey).GetID();
+        if (!keystore.HaveKey(keyID)) return false;
+    }
+    return true;
+}
+
+IsMineResult IsMineInner(const CWallet& 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:
+    case TX_WITNESS_UNKNOWN:
+        break;
+    case TX_PUBKEY:
+        keyID = CPubKey(vSolutions[0]).GetID();
+        if (!PermitsUncompressed(sigversion) && vSolutions[0].size() != 33) {
+            return IsMineResult::INVALID;
+        }
+        if (keystore.HaveKey(keyID)) {
+            ret = std::max(ret, IsMineResult::SPENDABLE);
+        }
+        break;
+    case TX_WITNESS_V0_KEYHASH:
+    {
+        if (sigversion == IsMineSigVersion::WITNESS_V0) {
+            // P2WPKH inside P2WSH is invalid.
+            return IsMineResult::INVALID;
+        }
+        if (sigversion == IsMineSigVersion::TOP && !keystore.HaveCScript(CScriptID(CScript() << OP_0 << vSolutions[0]))) {
+            // We do not support bare witness outputs unless the P2SH version of it would be
+            // acceptable as well. This protects against matching before segwit activates.
+            // This also applies to the P2WSH case.
+            break;
+        }
+        ret = std::max(ret, IsMineInner(keystore, GetScriptForDestination(PKHash(uint160(vSolutions[0]))), IsMineSigVersion::WITNESS_V0));
+        break;
+    }
+    case TX_PUBKEYHASH:
+        keyID = CKeyID(uint160(vSolutions[0]));
+        if (!PermitsUncompressed(sigversion)) {
+            CPubKey pubkey;
+            if (keystore.GetPubKey(keyID, pubkey) && !pubkey.IsCompressed()) {
+                return IsMineResult::INVALID;
+            }
+        }
+        if (keystore.HaveKey(keyID)) {
+            ret = std::max(ret, IsMineResult::SPENDABLE);
+        }
+        break;
+    case TX_SCRIPTHASH:
+    {
+        if (sigversion != IsMineSigVersion::TOP) {
+            // P2SH inside P2WSH or 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_WITNESS_V0_SCRIPTHASH:
+    {
+        if (sigversion == IsMineSigVersion::WITNESS_V0) {
+            // P2WSH inside P2WSH is invalid.
+            return IsMineResult::INVALID;
+        }
+        if (sigversion == IsMineSigVersion::TOP && !keystore.HaveCScript(CScriptID(CScript() << OP_0 << vSolutions[0]))) {
+            break;
+        }
+        uint160 hash;
+        CRIPEMD160().Write(&vSolutions[0][0], vSolutions[0].size()).Finalize(hash.begin());
+        CScriptID scriptID = CScriptID(hash);
+        CScript subscript;
+        if (keystore.GetCScript(scriptID, subscript)) {
+            ret = std::max(ret, IsMineInner(keystore, subscript, IsMineSigVersion::WITNESS_V0));
+        }
+        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 (!PermitsUncompressed(sigversion)) {
+            for (size_t i = 0; i < keys.size(); i++) {
+                if (keys[i].size() != 33) {
+                    return IsMineResult::INVALID;
+                }
+            }
+        }
+        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 CWallet& keystore, const CScript& scriptPubKey)
+{
+    switch (IsMineInner(keystore, scriptPubKey, IsMineSigVersion::TOP)) {
+    case IsMineResult::INVALID:
+    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 CWallet& keystore, const CTxDestination& dest)
+{
+    CScript script = GetScriptForDestination(dest);
+    return IsMine(keystore, script);
+}
diff --git a/src/wallet/ismine.h b/src/wallet/ismine.h
new file mode 100644
index 0000000000..41555fcb93
--- /dev/null
+++ b/src/wallet/ismine.h
@@ -0,0 +1,53 @@
+// 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.
+
+#ifndef BITCOIN_WALLET_ISMINE_H
+#define BITCOIN_WALLET_ISMINE_H
+
+#include <script/standard.h>
+
+#include <stdint.h>
+#include <bitset>
+
+class CWallet;
+class CScript;
+
+/** IsMine() return codes */
+enum isminetype : unsigned int
+{
+    ISMINE_NO         = 0,
+    ISMINE_WATCH_ONLY = 1 << 0,
+    ISMINE_SPENDABLE  = 1 << 1,
+    ISMINE_USED       = 1 << 2,
+    ISMINE_ALL        = ISMINE_WATCH_ONLY | ISMINE_SPENDABLE,
+    ISMINE_ALL_USED   = ISMINE_ALL | ISMINE_USED,
+    ISMINE_ENUM_ELEMENTS,
+};
+/** used for bitflags of isminetype */
+typedef uint8_t isminefilter;
+
+isminetype IsMine(const CWallet& wallet, const CScript& scriptPubKey);
+isminetype IsMine(const CWallet& wallet, 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;
+    CAmount m_value[ISMINE_ENUM_ELEMENTS];
+    inline void Reset()
+    {
+        m_cached.reset();
+    }
+    void Set(isminefilter filter, CAmount value)
+    {
+        m_cached.set(filter);
+        m_value[filter] = value;
+    }
+};
+
+#endif // BITCOIN_WALLET_ISMINE_H
diff --git a/src/wallet/test/ismine_tests.cpp b/src/wallet/test/ismine_tests.cpp
new file mode 100644
index 0000000000..0cae055676
--- /dev/null
+++ b/src/wallet/test/ismine_tests.cpp
@@ -0,0 +1,399 @@
+// 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 <script/script.h>
+#include <script/script_error.h>
+#include <script/standard.h>
+#include <test/setup_common.h>
+#include <wallet/ismine.h>
+#include <wallet/wallet.h>
+
+#include <boost/test/unit_test.hpp>
+
+
+BOOST_FIXTURE_TEST_SUITE(ismine_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(ismine_standard)
+{
+    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();
+    std::unique_ptr<interfaces::Chain> chain = interfaces::MakeChain();
+
+    CScript scriptPubKey;
+    isminetype result;
+
+    // P2PK compressed
+    {
+        CWallet keystore(chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
+        scriptPubKey = GetScriptForRawPubKey(pubkeys[0]);
+
+        // Keystore does not have key
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+
+        // Keystore has key
+        BOOST_CHECK(keystore.AddKey(keys[0]));
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
+    }
+
+    // P2PK uncompressed
+    {
+        CWallet keystore(chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
+        scriptPubKey = GetScriptForRawPubKey(uncompressedPubkey);
+
+        // Keystore does not have key
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+
+        // Keystore has key
+        BOOST_CHECK(keystore.AddKey(uncompressedKey));
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
+    }
+
+    // P2PKH compressed
+    {
+        CWallet keystore(chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
+        scriptPubKey = GetScriptForDestination(PKHash(pubkeys[0]));
+
+        // Keystore does not have key
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+
+        // Keystore has key
+        BOOST_CHECK(keystore.AddKey(keys[0]));
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
+    }
+
+    // P2PKH uncompressed
+    {
+        CWallet keystore(chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
+        scriptPubKey = GetScriptForDestination(PKHash(uncompressedPubkey));
+
+        // Keystore does not have key
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+
+        // Keystore has key
+        BOOST_CHECK(keystore.AddKey(uncompressedKey));
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
+    }
+
+    // P2SH
+    {
+        CWallet keystore(chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
+
+        CScript redeemScript = GetScriptForDestination(PKHash(pubkeys[0]));
+        scriptPubKey = GetScriptForDestination(ScriptHash(redeemScript));
+
+        // Keystore does not have redeemScript or key
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+
+        // Keystore has redeemScript but no key
+        BOOST_CHECK(keystore.AddCScript(redeemScript));
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+
+        // Keystore has redeemScript and key
+        BOOST_CHECK(keystore.AddKey(keys[0]));
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
+    }
+
+    // (P2PKH inside) P2SH inside P2SH (invalid)
+    {
+        CWallet keystore(chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
+
+        CScript redeemscript_inner = GetScriptForDestination(PKHash(pubkeys[0]));
+        CScript redeemscript = GetScriptForDestination(ScriptHash(redeemscript_inner));
+        scriptPubKey = GetScriptForDestination(ScriptHash(redeemscript));
+
+        BOOST_CHECK(keystore.AddCScript(redeemscript));
+        BOOST_CHECK(keystore.AddCScript(redeemscript_inner));
+        BOOST_CHECK(keystore.AddCScript(scriptPubKey));
+        BOOST_CHECK(keystore.AddKey(keys[0]));
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+    }
+
+    // (P2PKH inside) P2SH inside P2WSH (invalid)
+    {
+        CWallet keystore(chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
+
+        CScript redeemscript = GetScriptForDestination(PKHash(pubkeys[0]));
+        CScript witnessscript = GetScriptForDestination(ScriptHash(redeemscript));
+        scriptPubKey = GetScriptForDestination(WitnessV0ScriptHash(witnessscript));
+
+        BOOST_CHECK(keystore.AddCScript(witnessscript));
+        BOOST_CHECK(keystore.AddCScript(redeemscript));
+        BOOST_CHECK(keystore.AddCScript(scriptPubKey));
+        BOOST_CHECK(keystore.AddKey(keys[0]));
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+    }
+
+    // P2WPKH inside P2WSH (invalid)
+    {
+        CWallet keystore(chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
+
+        CScript witnessscript = GetScriptForDestination(WitnessV0KeyHash(PKHash(pubkeys[0])));
+        scriptPubKey = GetScriptForDestination(WitnessV0ScriptHash(witnessscript));
+
+        BOOST_CHECK(keystore.AddCScript(witnessscript));
+        BOOST_CHECK(keystore.AddCScript(scriptPubKey));
+        BOOST_CHECK(keystore.AddKey(keys[0]));
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+    }
+
+    // (P2PKH inside) P2WSH inside P2WSH (invalid)
+    {
+        CWallet keystore(chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
+
+        CScript witnessscript_inner = GetScriptForDestination(PKHash(pubkeys[0]));
+        CScript witnessscript = GetScriptForDestination(WitnessV0ScriptHash(witnessscript_inner));
+        scriptPubKey = GetScriptForDestination(WitnessV0ScriptHash(witnessscript));
+
+        BOOST_CHECK(keystore.AddCScript(witnessscript_inner));
+        BOOST_CHECK(keystore.AddCScript(witnessscript));
+        BOOST_CHECK(keystore.AddCScript(scriptPubKey));
+        BOOST_CHECK(keystore.AddKey(keys[0]));
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+    }
+
+    // P2WPKH compressed
+    {
+        CWallet keystore(chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
+        BOOST_CHECK(keystore.AddKey(keys[0]));
+
+        scriptPubKey = GetScriptForDestination(WitnessV0KeyHash(PKHash(pubkeys[0])));
+
+        // Keystore implicitly has key and P2SH redeemScript
+        BOOST_CHECK(keystore.AddCScript(scriptPubKey));
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
+    }
+
+    // P2WPKH uncompressed
+    {
+        CWallet keystore(chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
+        BOOST_CHECK(keystore.AddKey(uncompressedKey));
+
+        scriptPubKey = GetScriptForDestination(WitnessV0KeyHash(PKHash(uncompressedPubkey)));
+
+        // Keystore has key, but no P2SH redeemScript
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+
+        // Keystore has key and P2SH redeemScript
+        BOOST_CHECK(keystore.AddCScript(scriptPubKey));
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+    }
+
+    // scriptPubKey multisig
+    {
+        CWallet keystore(chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
+
+        scriptPubKey = GetScriptForMultisig(2, {uncompressedPubkey, pubkeys[1]});
+
+        // Keystore does not have any keys
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+
+        // Keystore has 1/2 keys
+        BOOST_CHECK(keystore.AddKey(uncompressedKey));
+
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+
+        // Keystore has 2/2 keys
+        BOOST_CHECK(keystore.AddKey(keys[1]));
+
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+
+        // Keystore has 2/2 keys and the script
+        BOOST_CHECK(keystore.AddCScript(scriptPubKey));
+
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+    }
+
+    // P2SH multisig
+    {
+        CWallet keystore(chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
+        BOOST_CHECK(keystore.AddKey(uncompressedKey));
+        BOOST_CHECK(keystore.AddKey(keys[1]));
+
+        CScript redeemScript = GetScriptForMultisig(2, {uncompressedPubkey, pubkeys[1]});
+        scriptPubKey = GetScriptForDestination(ScriptHash(redeemScript));
+
+        // Keystore has no redeemScript
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+
+        // Keystore has redeemScript
+        BOOST_CHECK(keystore.AddCScript(redeemScript));
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
+    }
+
+    // P2WSH multisig with compressed keys
+    {
+        CWallet keystore(chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
+        BOOST_CHECK(keystore.AddKey(keys[0]));
+        BOOST_CHECK(keystore.AddKey(keys[1]));
+
+        CScript witnessScript = GetScriptForMultisig(2, {pubkeys[0], pubkeys[1]});
+        scriptPubKey = GetScriptForDestination(WitnessV0ScriptHash(witnessScript));
+
+        // Keystore has keys, but no witnessScript or P2SH redeemScript
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+
+        // Keystore has keys and witnessScript, but no P2SH redeemScript
+        BOOST_CHECK(keystore.AddCScript(witnessScript));
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+
+        // Keystore has keys, witnessScript, P2SH redeemScript
+        BOOST_CHECK(keystore.AddCScript(scriptPubKey));
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
+    }
+
+    // P2WSH multisig with uncompressed key
+    {
+        CWallet keystore(chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
+        BOOST_CHECK(keystore.AddKey(uncompressedKey));
+        BOOST_CHECK(keystore.AddKey(keys[1]));
+
+        CScript witnessScript = GetScriptForMultisig(2, {uncompressedPubkey, pubkeys[1]});
+        scriptPubKey = GetScriptForDestination(WitnessV0ScriptHash(witnessScript));
+
+        // Keystore has keys, but no witnessScript or P2SH redeemScript
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+
+        // Keystore has keys and witnessScript, but no P2SH redeemScript
+        BOOST_CHECK(keystore.AddCScript(witnessScript));
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+
+        // Keystore has keys, witnessScript, P2SH redeemScript
+        BOOST_CHECK(keystore.AddCScript(scriptPubKey));
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+    }
+
+    // P2WSH multisig wrapped in P2SH
+    {
+        CWallet keystore(chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
+
+        CScript witnessScript = GetScriptForMultisig(2, {pubkeys[0], pubkeys[1]});
+        CScript redeemScript = GetScriptForDestination(WitnessV0ScriptHash(witnessScript));
+        scriptPubKey = GetScriptForDestination(ScriptHash(redeemScript));
+
+        // Keystore has no witnessScript, P2SH redeemScript, or keys
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+
+        // Keystore has witnessScript and P2SH redeemScript, but no keys
+        BOOST_CHECK(keystore.AddCScript(redeemScript));
+        BOOST_CHECK(keystore.AddCScript(witnessScript));
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+
+        // Keystore has keys, witnessScript, P2SH redeemScript
+        BOOST_CHECK(keystore.AddKey(keys[0]));
+        BOOST_CHECK(keystore.AddKey(keys[1]));
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
+    }
+
+    // OP_RETURN
+    {
+        CWallet keystore(chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
+        BOOST_CHECK(keystore.AddKey(keys[0]));
+
+        scriptPubKey.clear();
+        scriptPubKey << OP_RETURN << ToByteVector(pubkeys[0]);
+
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+    }
+
+    // witness unspendable
+    {
+        CWallet keystore(chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
+        BOOST_CHECK(keystore.AddKey(keys[0]));
+
+        scriptPubKey.clear();
+        scriptPubKey << OP_0 << ToByteVector(ParseHex("aabb"));
+
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+    }
+
+    // witness unknown
+    {
+        CWallet keystore(chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
+        BOOST_CHECK(keystore.AddKey(keys[0]));
+
+        scriptPubKey.clear();
+        scriptPubKey << OP_16 << ToByteVector(ParseHex("aabb"));
+
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+    }
+
+    // Nonstandard
+    {
+        CWallet keystore(chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
+        LOCK(keystore.cs_wallet);
+        BOOST_CHECK(keystore.AddKey(keys[0]));
+
+        scriptPubKey.clear();
+        scriptPubKey << OP_9 << OP_ADD << OP_11 << OP_EQUAL;
+
+        result = IsMine(keystore, scriptPubKey);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index c2d1102c33..7b5465c219 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -11,7 +11,6 @@
 #include <interfaces/handler.h>
 #include <outputtype.h>
 #include <policy/feerate.h>
-#include <script/ismine.h>
 #include <script/sign.h>
 #include <streams.h>
 #include <tinyformat.h>
@@ -21,6 +20,7 @@
 #include <validationinterface.h>
 #include <wallet/coinselection.h>
 #include <wallet/crypter.h>
+#include <wallet/ismine.h>
 #include <wallet/walletdb.h>
 #include <wallet/walletutil.h>
 
diff --git a/src/wallet/wallettool.h b/src/wallet/wallettool.h
index da848a747b..7ee2505631 100644
--- a/src/wallet/wallettool.h
+++ b/src/wallet/wallettool.h
@@ -5,7 +5,7 @@
 #ifndef BITCOIN_WALLET_WALLETTOOL_H
 #define BITCOIN_WALLET_WALLETTOOL_H
 
-#include <script/ismine.h>
+#include <wallet/ismine.h>
 #include <wallet/wallet.h>
 
 namespace WalletTool {