diff --git a/src/keystore.cpp b/src/keystore.cpp
index 9f71eb18d..afa830242 100644
--- a/src/keystore.cpp
+++ b/src/keystore.cpp
@@ -1,171 +1,178 @@
 // 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 <keystore.h>
 
 #include <key.h>
 #include <pubkey.h>
 #include <util/system.h>
 
 void CBasicKeyStore::ImplicitlyLearnRelatedKeyScripts(const CPubKey &pubkey) {
     AssertLockHeld(cs_KeyStore);
     CKeyID key_id = pubkey.GetID();
     // We must actually know about this key already.
     assert(HaveKey(key_id) || mapWatchKeys.count(key_id));
     // This adds the redeemscripts necessary to detect alternative outputs using
     // the same keys. Also note that having superfluous scripts in the keystore
     // never hurts. They're only used to guide recursion in signing and IsMine
     // logic - if a script is present but we can't do anything with it, it has
     // no effect. "Implicitly" refers to fact that scripts are derived
     // automatically from existing keys, and are present in memory, even without
     // being explicitly loaded (e.g. from a file).
 
     // Right now there are none so do nothing.
 }
 
 bool CBasicKeyStore::GetPubKey(const CKeyID &address,
                                CPubKey &vchPubKeyOut) const {
     CKey key;
     if (!GetKey(address, key)) {
         LOCK(cs_KeyStore);
         WatchKeyMap::const_iterator it = mapWatchKeys.find(address);
         if (it != mapWatchKeys.end()) {
             vchPubKeyOut = it->second;
             return true;
         }
         return false;
     }
     vchPubKeyOut = key.GetPubKey();
     return true;
 }
 
 bool CBasicKeyStore::AddKeyPubKey(const CKey &key, const CPubKey &pubkey) {
     LOCK(cs_KeyStore);
     mapKeys[pubkey.GetID()] = key;
     ImplicitlyLearnRelatedKeyScripts(pubkey);
     return true;
 }
 
 bool CBasicKeyStore::HaveKey(const CKeyID &address) const {
     LOCK(cs_KeyStore);
     return mapKeys.count(address) > 0;
 }
 
 std::set<CKeyID> CBasicKeyStore::GetKeys() const {
     LOCK(cs_KeyStore);
     std::set<CKeyID> set_address;
     for (const auto &mi : mapKeys) {
         set_address.insert(mi.first);
     }
     return set_address;
 }
 
 bool CBasicKeyStore::GetKey(const CKeyID &address, CKey &keyOut) const {
     LOCK(cs_KeyStore);
     KeyMap::const_iterator mi = mapKeys.find(address);
     if (mi != mapKeys.end()) {
         keyOut = mi->second;
         return true;
     }
     return false;
 }
 
 bool CBasicKeyStore::AddCScript(const CScript &redeemScript) {
     if (redeemScript.size() > MAX_SCRIPT_ELEMENT_SIZE) {
         return error("CBasicKeyStore::AddCScript(): redeemScripts > %i bytes "
                      "are invalid",
                      MAX_SCRIPT_ELEMENT_SIZE);
     }
 
     LOCK(cs_KeyStore);
     mapScripts[CScriptID(redeemScript)] = redeemScript;
     return true;
 }
 
 bool CBasicKeyStore::HaveCScript(const CScriptID &hash) const {
     LOCK(cs_KeyStore);
     return mapScripts.count(hash) > 0;
 }
 
 std::set<CScriptID> CBasicKeyStore::GetCScripts() const {
     LOCK(cs_KeyStore);
     std::set<CScriptID> set_script;
     for (const auto &mi : mapScripts) {
         set_script.insert(mi.first);
     }
     return set_script;
 }
 
 bool CBasicKeyStore::GetCScript(const CScriptID &hash,
                                 CScript &redeemScriptOut) const {
     LOCK(cs_KeyStore);
     ScriptMap::const_iterator mi = mapScripts.find(hash);
     if (mi != mapScripts.end()) {
         redeemScriptOut = (*mi).second;
         return true;
     }
     return false;
 }
 
 static bool ExtractPubKey(const CScript &dest, CPubKey &pubKeyOut) {
     // TODO: Use Solver to extract this?
     CScript::const_iterator pc = dest.begin();
     opcodetype opcode;
     std::vector<uint8_t> vch;
     if (!dest.GetOp(pc, opcode, vch) || !CPubKey::ValidSize(vch)) {
         return false;
     }
     pubKeyOut = CPubKey(vch);
     if (!pubKeyOut.IsFullyValid()) {
         return false;
     }
     if (!dest.GetOp(pc, opcode, vch) || opcode != OP_CHECKSIG ||
         dest.GetOp(pc, opcode, vch)) {
         return false;
     }
     return true;
 }
 
 bool CBasicKeyStore::AddWatchOnly(const CScript &dest) {
     LOCK(cs_KeyStore);
     setWatchOnly.insert(dest);
     CPubKey pubKey;
     if (ExtractPubKey(dest, pubKey)) {
         mapWatchKeys[pubKey.GetID()] = pubKey;
         ImplicitlyLearnRelatedKeyScripts(pubKey);
     }
     return true;
 }
 
 bool CBasicKeyStore::RemoveWatchOnly(const CScript &dest) {
     LOCK(cs_KeyStore);
     setWatchOnly.erase(dest);
     CPubKey pubKey;
     if (ExtractPubKey(dest, pubKey)) {
         mapWatchKeys.erase(pubKey.GetID());
     }
     // Related CScripts are not removed; having superfluous scripts around is
     // harmless (see comment in ImplicitlyLearnRelatedKeyScripts).
     return true;
 }
 
 bool CBasicKeyStore::HaveWatchOnly(const CScript &dest) const {
     LOCK(cs_KeyStore);
     return setWatchOnly.count(dest) > 0;
 }
 
 bool CBasicKeyStore::HaveWatchOnly() const {
     LOCK(cs_KeyStore);
     return (!setWatchOnly.empty());
 }
 
 CKeyID GetKeyForDestination(const CKeyStore &store,
                             const CTxDestination &dest) {
     // Only supports destinations which map to single public keys, i.e. P2PKH.
     if (auto id = boost::get<CKeyID>(&dest)) {
         return *id;
     }
     return CKeyID();
 }
+
+bool HaveKey(const CKeyStore &store, const CKey &key) {
+    CKey key2;
+    key2.Set(key.begin(), key.end(), !key.IsCompressed());
+    return store.HaveKey(key.GetPubKey().GetID()) ||
+           store.HaveKey(key2.GetPubKey().GetID());
+}
diff --git a/src/keystore.h b/src/keystore.h
index 4291e3ec4..013b02f78 100644
--- a/src/keystore.h
+++ b/src/keystore.h
@@ -1,91 +1,96 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2015 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_KEYSTORE_H
 #define BITCOIN_KEYSTORE_H
 
 #include <key.h>
 #include <pubkey.h>
 #include <script/script.h>
 #include <script/sign.h>
 #include <script/standard.h>
 #include <sync.h>
 
 #include <boost/signals2/signal.hpp>
 
 /** A virtual base class for key stores */
 class CKeyStore : public SigningProvider {
 protected:
     mutable CCriticalSection cs_KeyStore;
 
 public:
     //! Add a key to the store.
     virtual bool AddKeyPubKey(const CKey &key, const CPubKey &pubkey) = 0;
 
     //! Check whether a key corresponding to a given address is present in the
     //! store.
     virtual bool HaveKey(const CKeyID &address) const = 0;
     virtual std::set<CKeyID> GetKeys() const = 0;
 
     //! Support for BIP 0013 : see
     //! https://github.com/bitcoin/bips/blob/master/bip-0013.mediawiki
     virtual bool AddCScript(const CScript &redeemScript) = 0;
     virtual bool HaveCScript(const CScriptID &hash) const = 0;
     virtual std::set<CScriptID> GetCScripts() const = 0;
 
     //! Support for Watch-only addresses
     virtual bool AddWatchOnly(const CScript &dest) = 0;
     virtual bool RemoveWatchOnly(const CScript &dest) = 0;
     virtual bool HaveWatchOnly(const CScript &dest) const = 0;
     virtual bool HaveWatchOnly() const = 0;
 };
 
 typedef std::map<CKeyID, CKey> KeyMap;
 typedef std::map<CKeyID, CPubKey> WatchKeyMap;
 typedef std::map<CScriptID, CScript> ScriptMap;
 typedef std::set<CScript> WatchOnlySet;
 
 /** Basic key store, that keeps keys in an address->secret map */
 class CBasicKeyStore : public CKeyStore {
 protected:
     mutable CCriticalSection cs_KeyStore;
 
     KeyMap mapKeys;
     WatchKeyMap mapWatchKeys;
     ScriptMap mapScripts;
     WatchOnlySet setWatchOnly;
 
     void ImplicitlyLearnRelatedKeyScripts(const CPubKey &pubkey)
         EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore);
 
 public:
     bool AddKeyPubKey(const CKey &key, const CPubKey &pubkey) override;
     bool AddKey(const CKey &key) { return AddKeyPubKey(key, key.GetPubKey()); }
     bool GetPubKey(const CKeyID &address, CPubKey &vchPubKeyOut) const override;
     bool HaveKey(const CKeyID &address) const override;
     std::set<CKeyID> GetKeys() const override;
     bool GetKey(const CKeyID &address, CKey &keyOut) const override;
     bool AddCScript(const CScript &redeemScript) override;
     bool HaveCScript(const CScriptID &hash) const override;
     std::set<CScriptID> GetCScripts() const override;
     bool GetCScript(const CScriptID &hash,
                     CScript &redeemScriptOut) const override;
 
     bool AddWatchOnly(const CScript &dest) override;
     bool RemoveWatchOnly(const CScript &dest) override;
     bool HaveWatchOnly(const CScript &dest) const override;
     bool HaveWatchOnly() const override;
 };
 
 typedef std::vector<uint8_t, secure_allocator<uint8_t>> CKeyingMaterial;
 typedef std::map<CKeyID, std::pair<CPubKey, std::vector<uint8_t>>>
     CryptedKeyMap;
 
 /**
  * Return the CKeyID of the key involved in a script (if there is a unique one).
  */
 CKeyID GetKeyForDestination(const CKeyStore &store, const CTxDestination &dest);
 
+/**
+ * Checks if a CKey is in the given CKeyStore compressed or otherwise
+ */
+bool HaveKey(const CKeyStore &store, const CKey &key);
+
 #endif // BITCOIN_KEYSTORE_H