coins.h

Go to the documentation of this file.

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2014 The Bitcoin developers
// Copyright (c) 2016-2021 The PIVX Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef PIVX_COINS_H
#define PIVX_COINS_H
 
#include "compressor.h"
#include "consensus/consensus.h" // can be removed once policy/ established
#include "crypto/siphash.h"
#include "memusage.h"
#include "sapling/incrementalmerkletree.h"
#include "script/standard.h"
#include "serialize.h"
#include "uint256.h"
 
#include <assert.h>
#include <stdint.h>
 
#include <unordered_map>
 
class Coin
{
public:
    bool fCoinBase;
 
    bool fCoinStake;
 
    CTxOut out;
 
    uint32_t nHeight;
 
    Coin(CTxOut&& outIn, int nHeightIn, bool fCoinBaseIn, bool fCoinStakeIn) : fCoinBase(fCoinBaseIn), fCoinStake(fCoinStakeIn), out(std::move(outIn)), nHeight(nHeightIn) {}
    Coin(const CTxOut& outIn, int nHeightIn, bool fCoinBaseIn, bool fCoinStakeIn) : fCoinBase(fCoinBaseIn), fCoinStake(fCoinStakeIn), out(outIn), nHeight(nHeightIn) {}
 
    void Clear() {
        out.SetNull();
        fCoinBase = false;
        fCoinStake = false;
        nHeight = 0;
    }
 
    Coin() : fCoinBase(false), fCoinStake(false), nHeight(0) { }
 
    bool IsCoinBase() const {
        return fCoinBase;
    }
 
    bool IsCoinStake() const {
        return fCoinStake;
    }
 
    template<typename Stream>
    void Serialize(Stream &s) const {
        assert(!IsSpent());
        uint32_t code = nHeight * 4 + (fCoinBase ? 2 : 0) + (fCoinStake ? 1 : 0);
        ::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 >> 2;
        fCoinBase = code & 2;
        fCoinStake = code & 1;
        ::Unserialize(s, Using<TxOutCompression>(out));
    }
 
    bool IsSpent() const {
        return out.IsNull();
    }
 
    size_t DynamicMemoryUsage() const {
        return memusage::DynamicUsage(out.scriptPubKey);
    }
};
 
class SaltedOutpointHasher
{
private:
    const uint64_t k0, k1;
 
public:
    SaltedOutpointHasher();
 
    size_t operator()(const COutPoint& id) const {
        return SipHashUint256Extra(k0, k1, id.hash, id.n);
    }
};
 
// Used on Sapling nullifiers, anchor maps and txmempool::mapTx: sorted by txid
class SaltedIdHasher
{
private:
    const uint64_t k0, k1;
 
public:
    SaltedIdHasher();
 
    size_t operator()(const uint256& txid) const {
        return SipHashUint256(k0, k1, txid);
    }
};
 
struct CCoinsCacheEntry {
    Coin coin; // The actual cached data.
    unsigned char flags;
 
    enum Flags {
        DIRTY = (1 << 0), // This cache entry is potentially different from the version in the parent view.
        FRESH = (1 << 1), // The parent view does not have this entry (or it is pruned).
    };
 
    CCoinsCacheEntry() : flags(0) {}
    explicit CCoinsCacheEntry(Coin&& coin_) : coin(std::move(coin_)), flags(0) {}
};
 
// Sapling
 
struct CAnchorsSaplingCacheEntry
{
    bool entered; // This will be false if the anchor is removed from the cache
    SaplingMerkleTree tree; // The tree itself
    unsigned char flags;
 
    enum Flags {
        DIRTY = (1 << 0), // This cache entry is potentially different from the version in the parent view.
    };
 
    CAnchorsSaplingCacheEntry() : entered(false), flags(0) {}
};
 
struct CNullifiersCacheEntry
{
    bool entered; // If the nullifier is spent or not
    unsigned char flags;
 
    enum Flags {
        DIRTY = (1 << 0), // This cache entry is potentially different from the version in the parent view.
    };
 
    CNullifiersCacheEntry() : entered(false), flags(0) {}
};
 
typedef std::unordered_map<uint256, CAnchorsSaplingCacheEntry, SaltedIdHasher> CAnchorsSaplingMap;
typedef std::unordered_map<uint256, CNullifiersCacheEntry, SaltedIdHasher> CNullifiersMap;
 
typedef std::unordered_map<COutPoint, CCoinsCacheEntry, SaltedOutpointHasher> CCoinsMap;
 
class CCoinsViewCursor
{
public:
    CCoinsViewCursor(const uint256 &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 uint256 &GetBestBlock() const { return hashBlock; }
private:
    uint256 hashBlock;
};
 
class CCoinsView
{
public:
    virtual bool GetCoin(const COutPoint& outpoint, Coin& coin) const;
 
    virtual bool HaveCoin(const COutPoint& outpoint) const;
 
    virtual uint256 GetBestBlock() const;
 
    virtual std::vector<uint256> GetHeadBlocks() const;
 
    virtual bool BatchWrite(CCoinsMap& mapCoins,
                            const uint256& hashBlock,
                            const uint256& hashSaplingAnchor,
                            CAnchorsSaplingMap& mapSaplingAnchors,
                            CNullifiersMap& mapSaplingNullifiers);
 
    virtual CCoinsViewCursor* Cursor() const;
 
    virtual ~CCoinsView() {}
 
    virtual size_t EstimateSize() const { return 0; }
 
    // Sapling
    virtual bool GetSaplingAnchorAt(const uint256 &rt, SaplingMerkleTree &tree) const;
 
    virtual bool GetNullifier(const uint256 &nullifier) const;
 
    virtual uint256 GetBestAnchor() const;
};
 
 
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;
    uint256 GetBestBlock() const override;
    std::vector<uint256> GetHeadBlocks() const override;
    void SetBackend(CCoinsView& viewIn);
    CCoinsViewCursor* Cursor() const override;
    size_t EstimateSize() const override;
 
    bool BatchWrite(CCoinsMap& mapCoins,
                    const uint256& hashBlock,
                    const uint256& hashSaplingAnchor,
                    CAnchorsSaplingMap& mapSaplingAnchors,
                    CNullifiersMap& mapSaplingNullifiers) override;
 
    // Sapling
    bool GetSaplingAnchorAt(const uint256 &rt, SaplingMerkleTree &tree) const override;
    bool GetNullifier(const uint256 &nullifier) const override;
    uint256 GetBestAnchor() const override;
};
 
 
static const unsigned int STANDARD_LOCKTIME_VERIFY_FLAGS = LOCKTIME_VERIFY_SEQUENCE |
                                                           LOCKTIME_MEDIAN_TIME_PAST;
 
class CCoinsViewCache : public CCoinsViewBacked
{
protected:
    mutable uint256 hashBlock;
    mutable CCoinsMap cacheCoins;
 
    // Sapling
    mutable uint256 hashSaplingAnchor;
    mutable CAnchorsSaplingMap cacheSaplingAnchors;
    mutable CNullifiersMap cacheSaplingNullifiers;
 
    /* Cached dynamic memory usage for the inner Coin objects. */
    mutable size_t cachedCoinsUsage;
 
public:
    CCoinsViewCache(CCoinsView *baseIn);
 
    CCoinsViewCache(const CCoinsViewCache &) = delete;
 
    // Sapling methods
    bool GetSaplingAnchorAt(const uint256 &rt, SaplingMerkleTree &tree) const override;
    bool GetNullifier(const uint256 &nullifier) const override;
    uint256 GetBestAnchor() const override;
 
    // Adds the tree to mapSaplingAnchors
    // and sets the current commitment root to this root.
    template<typename Tree> void PushAnchor(const Tree &tree);
 
    // Removes the current commitment root from mapAnchors and sets
    // the new current root.
    void PopAnchor(const uint256 &rt);
 
    // Marks nullifiers for a given transaction as spent or not.
    void SetNullifiers(const CTransaction& tx, bool spent);
 
    bool HaveShieldedRequirements(const CTransaction& tx) const;
 
    // Standard CCoinsView methods
    bool GetCoin(const COutPoint& outpoint, Coin& coin) const override;
    bool HaveCoin(const COutPoint& outpoint) const override;
    uint256 GetBestBlock() const override;
    void SetBestBlock(const uint256& hashBlock);
 
    bool GetUTXOCoin(const COutPoint& outpoint, Coin& coin) const;
 
    bool BatchWrite(CCoinsMap& mapCoins,
                    const uint256& hashBlock,
                    const uint256& hashSaplingAnchor,
                    CAnchorsSaplingMap& mapSaplingAnchors,
                    CNullifiersMap& mapSaplingNullifiers) override;
 
    bool HaveCoinInCache(const COutPoint& outpoint) const;
 
    const Coin& AccessCoin(const COutPoint& output) const;
 
    void AddCoin(const COutPoint& outpoint, Coin&& coin, bool potential_overwrite);
 
    void SpendCoin(const COutPoint &outpoint, Coin* moveto = nullptr);
 
    bool Flush();
 
    void Uncache(const COutPoint &outpoint);
 
    unsigned int GetCacheSize() const;
 
    size_t DynamicMemoryUsage() const;
 
    CAmount GetValueIn(const CTransaction& tx) const;
 
    bool HaveInputs(const CTransaction& tx) const;
 
    /*
     * Return the depth of a coin at height nHeight, or -1 if not found
     */
    int GetCoinDepthAtHeight(const COutPoint& output, int nHeight) const;
 
    /*
     * Return the sum of the value of all transaction outputs
     */
    CAmount GetTotalAmount() const;
 
    /*
     * Prune zerocoin mints and frozen outputs - do it once, after initialization
     */
    bool PruneInvalidEntries();
 
 
private:
    CCoinsMap::iterator FetchCoin(const COutPoint& outpoint) const;
 
    template<typename Tree, typename Cache, typename CacheEntry>
    void AbstractPopAnchor(
            const uint256 &newrt,
            Cache &cacheAnchors,
            uint256 &hash
    );
 
    template<typename Tree, typename Cache, typename CacheIterator, typename CacheEntry>
    void AbstractPushAnchor(
            const Tree &tree,
            Cache &cacheAnchors,
            uint256 &hash
    );
 
    template<typename Tree>
    void BringBestAnchorIntoCache(
            const uint256 &currentRoot,
            Tree &tree
    );
};
 
// PIVX: When check is false, this assumes that overwrites are never possible due to BIP34 always in effect
// When check is true, the underlying view may be queried to determine whether an addition is
// an overwrite.
// When fSkipInvalid is true, the invalid_out list is checked before adding the coin.
void AddCoins(CCoinsViewCache& cache, const CTransaction& tx, int nHeight, bool check = false, bool fSkipInvalid = false);
 
const Coin& AccessByTxid(const CCoinsViewCache& cache, const uint256& txid);
 
#endif // PIVX_COINS_H