Expose CSignatureCache class in header

This is done in preparation for the following commit. Also rename it to
SignatureCache.

src/script/sigcache.cpp

@@ -5,82 +5,61 @@
 
 #include <script/sigcache.h>
 
-#include <common/system.h>
+#include <crypto/sha256.h>
 #include <logging.h>
 #include <pubkey.h>
 #include <random.h>
+#include <script/interpreter.h>
+#include <span.h>
 #include <uint256.h>
 
-#include <cuckoocache.h>
-
-#include <algorithm>
 #include <mutex>
 #include <shared_mutex>
 #include <vector>
 
-namespace {
+SignatureCache::SignatureCache()
-/**
- * Valid signature cache, to avoid doing expensive ECDSA signature checking
- * twice for every transaction (once when accepted into memory pool, and
- * again when accepted into the block chain)
- */
-class CSignatureCache
 {
-private:
+    uint256 nonce = GetRandHash();
-     //! Entries are SHA256(nonce || 'E' or 'S' || 31 zero bytes || signature hash || public key || signature):
+    // We want the nonce to be 64 bytes long to force the hasher to process
-    CSHA256 m_salted_hasher_ecdsa;
+    // this chunk, which makes later hash computations more efficient. We
-    CSHA256 m_salted_hasher_schnorr;
+    // just write our 32-byte entropy, and then pad with 'E' for ECDSA and
-    typedef CuckooCache::cache<uint256, SignatureCacheHasher> map_type;
+    // 'S' for Schnorr (followed by 0 bytes).
-    map_type setValid;
+    static constexpr unsigned char PADDING_ECDSA[32] = {'E'};
-    std::shared_mutex cs_sigcache;
+    static constexpr unsigned char PADDING_SCHNORR[32] = {'S'};
+    m_salted_hasher_ecdsa.Write(nonce.begin(), 32);
+    m_salted_hasher_ecdsa.Write(PADDING_ECDSA, 32);
+    m_salted_hasher_schnorr.Write(nonce.begin(), 32);
+    m_salted_hasher_schnorr.Write(PADDING_SCHNORR, 32);
+}
 
-public:
+void SignatureCache::ComputeEntryECDSA(uint256& entry, const uint256& hash, const std::vector<unsigned char>& vchSig, const CPubKey& pubkey) const
-    CSignatureCache()
+{
-    {
+    CSHA256 hasher = m_salted_hasher_ecdsa;
-        uint256 nonce = GetRandHash();
+    hasher.Write(hash.begin(), 32).Write(pubkey.data(), pubkey.size()).Write(vchSig.data(), vchSig.size()).Finalize(entry.begin());
-        // We want the nonce to be 64 bytes long to force the hasher to process
+}
-        // this chunk, which makes later hash computations more efficient. We
-        // just write our 32-byte entropy, and then pad with 'E' for ECDSA and
-        // 'S' for Schnorr (followed by 0 bytes).
-        static constexpr unsigned char PADDING_ECDSA[32] = {'E'};
-        static constexpr unsigned char PADDING_SCHNORR[32] = {'S'};
-        m_salted_hasher_ecdsa.Write(nonce.begin(), 32);
-        m_salted_hasher_ecdsa.Write(PADDING_ECDSA, 32);
-        m_salted_hasher_schnorr.Write(nonce.begin(), 32);
-        m_salted_hasher_schnorr.Write(PADDING_SCHNORR, 32);
-    }
 
-    void
+void SignatureCache::ComputeEntrySchnorr(uint256& entry, const uint256& hash, Span<const unsigned char> sig, const XOnlyPubKey& pubkey) const
-    ComputeEntryECDSA(uint256& entry, const uint256 &hash, const std::vector<unsigned char>& vchSig, const CPubKey& pubkey) const
+{
-    {
+    CSHA256 hasher = m_salted_hasher_schnorr;
-        CSHA256 hasher = m_salted_hasher_ecdsa;
+    hasher.Write(hash.begin(), 32).Write(pubkey.data(), pubkey.size()).Write(sig.data(), sig.size()).Finalize(entry.begin());
-        hasher.Write(hash.begin(), 32).Write(pubkey.data(), pubkey.size()).Write(vchSig.data(), vchSig.size()).Finalize(entry.begin());
+}
-    }
 
-    void
+bool SignatureCache::Get(const uint256& entry, const bool erase)
-    ComputeEntrySchnorr(uint256& entry, const uint256 &hash, Span<const unsigned char> sig, const XOnlyPubKey& pubkey) const
+{
-    {
+    std::shared_lock<std::shared_mutex> lock(cs_sigcache);
-        CSHA256 hasher = m_salted_hasher_schnorr;
+    return setValid.contains(entry, erase);
-        hasher.Write(hash.begin(), 32).Write(pubkey.data(), pubkey.size()).Write(sig.data(), sig.size()).Finalize(entry.begin());
+}
-    }
 
-    bool
+void SignatureCache::Set(const uint256& entry)
-    Get(const uint256& entry, const bool erase)
+{
-    {
+    std::unique_lock<std::shared_mutex> lock(cs_sigcache);
-        std::shared_lock<std::shared_mutex> lock(cs_sigcache);
+    setValid.insert(entry);
-        return setValid.contains(entry, erase);
+}
-    }
 
-    void Set(const uint256& entry)
+std::pair<uint32_t, size_t> SignatureCache::setup_bytes(size_t n)
-    {
+{
-        std::unique_lock<std::shared_mutex> lock(cs_sigcache);
+    return setValid.setup_bytes(n);
-        setValid.insert(entry);
+}
-    }
-    std::pair<uint32_t, size_t> setup_bytes(size_t n)
-    {
-        return setValid.setup_bytes(n);
-    }
-};
 
 /* In previous versions of this code, signatureCache was a local static variable
  * in CachingTransactionSignatureChecker::VerifySignature.  We initialize
@@ -88,8 +67,7 @@ public:
  * call overhead associated with local static variables even though
  * signatureCache could be made local to VerifySignature.
 */
-static CSignatureCache signatureCache;
+static SignatureCache signatureCache;
-} // namespace
 
 // To be called once in AppInitMain/BasicTestingSetup to initialize the
 // signatureCache.

src/script/sigcache.h

@@ -6,12 +6,23 @@
 #ifndef BITCOIN_SCRIPT_SIGCACHE_H
 #define BITCOIN_SCRIPT_SIGCACHE_H
 
+#include <consensus/amount.h>
+#include <crypto/sha256.h>
+#include <cuckoocache.h>
 #include <script/interpreter.h>
 #include <span.h>
+#include <uint256.h>
 #include <util/hasher.h>
 
+#include <cstddef>
+#include <cstdint>
+#include <shared_mutex>
+#include <utility>
 #include <vector>
 
+class CTransaction;
+class XOnlyPubKey;
+
 // DoS prevention: limit cache size to 32MiB (over 1000000 entries on 64-bit
 // systems). Due to how we count cache size, actual memory usage is slightly
 // more (~32.25 MiB)
@@ -20,6 +31,35 @@ static constexpr size_t DEFAULT_SCRIPT_EXECUTION_CACHE_BYTES{DEFAULT_MAX_SIG_CAC
 
 class CPubKey;
 
+/**
+ * Valid signature cache, to avoid doing expensive ECDSA signature checking
+ * twice for every transaction (once when accepted into memory pool, and
+ * again when accepted into the block chain)
+ */
+class SignatureCache
+{
+private:
+    //! Entries are SHA256(nonce || 'E' or 'S' || 31 zero bytes || signature hash || public key || signature):
+    CSHA256 m_salted_hasher_ecdsa;
+    CSHA256 m_salted_hasher_schnorr;
+    typedef CuckooCache::cache<uint256, SignatureCacheHasher> map_type;
+    map_type setValid;
+    std::shared_mutex cs_sigcache;
+
+public:
+    SignatureCache();
+
+    void ComputeEntryECDSA(uint256& entry, const uint256 &hash, const std::vector<unsigned char>& vchSig, const CPubKey& pubkey) const;
+
+    void ComputeEntrySchnorr(uint256& entry, const uint256 &hash, Span<const unsigned char> sig, const XOnlyPubKey& pubkey) const;
+
+    bool Get(const uint256& entry, const bool erase);
+
+    void Set(const uint256& entry);
+
+    std::pair<uint32_t, size_t> setup_bytes(size_t n);
+};
+
 class CachingTransactionSignatureChecker : public TransactionSignatureChecker
 {
 private: