coins.h

Go to the documentation of this file.

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2016 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 <compressor.h>
#include <crypto/siphash.h>
#include <memusage.h>
#include <primitives/blockhash.h>
#include <serialize.h>

#include <cassert>
#include <cstdint>
#include <functional>
#include <unordered_map>

class Coin {
    CTxOut out;

    uint32_t nHeightAndIsCoinBase;

public:
    Coin() : nHeightAndIsCoinBase(0) {}

    Coin(CTxOut outIn, uint32_t nHeightIn, bool IsCoinbase)
        : out(std::move(outIn)),
          nHeightAndIsCoinBase((nHeightIn << 1) | IsCoinbase) {}

    uint32_t GetHeight() const { return nHeightAndIsCoinBase >> 1; }
    bool IsCoinBase() const { return nHeightAndIsCoinBase & 0x01; }
    bool IsSpent() const { return out.IsNull(); }

    CTxOut &GetTxOut() { return out; }
    const CTxOut &GetTxOut() const { return out; }

    void Clear() {
        out.SetNull();
        nHeightAndIsCoinBase = 0;
    }

    template <typename Stream> void Serialize(Stream &s) const {
        assert(!IsSpent());
        ::Serialize(s, VARINT(nHeightAndIsCoinBase));
        ::Serialize(s, Using<TxOutCompression>(out));
    }

    template <typename Stream> void Unserialize(Stream &s) {
        ::Unserialize(s, VARINT(nHeightAndIsCoinBase));
        ::Unserialize(s, Using<TxOutCompression>(out));
    }

    size_t DynamicMemoryUsage() const {
        return memusage::DynamicUsage(out.scriptPubKey);
    }
};

class SaltedOutpointHasher {
private:
    const uint64_t k0, k1;

public:
    SaltedOutpointHasher();

    size_t operator()(const COutPoint &outpoint) const noexcept {
        return SipHashUint256Extra(k0, k1, outpoint.GetTxId(), outpoint.GetN());
    }
};

struct CCoinsCacheEntry {
    // The actual cached data.
    Coin coin;
    uint8_t flags;

    enum Flags {
        DIRTY = (1 << 0),
        FRESH = (1 << 1),
    };

    CCoinsCacheEntry() : flags(0) {}
    explicit CCoinsCacheEntry(Coin coinIn)
        : coin(std::move(coinIn)), flags(0) {}
};

typedef std::unordered_map<COutPoint, CCoinsCacheEntry, SaltedOutpointHasher>
    CCoinsMap;

class CCoinsViewCursor {
public:
    CCoinsViewCursor(const BlockHash &hashBlockIn) : hashBlock(hashBlockIn) {}
    virtual ~CCoinsViewCursor() {}

    virtual bool GetKey(COutPoint &key) const = 0;
    virtual bool GetValue(Coin &coin) const = 0;
    virtual unsigned int GetValueSize() const = 0;

    virtual bool Valid() const = 0;
    virtual void Next() = 0;

    const BlockHash &GetBestBlock() const { return hashBlock; }

private:
    BlockHash hashBlock;
};

class CCoinsView {
public:
    virtual bool GetCoin(const COutPoint &outpoint, Coin &coin) const;

    virtual bool HaveCoin(const COutPoint &outpoint) const;

    virtual BlockHash GetBestBlock() const;

    virtual std::vector<BlockHash> GetHeadBlocks() const;

    virtual bool BatchWrite(CCoinsMap &mapCoins, const BlockHash &hashBlock);

    virtual CCoinsViewCursor *Cursor() const;

    virtual ~CCoinsView() {}

    virtual size_t EstimateSize() const { return 0; }
};

class CCoinsViewBacked : public CCoinsView {
protected:
    CCoinsView *base;

public:
    CCoinsViewBacked(CCoinsView *viewIn);
    bool GetCoin(const COutPoint &outpoint, Coin &coin) const override;
    bool HaveCoin(const COutPoint &outpoint) const override;
    BlockHash GetBestBlock() const override;
    std::vector<BlockHash> GetHeadBlocks() const override;
    void SetBackend(CCoinsView &viewIn);
    bool BatchWrite(CCoinsMap &mapCoins, const BlockHash &hashBlock) override;
    CCoinsViewCursor *Cursor() const override;
    size_t EstimateSize() const override;
};

class CCoinsViewCache : public CCoinsViewBacked {
protected:
    mutable BlockHash hashBlock;
    mutable CCoinsMap cacheCoins;

    /* Cached dynamic memory usage for the inner Coin objects. */
    mutable size_t cachedCoinsUsage;

public:
    CCoinsViewCache(CCoinsView *baseIn);

    CCoinsViewCache(const CCoinsViewCache &) = delete;

    // Standard CCoinsView methods
    bool GetCoin(const COutPoint &outpoint, Coin &coin) const override;
    bool HaveCoin(const COutPoint &outpoint) const override;
    BlockHash GetBestBlock() const override;
    void SetBestBlock(const BlockHash &hashBlock);
    bool BatchWrite(CCoinsMap &mapCoins, const BlockHash &hashBlock) override;
    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);

    bool SpendCoin(const COutPoint &outpoint, Coin *moveto = nullptr);

    bool Flush();

    void Uncache(const COutPoint &outpoint);

    unsigned int GetCacheSize() const;

    size_t DynamicMemoryUsage() const;

    Amount GetValueIn(const CTransaction &tx) const;

    bool HaveInputs(const CTransaction &tx) const;

private:
    CCoinsMap::iterator FetchCoin(const COutPoint &outpoint) const;
};

// 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));
    }

    bool GetCoin(const COutPoint &outpoint, Coin &coin) const override;

private:
    std::vector<std::function<void()>> m_err_callbacks;
};

#endif // BITCOIN_COINS_H