hasher.h

Go to the documentation of this file.

// Copyright (c) 2019 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 <addresstype.h>
#include <crypto/siphash.h>
#include <primitives/blockhash.h>
#include <primitives/transaction.h>
#include <primitives/txid.h>
#include <script/solver.h>
#include <uint256.h>
 
class SaltedUint256Hasher {
private:
    const uint64_t k0, k1;
 
public:
    SaltedUint256Hasher();
 
    size_t hash(const uint256 &h) const { return SipHashUint256(k0, k1, h); }
    size_t operator()(const uint256 &h) const { return hash(h); }
};
 
class SaltedTxIdHasher : private SaltedUint256Hasher {
public:
    SaltedTxIdHasher() : SaltedUint256Hasher() {}
 
    size_t operator()(const TxId &txid) const { return hash(txid); }
};
 
class SaltedBlockHashHasher : private SaltedUint256Hasher {
public:
    SaltedBlockHashHasher() : SaltedUint256Hasher() {}
 
    size_t operator()(const BlockHash &block_hash) const {
        return hash(block_hash);
    }
};
 
class SaltedOutpointHasher {
private:
    const uint64_t k0, k1;
 
public:
    SaltedOutpointHasher(bool deterministic = false);
 
    size_t operator()(const COutPoint &outpoint) const noexcept {
        return SipHashUint256Extra(k0, k1, outpoint.GetTxId(), outpoint.GetN());
    }
};
 
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 BlockHash &hash) const {
        return ReadLE64(hash.begin());
    }
};
 
class SaltedSipHasher {
private:
    const uint64_t m_k0, m_k1;
 
public:
    SaltedSipHasher();
 
    size_t operator()(const Span<const uint8_t> &script) const;
};
 
struct TxDestinationHasher : SaltedSipHasher {
    size_t operator()(const CTxDestination &dest) const {
        return SaltedSipHasher::operator()(GetScriptForDestination(dest));
    }
};
 
#endif // BITCOIN_UTIL_HASHER_H