hasher.h

Go to the documentation of this file.

// Copyright (c) 2019-present 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_UTIL_HASHER_H
#define BITCOIN_UTIL_HASHER_H
 
#include <crypto/common.h>
#include <crypto/siphash.h>
#include <primitives/transaction.h>
#include <span.h>
#include <uint256.h>
 
#include <concepts>
#include <cstdint>
#include <cstring>
 
class SaltedUint256Hasher
{
    const PresaltedSipHasher m_hasher;
 
public:
    SaltedUint256Hasher();
 
    size_t operator()(const uint256& hash) const
    {
        return m_hasher(hash);
    }
};
 
class SaltedTxidHasher
{
    const PresaltedSipHasher m_hasher;
 
public:
    SaltedTxidHasher();
 
    size_t operator()(const Txid& txid) const
    {
        return m_hasher(txid.ToUint256());
    }
};
 
class SaltedWtxidHasher
{
    const PresaltedSipHasher m_hasher;
 
public:
    SaltedWtxidHasher();
 
    size_t operator()(const Wtxid& wtxid) const
    {
        return m_hasher(wtxid.ToUint256());
    }
};
 
class SaltedOutpointHasher
{
    const PresaltedSipHasher m_hasher;
 
public:
    SaltedOutpointHasher(bool deterministic = false);
 
    size_t operator()(const COutPoint& id) const noexcept
    {
        return m_hasher(id.hash.ToUint256(), id.n);
    }
};
 
struct FilterHeaderHasher {
    size_t operator()(const uint256& hash) const { return ReadLE64(hash.begin()); }
};
 
class SignatureCacheHasher
{
public:
    template <uint8_t hash_select>
    uint32_t operator()(const uint256& key) const
    {
        static_assert(hash_select <8, "SignatureCacheHasher only has 8 hashes available.");
        uint32_t u;
        std::memcpy(&u, key.begin()+4*hash_select, 4);
        return u;
    }
};
 
struct BlockHasher
{
    // this used to call `GetCheapHash()` in uint256, which was later moved; the
    // cheap hash function simply calls ReadLE64() however, so the end result is
    // identical
    size_t operator()(const uint256& hash) const { return ReadLE64(hash.begin()); }
};
 
class SaltedSipHasher
{
private:
    const uint64_t m_k0, m_k1;
 
public:
    SaltedSipHasher();
 
    size_t operator()(const std::span<const unsigned char>& script) const;
};
 
#endif // BITCOIN_UTIL_HASHER_H