coins.h

Go to the documentation of this file.

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-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_COINS_H
#define BITCOIN_COINS_H
 
#include <attributes.h>
#include <compressor.h>
#include <core_memusage.h>
#include <memusage.h>
#include <primitives/transaction.h>
#include <serialize.h>
#include <support/allocators/pool.h>
#include <uint256.h>
#include <util/check.h>
#include <util/overflow.h>
#include <util/hasher.h>
 
#include <cassert>
#include <cstdint>
 
#include <functional>
#include <unordered_map>
 
class Coin
{
public:
    CTxOut out;
 
    unsigned int fCoinBase : 1;
 
    uint32_t nHeight : 31;
 
    Coin(CTxOut&& outIn, int nHeightIn, bool fCoinBaseIn) : out(std::move(outIn)), fCoinBase(fCoinBaseIn), nHeight(nHeightIn) {}
    Coin(const CTxOut& outIn, int nHeightIn, bool fCoinBaseIn) : out(outIn), fCoinBase(fCoinBaseIn),nHeight(nHeightIn) {}
 
    void Clear() {
        out.SetNull();
        fCoinBase = false;
        nHeight = 0;
    }
 
    Coin() : fCoinBase(false), nHeight(0) { }
 
    bool IsCoinBase() const {
        return fCoinBase;
    }
 
    template<typename Stream>
    void Serialize(Stream &s) const {
        assert(!IsSpent());
        uint32_t code = nHeight * uint32_t{2} + fCoinBase;
        ::Serialize(s, VARINT(code));
        ::Serialize(s, Using<TxOutCompression>(out));
    }
 
    template<typename Stream>
    void Unserialize(Stream &s) {
        uint32_t code = 0;
        ::Unserialize(s, VARINT(code));
        nHeight = code >> 1;
        fCoinBase = code & 1;
        ::Unserialize(s, Using<TxOutCompression>(out));
    }
 
    bool IsSpent() const {
        return out.IsNull();
    }
 
    size_t DynamicMemoryUsage() const {
        return memusage::DynamicUsage(out.scriptPubKey);
    }
};
 
struct CCoinsCacheEntry;
using CoinsCachePair = std::pair<const COutPoint, CCoinsCacheEntry>;
 
struct CCoinsCacheEntry
{
private:
    CoinsCachePair* m_prev{nullptr};
    CoinsCachePair* m_next{nullptr};
    uint8_t m_flags{0};
 
    static void AddFlags(uint8_t flags, CoinsCachePair& pair, CoinsCachePair& sentinel) noexcept
    {
        Assume(flags & (DIRTY | FRESH));
        if (!pair.second.m_flags) {
            Assume(!pair.second.m_prev && !pair.second.m_next);
            pair.second.m_prev = sentinel.second.m_prev;
            pair.second.m_next = &sentinel;
            sentinel.second.m_prev = &pair;
            pair.second.m_prev->second.m_next = &pair;
        }
        Assume(pair.second.m_prev && pair.second.m_next);
        pair.second.m_flags |= flags;
    }
 
public:
    Coin coin; // The actual cached data.
 
    enum Flags {
        DIRTY = (1 << 0),
        FRESH = (1 << 1),
    };
 
    CCoinsCacheEntry() noexcept = default;
    explicit CCoinsCacheEntry(Coin&& coin_) noexcept : coin(std::move(coin_)) {}
    ~CCoinsCacheEntry()
    {
        SetClean();
    }
 
    static void SetDirty(CoinsCachePair& pair, CoinsCachePair& sentinel) noexcept { AddFlags(DIRTY, pair, sentinel); }
    static void SetFresh(CoinsCachePair& pair, CoinsCachePair& sentinel) noexcept { AddFlags(FRESH, pair, sentinel); }
 
    void SetClean() noexcept
    {
        if (!m_flags) return;
        m_next->second.m_prev = m_prev;
        m_prev->second.m_next = m_next;
        m_flags = 0;
        m_prev = m_next = nullptr;
    }
    bool IsDirty() const noexcept { return m_flags & DIRTY; }
    bool IsFresh() const noexcept { return m_flags & FRESH; }
 
    CoinsCachePair* Next() const noexcept
    {
        Assume(m_flags);
        return m_next;
    }
 
    CoinsCachePair* Prev() const noexcept
    {
        Assume(m_flags);
        return m_prev;
    }
 
    void SelfRef(CoinsCachePair& pair) noexcept
    {
        Assume(&pair.second == this);
        m_prev = &pair;
        m_next = &pair;
        // Set sentinel to DIRTY so we can call Next on it
        m_flags = DIRTY;
    }
};
 
using CCoinsMap = std::unordered_map<COutPoint,
                                     CCoinsCacheEntry,
                                     SaltedOutpointHasher,
                                     std::equal_to<COutPoint>,
                                     PoolAllocator<CoinsCachePair,
                                                   sizeof(CoinsCachePair) + sizeof(void*) * 4>>;
 
using CCoinsMapMemoryResource = CCoinsMap::allocator_type::ResourceType;
 
class CCoinsViewCursor
{
public:
    CCoinsViewCursor(const uint256 &hashBlockIn): hashBlock(hashBlockIn) {}
    virtual ~CCoinsViewCursor() = default;
 
    virtual bool GetKey(COutPoint &key) const = 0;
    virtual bool GetValue(Coin &coin) const = 0;
 
    virtual bool Valid() const = 0;
    virtual void Next() = 0;
 
    const uint256 &GetBestBlock() const { return hashBlock; }
private:
    uint256 hashBlock;
};
 
struct CoinsViewCacheCursor
{
    CoinsViewCacheCursor(size_t& dirty_count LIFETIMEBOUND,
                         CoinsCachePair& sentinel LIFETIMEBOUND,
                         CCoinsMap& map LIFETIMEBOUND,
                         bool will_erase) noexcept
        : m_dirty_count(dirty_count), m_sentinel(sentinel), m_map(map), m_will_erase(will_erase) {}
 
    inline CoinsCachePair* Begin() const noexcept { return m_sentinel.second.Next(); }
    inline CoinsCachePair* End() const noexcept { return &m_sentinel; }
 
    inline CoinsCachePair* NextAndMaybeErase(CoinsCachePair& current) noexcept
    {
        const auto next_entry{current.second.Next()};
        Assume(TrySub(m_dirty_count, current.second.IsDirty()));
        // If we are not going to erase the cache, we must still erase spent entries.
        // Otherwise, clear the state of the entry.
        if (!m_will_erase) {
            if (current.second.coin.IsSpent()) {
                assert(current.second.coin.DynamicMemoryUsage() == 0); // scriptPubKey was already cleared in SpendCoin
                m_map.erase(current.first);
            } else {
                current.second.SetClean();
            }
        }
        return next_entry;
    }
 
    inline bool WillErase(CoinsCachePair& current) const noexcept { return m_will_erase || current.second.coin.IsSpent(); }
    size_t GetDirtyCount() const noexcept { return m_dirty_count; }
    size_t GetTotalCount() const noexcept { return m_map.size(); }
private:
    size_t& m_dirty_count;
    CoinsCachePair& m_sentinel;
    CCoinsMap& m_map;
    bool m_will_erase;
};
 
class CCoinsView
{
public:
    virtual std::optional<Coin> GetCoin(const COutPoint& outpoint) const;
 
    virtual std::optional<Coin> PeekCoin(const COutPoint& outpoint) const;
 
    virtual bool HaveCoin(const COutPoint &outpoint) const;
 
    virtual uint256 GetBestBlock() const;
 
    virtual std::vector<uint256> GetHeadBlocks() const;
 
    virtual void BatchWrite(CoinsViewCacheCursor& cursor, const uint256& hashBlock);
 
    virtual std::unique_ptr<CCoinsViewCursor> Cursor() const;
 
    virtual ~CCoinsView() = default;
 
    virtual size_t EstimateSize() const { return 0; }
};
 
 
class CCoinsViewBacked : public CCoinsView
{
protected:
    CCoinsView *base;
 
public:
    CCoinsViewBacked(CCoinsView *viewIn);
    std::optional<Coin> GetCoin(const COutPoint& outpoint) const override;
    std::optional<Coin> PeekCoin(const COutPoint& outpoint) const override;
    bool HaveCoin(const COutPoint &outpoint) const override;
    uint256 GetBestBlock() const override;
    std::vector<uint256> GetHeadBlocks() const override;
    void SetBackend(CCoinsView &viewIn);
    void BatchWrite(CoinsViewCacheCursor& cursor, const uint256& hashBlock) override;
    std::unique_ptr<CCoinsViewCursor> Cursor() const override;
    size_t EstimateSize() const override;
};
 
 
class CCoinsViewCache : public CCoinsViewBacked
{
private:
    const bool m_deterministic;
 
protected:
    mutable uint256 hashBlock;
    mutable CCoinsMapMemoryResource m_cache_coins_memory_resource{};
    /* The starting sentinel of the flagged entry circular doubly linked list. */
    mutable CoinsCachePair m_sentinel;
    mutable CCoinsMap cacheCoins;
 
    /* Cached dynamic memory usage for the inner Coin objects. */
    mutable size_t cachedCoinsUsage{0};
    /* Running count of dirty Coin cache entries. */
    mutable size_t m_dirty_count{0};
 
    void Reset() noexcept;
 
    /* Fetch the coin from base. Used for cache misses in FetchCoin. */
    virtual std::optional<Coin> FetchCoinFromBase(const COutPoint& outpoint) const;
 
public:
    CCoinsViewCache(CCoinsView *baseIn, bool deterministic = false);
 
    CCoinsViewCache(const CCoinsViewCache &) = delete;
 
    // Standard CCoinsView methods
    std::optional<Coin> GetCoin(const COutPoint& outpoint) const override;
    std::optional<Coin> PeekCoin(const COutPoint& outpoint) const override;
    bool HaveCoin(const COutPoint &outpoint) const override;
    uint256 GetBestBlock() const override;
    void SetBestBlock(const uint256 &hashBlock);
    void BatchWrite(CoinsViewCacheCursor& cursor, const uint256& hashBlock) override;
    std::unique_ptr<CCoinsViewCursor> Cursor() const override {
        throw std::logic_error("CCoinsViewCache cursor iteration not supported.");
    }
 
    bool HaveCoinInCache(const COutPoint &outpoint) const;
 
    const Coin& AccessCoin(const COutPoint &output) const;
 
    void AddCoin(const COutPoint& outpoint, Coin&& coin, bool possible_overwrite);
 
    void EmplaceCoinInternalDANGER(COutPoint&& outpoint, Coin&& coin);
 
    bool SpendCoin(const COutPoint &outpoint, Coin* moveto = nullptr);
 
    void Flush(bool reallocate_cache = true);
 
    void Sync();
 
    void Uncache(const COutPoint &outpoint);
 
    unsigned int GetCacheSize() const;
 
    size_t GetDirtyCount() const noexcept { return m_dirty_count; }
 
    size_t DynamicMemoryUsage() const;
 
    bool HaveInputs(const CTransaction& tx) const;
 
    void ReallocateCache();
 
    void SanityCheck() const;
 
    class ResetGuard
    {
    private:
        friend CCoinsViewCache;
        CCoinsViewCache& m_cache;
        explicit ResetGuard(CCoinsViewCache& cache LIFETIMEBOUND) noexcept : m_cache{cache} {}
 
    public:
        ResetGuard(const ResetGuard&) = delete;
        ResetGuard& operator=(const ResetGuard&) = delete;
        ResetGuard(ResetGuard&&) = delete;
        ResetGuard& operator=(ResetGuard&&) = delete;
 
        ~ResetGuard() { m_cache.Reset(); }
    };
 
    [[nodiscard]] ResetGuard CreateResetGuard() noexcept { return ResetGuard{*this}; }
 
private:
    CCoinsMap::iterator FetchCoin(const COutPoint &outpoint) const;
};
 
class CoinsViewOverlay : public CCoinsViewCache
{
private:
    std::optional<Coin> FetchCoinFromBase(const COutPoint& outpoint) const override
    {
        return base->PeekCoin(outpoint);
    }
 
public:
    using CCoinsViewCache::CCoinsViewCache;
};
 
// TODO: pass in a boolean to limit these possible overwrites to known
// (pre-BIP34) cases.
void AddCoins(CCoinsViewCache& cache, const CTransaction& tx, int nHeight, bool check = false);
 
const Coin& AccessByTxid(const CCoinsViewCache& cache, const Txid& txid);
 
class CCoinsViewErrorCatcher final : public CCoinsViewBacked
{
public:
    explicit CCoinsViewErrorCatcher(CCoinsView* view) : CCoinsViewBacked(view) {}
 
    void AddReadErrCallback(std::function<void()> f) {
        m_err_callbacks.emplace_back(std::move(f));
    }
 
    std::optional<Coin> GetCoin(const COutPoint& outpoint) const override;
    bool HaveCoin(const COutPoint &outpoint) const override;
    std::optional<Coin> PeekCoin(const COutPoint& outpoint) const override;
 
private:
    std::vector<std::function<void()>> m_err_callbacks;
 
};
 
#endif // BITCOIN_COINS_H