diff --git a/src/keystore.h b/src/keystore.h
index 6e698650f..51365069c 100644
--- a/src/keystore.h
+++ b/src/keystore.h
@@ -1,93 +1,90 @@
 // 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:
-    virtual ~CKeyStore() {}
+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 bool GetKey(const CKeyID &address, CKey &keyOut) const = 0;
     virtual std::set<CKeyID> GetKeys() const = 0;
-    virtual bool GetPubKey(const CKeyID &address,
-                           CPubKey &vchPubKeyOut) 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;
-    virtual bool GetCScript(const CScriptID &hash,
-                            CScript &redeemScriptOut) 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);
 
 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);
 
 #endif // BITCOIN_KEYSTORE_H
diff --git a/src/script/sign.cpp b/src/script/sign.cpp
index 781b7e5c0..e6064b21d 100644
--- a/src/script/sign.cpp
+++ b/src/script/sign.cpp
@@ -1,391 +1,387 @@
 // 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/sign.h>
 
 #include <key.h>
-#include <keystore.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <script/standard.h>
 #include <uint256.h>
 
 typedef std::vector<uint8_t> valtype;
 
 TransactionSignatureCreator::TransactionSignatureCreator(
-    const CKeyStore *keystoreIn, const CTransaction *txToIn, unsigned int nInIn,
-    const Amount amountIn, SigHashType sigHashTypeIn)
-    : BaseSignatureCreator(keystoreIn), txTo(txToIn), nIn(nInIn),
+    const SigningProvider *provider, const CTransaction *txToIn,
+    unsigned int nInIn, const Amount amountIn, SigHashType sigHashTypeIn)
+    : BaseSignatureCreator(provider), txTo(txToIn), nIn(nInIn),
       amount(amountIn), sigHashType(sigHashTypeIn),
       checker(txTo, nIn, amountIn) {}
 
 bool TransactionSignatureCreator::CreateSig(std::vector<uint8_t> &vchSig,
                                             const CKeyID &address,
                                             const CScript &scriptCode) const {
     CKey key;
-    if (!keystore->GetKey(address, key)) {
+    if (!m_provider->GetKey(address, key)) {
         return false;
     }
 
     uint256 hash = SignatureHash(scriptCode, *txTo, nIn, sigHashType, amount);
     if (!key.SignECDSA(hash, vchSig)) {
         return false;
     }
 
     vchSig.push_back(uint8_t(sigHashType.getRawSigHashType()));
     return true;
 }
 
 static bool Sign1(const CKeyID &address, const BaseSignatureCreator &creator,
                   const CScript &scriptCode, std::vector<valtype> &ret) {
     std::vector<uint8_t> vchSig;
     if (!creator.CreateSig(vchSig, address, scriptCode)) {
         return false;
     }
 
     ret.push_back(vchSig);
     return true;
 }
 
 static bool SignN(const std::vector<valtype> &multisigdata,
                   const BaseSignatureCreator &creator,
                   const CScript &scriptCode, std::vector<valtype> &ret) {
     int nSigned = 0;
     int nRequired = multisigdata.front()[0];
     for (size_t i = 1; i < multisigdata.size() - 1 && nSigned < nRequired;
          i++) {
         const valtype &pubkey = multisigdata[i];
         CKeyID keyID = CPubKey(pubkey).GetID();
         if (Sign1(keyID, creator, scriptCode, ret)) {
             ++nSigned;
         }
     }
 
     return nSigned == nRequired;
 }
 
 /**
  * Sign scriptPubKey using signature made with creator.
  * Signatures are returned in scriptSigRet (or returns false if scriptPubKey
  * can't be signed), unless whichTypeRet is TX_SCRIPTHASH, in which case
  * scriptSigRet is the redemption script.
  * Returns false if scriptPubKey could not be completely satisfied.
  */
 static bool SignStep(const BaseSignatureCreator &creator,
                      const CScript &scriptPubKey, std::vector<valtype> &ret,
                      txnouttype &whichTypeRet) {
     CScript scriptRet;
     uint160 h160;
     ret.clear();
 
     std::vector<valtype> vSolutions;
     if (!Solver(scriptPubKey, whichTypeRet, vSolutions)) {
         return false;
     }
 
     CKeyID keyID;
     switch (whichTypeRet) {
         case TX_NONSTANDARD:
         case TX_NULL_DATA:
             return false;
         case TX_PUBKEY:
             keyID = CPubKey(vSolutions[0]).GetID();
             return Sign1(keyID, creator, scriptPubKey, ret);
         case TX_PUBKEYHASH: {
             keyID = CKeyID(uint160(vSolutions[0]));
             if (!Sign1(keyID, creator, scriptPubKey, ret)) {
                 return false;
             }
 
             CPubKey vch;
-            creator.KeyStore().GetPubKey(keyID, vch);
+            creator.Provider().GetPubKey(keyID, vch);
             ret.push_back(ToByteVector(vch));
             return true;
         }
         case TX_SCRIPTHASH:
-            if (creator.KeyStore().GetCScript(uint160(vSolutions[0]),
+            if (creator.Provider().GetCScript(uint160(vSolutions[0]),
                                               scriptRet)) {
                 ret.push_back(
                     std::vector<uint8_t>(scriptRet.begin(), scriptRet.end()));
                 return true;
             }
-
             return false;
-
         case TX_MULTISIG:
             // workaround CHECKMULTISIG bug
             ret.push_back(valtype());
             return (SignN(vSolutions, creator, scriptPubKey, ret));
-
         default:
             return false;
     }
 }
 
 static CScript PushAll(const std::vector<valtype> &values) {
     CScript result;
     for (const valtype &v : values) {
         if (v.size() == 0) {
             result << OP_0;
         } else if (v.size() == 1 && v[0] >= 1 && v[0] <= 16) {
             result << CScript::EncodeOP_N(v[0]);
         } else {
             result << v;
         }
     }
 
     return result;
 }
 
 bool ProduceSignature(const BaseSignatureCreator &creator,
                       const CScript &fromPubKey, SignatureData &sigdata) {
     std::vector<valtype> result;
     txnouttype whichType;
     bool solved = SignStep(creator, fromPubKey, result, whichType);
     CScript subscript;
 
     if (solved && whichType == TX_SCRIPTHASH) {
         // Solver returns the subscript that needs to be evaluated; the final
         // scriptSig is the signatures from that and then the serialized
         // subscript:
         subscript = CScript(result[0].begin(), result[0].end());
         solved = solved && SignStep(creator, subscript, result, whichType) &&
                  whichType != TX_SCRIPTHASH;
         result.push_back(
             std::vector<uint8_t>(subscript.begin(), subscript.end()));
     }
 
     sigdata.scriptSig = PushAll(result);
 
     // Test solution
     return solved &&
            VerifyScript(sigdata.scriptSig, fromPubKey,
                         STANDARD_SCRIPT_VERIFY_FLAGS, creator.Checker());
 }
 
 SignatureData DataFromTransaction(const CMutableTransaction &tx,
                                   unsigned int nIn) {
     SignatureData data;
     assert(tx.vin.size() > nIn);
     data.scriptSig = tx.vin[nIn].scriptSig;
     return data;
 }
 
 void UpdateInput(CTxIn &input, const SignatureData &data) {
     input.scriptSig = data.scriptSig;
 }
 
 void UpdateTransaction(CMutableTransaction &tx, unsigned int nIn,
                        const SignatureData &data) {
     assert(tx.vin.size() > nIn);
     UpdateInput(tx.vin[nIn], data);
 }
 
-bool SignSignature(const CKeyStore &keystore, const CScript &fromPubKey,
+bool SignSignature(const SigningProvider &provider, const CScript &fromPubKey,
                    CMutableTransaction &txTo, unsigned int nIn,
                    const Amount amount, SigHashType sigHashType) {
     assert(nIn < txTo.vin.size());
 
     CTransaction txToConst(txTo);
-    TransactionSignatureCreator creator(&keystore, &txToConst, nIn, amount,
+    TransactionSignatureCreator creator(&provider, &txToConst, nIn, amount,
                                         sigHashType);
 
     SignatureData sigdata;
     bool ret = ProduceSignature(creator, fromPubKey, sigdata);
     UpdateTransaction(txTo, nIn, sigdata);
     return ret;
 }
 
-bool SignSignature(const CKeyStore &keystore, const CTransaction &txFrom,
+bool SignSignature(const SigningProvider &provider, const CTransaction &txFrom,
                    CMutableTransaction &txTo, unsigned int nIn,
                    SigHashType sigHashType) {
     assert(nIn < txTo.vin.size());
     CTxIn &txin = txTo.vin[nIn];
     assert(txin.prevout.GetN() < txFrom.vout.size());
     const CTxOut &txout = txFrom.vout[txin.prevout.GetN()];
 
-    return SignSignature(keystore, txout.scriptPubKey, txTo, nIn, txout.nValue,
+    return SignSignature(provider, txout.scriptPubKey, txTo, nIn, txout.nValue,
                          sigHashType);
 }
 
 static std::vector<valtype> CombineMultisig(
     const CScript &scriptPubKey, const BaseSignatureChecker &checker,
     const std::vector<valtype> &vSolutions, const std::vector<valtype> &sigs1,
     const std::vector<valtype> &sigs2) {
     // Combine all the signatures we've got:
     std::set<valtype> allsigs;
     for (const valtype &v : sigs1) {
         if (!v.empty()) {
             allsigs.insert(v);
         }
     }
 
     for (const valtype &v : sigs2) {
         if (!v.empty()) {
             allsigs.insert(v);
         }
     }
 
     // Build a map of pubkey -> signature by matching sigs to pubkeys:
     assert(vSolutions.size() > 1);
     unsigned int nSigsRequired = vSolutions.front()[0];
     unsigned int nPubKeys = vSolutions.size() - 2;
     std::map<valtype, valtype> sigs;
     for (const valtype &sig : allsigs) {
         for (unsigned int i = 0; i < nPubKeys; i++) {
             const valtype &pubkey = vSolutions[i + 1];
             // Already got a sig for this pubkey
             if (sigs.count(pubkey)) {
                 continue;
             }
 
             if (checker.CheckSig(sig, pubkey, scriptPubKey,
                                  STANDARD_SCRIPT_VERIFY_FLAGS)) {
                 sigs[pubkey] = sig;
                 break;
             }
         }
     }
     // Now build a merged CScript:
     unsigned int nSigsHave = 0;
     // pop-one-too-many workaround
     std::vector<valtype> result;
     result.push_back(valtype());
     for (unsigned int i = 0; i < nPubKeys && nSigsHave < nSigsRequired; i++) {
         if (sigs.count(vSolutions[i + 1])) {
             result.push_back(sigs[vSolutions[i + 1]]);
             ++nSigsHave;
         }
     }
 
     // Fill any missing with OP_0:
     for (unsigned int i = nSigsHave; i < nSigsRequired; i++) {
         result.push_back(valtype());
     }
 
     return result;
 }
 
 namespace {
 struct Stacks {
     std::vector<valtype> script;
 
     Stacks() {}
     explicit Stacks(const std::vector<valtype> &scriptSigStack_)
         : script(scriptSigStack_) {}
     explicit Stacks(const SignatureData &data) {
         EvalScript(script, data.scriptSig, MANDATORY_SCRIPT_VERIFY_FLAGS,
                    BaseSignatureChecker());
     }
 
     SignatureData Output() const {
         SignatureData result;
         result.scriptSig = PushAll(script);
         return result;
     }
 };
 } // namespace
 
 static Stacks CombineSignatures(const CScript &scriptPubKey,
                                 const BaseSignatureChecker &checker,
                                 const txnouttype txType,
                                 const std::vector<valtype> &vSolutions,
                                 Stacks sigs1, Stacks sigs2) {
     switch (txType) {
         case TX_NONSTANDARD:
         case TX_NULL_DATA:
             // Don't know anything about this, assume bigger one is correct:
             if (sigs1.script.size() >= sigs2.script.size()) {
                 return sigs1;
             }
 
             return sigs2;
         case TX_PUBKEY:
         case TX_PUBKEYHASH:
             // Signatures are bigger than placeholders or empty scripts:
             if (sigs1.script.empty() || sigs1.script[0].empty()) {
                 return sigs2;
             }
 
             return sigs1;
         case TX_SCRIPTHASH: {
             if (sigs1.script.empty() || sigs1.script.back().empty()) {
                 return sigs2;
             }
 
             if (sigs2.script.empty() || sigs2.script.back().empty()) {
                 return sigs1;
             }
 
             // Recur to combine:
             valtype spk = sigs1.script.back();
             CScript pubKey2(spk.begin(), spk.end());
 
             txnouttype txType2;
             std::vector<std::vector<uint8_t>> vSolutions2;
             Solver(pubKey2, txType2, vSolutions2);
             sigs1.script.pop_back();
             sigs2.script.pop_back();
             Stacks result = CombineSignatures(pubKey2, checker, txType2,
                                               vSolutions2, sigs1, sigs2);
             result.script.push_back(spk);
             return result;
         }
         case TX_MULTISIG:
             return Stacks(CombineMultisig(scriptPubKey, checker, vSolutions,
                                           sigs1.script, sigs2.script));
         default:
             return Stacks();
     }
 }
 
 SignatureData CombineSignatures(const CScript &scriptPubKey,
                                 const BaseSignatureChecker &checker,
                                 const SignatureData &scriptSig1,
                                 const SignatureData &scriptSig2) {
     txnouttype txType;
     std::vector<std::vector<uint8_t>> vSolutions;
     Solver(scriptPubKey, txType, vSolutions);
 
     return CombineSignatures(scriptPubKey, checker, txType, vSolutions,
                              Stacks(scriptSig1), Stacks(scriptSig2))
         .Output();
 }
 
 namespace {
 /** Dummy signature checker which accepts all signatures. */
 class DummySignatureChecker : public BaseSignatureChecker {
 public:
     DummySignatureChecker() {}
 
     bool CheckSig(const std::vector<uint8_t> &scriptSig,
                   const std::vector<uint8_t> &vchPubKey,
                   const CScript &scriptCode, uint32_t flags) const override {
         return true;
     }
 };
 const DummySignatureChecker dummyChecker;
 } // namespace
 
 const BaseSignatureChecker &DummySignatureCreator::Checker() const {
     return dummyChecker;
 }
 
 bool DummySignatureCreator::CreateSig(std::vector<uint8_t> &vchSig,
                                       const CKeyID &keyid,
                                       const CScript &scriptCode) const {
     // Create a dummy signature that is a valid DER-encoding
     vchSig.assign(72, '\000');
     vchSig[0] = 0x30;
     vchSig[1] = 69;
     vchSig[2] = 0x02;
     vchSig[3] = 33;
     vchSig[4] = 0x01;
     vchSig[4 + 33] = 0x02;
     vchSig[5 + 33] = 32;
     vchSig[6 + 33] = 0x01;
     vchSig[6 + 33 + 32] = SIGHASH_ALL | SIGHASH_FORKID;
     return true;
 }
diff --git a/src/script/sign.h b/src/script/sign.h
index 423e44c9f..1685d4b01 100644
--- a/src/script/sign.h
+++ b/src/script/sign.h
@@ -1,110 +1,121 @@
 // 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_SIGN_H
 #define BITCOIN_SCRIPT_SIGN_H
 
 #include <script/interpreter.h>
 #include <script/sighashtype.h>
 
+class CKey;
 class CKeyID;
-class CKeyStore;
 class CMutableTransaction;
 class CScript;
+class CScriptID;
 class CTransaction;
 
+/** An interface to be implemented by keystores that support signing. */
+class SigningProvider {
+public:
+    virtual ~SigningProvider() {}
+    virtual bool GetCScript(const CScriptID &scriptid,
+                            CScript &script) const = 0;
+    virtual bool GetPubKey(const CKeyID &address, CPubKey &pubkey) const = 0;
+    virtual bool GetKey(const CKeyID &address, CKey &key) const = 0;
+};
+
 /** Virtual base class for signature creators. */
 class BaseSignatureCreator {
 protected:
-    const CKeyStore *keystore;
+    const SigningProvider *m_provider;
 
 public:
-    explicit BaseSignatureCreator(const CKeyStore *keystoreIn)
-        : keystore(keystoreIn) {}
-    const CKeyStore &KeyStore() const { return *keystore; };
+    explicit BaseSignatureCreator(const SigningProvider *provider)
+        : m_provider(provider) {}
+    const SigningProvider &Provider() const { return *m_provider; }
     virtual ~BaseSignatureCreator() {}
     virtual const BaseSignatureChecker &Checker() const = 0;
 
     /** Create a singular (non-script) signature. */
     virtual bool CreateSig(std::vector<uint8_t> &vchSig, const CKeyID &keyid,
                            const CScript &scriptCode) const = 0;
 };
 
 /** A signature creator for transactions. */
 class TransactionSignatureCreator : public BaseSignatureCreator {
     const CTransaction *txTo;
     unsigned int nIn;
     Amount amount;
     SigHashType sigHashType;
     const TransactionSignatureChecker checker;
 
 public:
-    TransactionSignatureCreator(const CKeyStore *keystoreIn,
+    TransactionSignatureCreator(const SigningProvider *provider,
                                 const CTransaction *txToIn, unsigned int nInIn,
                                 const Amount amountIn,
                                 SigHashType sigHashTypeIn = SigHashType());
     const BaseSignatureChecker &Checker() const override { return checker; }
     bool CreateSig(std::vector<uint8_t> &vchSig, const CKeyID &keyid,
                    const CScript &scriptCode) const override;
 };
 
 class MutableTransactionSignatureCreator : public TransactionSignatureCreator {
     CTransaction tx;
 
 public:
-    MutableTransactionSignatureCreator(const CKeyStore *keystoreIn,
+    MutableTransactionSignatureCreator(const SigningProvider *provider,
                                        const CMutableTransaction *txToIn,
                                        unsigned int nInIn,
                                        const Amount amountIn,
                                        SigHashType sigHashTypeIn)
-        : TransactionSignatureCreator(keystoreIn, &tx, nInIn, amountIn,
+        : TransactionSignatureCreator(provider, &tx, nInIn, amountIn,
                                       sigHashTypeIn),
           tx(*txToIn) {}
 };
 
 /** A signature creator that just produces 72-byte empty signatures. */
 class DummySignatureCreator : public BaseSignatureCreator {
 public:
-    explicit DummySignatureCreator(const CKeyStore *keystoreIn)
-        : BaseSignatureCreator(keystoreIn) {}
+    explicit DummySignatureCreator(const SigningProvider *provider)
+        : BaseSignatureCreator(provider) {}
     const BaseSignatureChecker &Checker() const override;
     bool CreateSig(std::vector<uint8_t> &vchSig, const CKeyID &keyid,
                    const CScript &scriptCode) const override;
 };
 
 struct SignatureData {
     CScript scriptSig;
 
     SignatureData() {}
     explicit SignatureData(const CScript &script) : scriptSig(script) {}
 };
 
 /** Produce a script signature using a generic signature creator. */
 bool ProduceSignature(const BaseSignatureCreator &creator,
                       const CScript &scriptPubKey, SignatureData &sigdata);
 
 /** Produce a script signature for a transaction. */
-bool SignSignature(const CKeyStore &keystore, const CScript &fromPubKey,
+bool SignSignature(const SigningProvider &provider, const CScript &fromPubKey,
                    CMutableTransaction &txTo, unsigned int nIn,
                    const Amount amount, SigHashType sigHashType);
-bool SignSignature(const CKeyStore &keystore, const CTransaction &txFrom,
+bool SignSignature(const SigningProvider &provider, const CTransaction &txFrom,
                    CMutableTransaction &txTo, unsigned int nIn,
                    SigHashType sigHashType);
 
 /** Combine two script signatures using a generic signature checker,
  * intelligently, possibly with OP_0 placeholders. */
 SignatureData CombineSignatures(const CScript &scriptPubKey,
                                 const BaseSignatureChecker &checker,
                                 const SignatureData &scriptSig1,
                                 const SignatureData &scriptSig2);
 
 /** Extract signature data from a transaction, and insert it. */
 SignatureData DataFromTransaction(const CMutableTransaction &tx,
                                   unsigned int nIn);
 void UpdateTransaction(CMutableTransaction &tx, unsigned int nIn,
                        const SignatureData &data);
 void UpdateInput(CTxIn &input, const SignatureData &data);
 
 #endif // BITCOIN_SCRIPT_SIGN_H