diff --git a/src/keystore.h b/src/keystore.h
--- a/src/keystore.h
+++ b/src/keystore.h
@@ -9,34 +9,31 @@
 #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;
diff --git a/src/script/sign.h b/src/script/sign.h
--- a/src/script/sign.h
+++ b/src/script/sign.h
@@ -9,21 +9,32 @@
 #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;
 
@@ -41,7 +52,7 @@
     const TransactionSignatureChecker checker;
 
 public:
-    TransactionSignatureCreator(const CKeyStore *keystoreIn,
+    TransactionSignatureCreator(const SigningProvider *provider,
                                 const CTransaction *txToIn, unsigned int nInIn,
                                 const Amount amountIn,
                                 SigHashType sigHashTypeIn = SigHashType());
@@ -54,12 +65,12 @@
     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) {}
 };
@@ -67,8 +78,8 @@
 /** 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;
@@ -86,10 +97,10 @@
                       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);
 
diff --git a/src/script/sign.cpp b/src/script/sign.cpp
--- a/src/script/sign.cpp
+++ b/src/script/sign.cpp
@@ -6,7 +6,6 @@
 #include <script/sign.h>
 
 #include <key.h>
-#include <keystore.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <script/standard.h>
@@ -15,9 +14,9 @@
 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) {}
 
@@ -25,7 +24,7 @@
                                             const CKeyID &address,
                                             const CScript &scriptCode) const {
     CKey key;
-    if (!keystore->GetKey(address, key)) {
+    if (!m_provider->GetKey(address, key)) {
         return false;
     }
 
@@ -100,25 +99,22 @@
             }
 
             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;
     }
@@ -183,13 +179,13 @@
     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;
@@ -198,7 +194,7 @@
     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());
@@ -206,7 +202,7 @@
     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);
 }