mempool_entry.h

Go to the documentation of this file.

// Copyright (c) 2009-2022 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_KERNEL_MEMPOOL_ENTRY_H
#define BITCOIN_KERNEL_MEMPOOL_ENTRY_H
 
#include <consensus/amount.h>
#include <core_memusage.h>
#include <policy/policy.h>
#include <policy/settings.h>
#include <primitives/transaction.h>
#include <rcu.h>
 
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <set>
 
struct LockPoints {
    // Will be set to the blockchain height and median time past values that
    // would be necessary to satisfy all relative locktime constraints (BIP68)
    // of this tx given our view of block chain history
    int height{0};
    int64_t time{0};
};
 
struct CompareIteratorById {
    // SFINAE for T where T is either a std::reference_wrapper<T> (e.g. a
    // CTxMemPoolEntryRef) or an iterator to a pointer type (e.g., a txiter)
    template <typename T>
    bool operator()(const std::reference_wrapper<T> &a,
                    const std::reference_wrapper<T> &b) const {
        return a.get()->GetTx().GetId() < b.get()->GetTx().GetId();
    }
    template <typename T> bool operator()(const T &a, const T &b) const {
        return (*a)->GetTx().GetId() < (*b)->GetTx().GetId();
    }
};
struct CompareIteratorByRevEntryId {
    template <typename T>
    bool operator()(const std::reference_wrapper<T> &a,
                    const std::reference_wrapper<T> &b) const {
        return a.get()->GetEntryId() > b.get()->GetEntryId();
    }
 
    template <typename T> bool operator()(const T &a, const T &b) const {
        return (*a)->GetEntryId() > (*b)->GetEntryId();
    }
};
 
class CTxMemPoolEntry;
using CTxMemPoolEntryRef = RCUPtr<CTxMemPoolEntry>;
 
class CTxMemPoolEntry {
public:
    // two aliases, should the types ever diverge
    typedef std::set<std::reference_wrapper<const CTxMemPoolEntryRef>,
                     CompareIteratorById>
        Parents;
    typedef std::set<std::reference_wrapper<const CTxMemPoolEntryRef>,
                     CompareIteratorById>
        Children;
 
private:
    uint64_t entryId = 0;
 
    const CTransactionRef tx;
    mutable Parents m_parents;
    mutable Children m_children;
    const Amount nFee;
    const size_t nTxSize;
    const size_t nUsageSize;
    const int64_t nTime;
    const unsigned int entryHeight;
    const int64_t sigChecks;
    Amount m_modified_fee{Amount::zero()};
    LockPoints lockPoints;
 
    IMPLEMENT_RCU_REFCOUNT(uint64_t);
 
public:
    CTxMemPoolEntry(const CTransactionRef &_tx, const Amount fee, int64_t time,
                    unsigned int entry_height, int64_t sigchecks, LockPoints lp)
        : tx{_tx}, nFee{fee}, nTxSize(tx->GetTotalSize()),
          nUsageSize{RecursiveDynamicUsage(tx)}, nTime(time),
          entryHeight{entry_height}, sigChecks(sigchecks), m_modified_fee{nFee},
          lockPoints(lp) {}
 
    CTxMemPoolEntry(const CTxMemPoolEntry &other) = delete;
    CTxMemPoolEntry(CTxMemPoolEntry &&other)
        : entryId(other.entryId), tx(std::move(other.tx)),
          m_parents(std::move(other.m_parents)),
          m_children(std::move(other.m_children)), nFee(other.nFee),
          nTxSize(other.nTxSize), nUsageSize(other.nUsageSize),
          nTime(other.nTime), entryHeight(other.entryHeight),
          sigChecks(other.sigChecks), m_modified_fee(other.m_modified_fee),
          lockPoints(std::move(other.lockPoints)),
          refcount(other.refcount.load()){};
 
    uint64_t GetEntryId() const { return entryId; }
    void SetEntryId(uint64_t eid) { entryId = eid; }
 
    const CTransaction &GetTx() const { return *this->tx; }
    CTransactionRef GetSharedTx() const { return this->tx; }
    Amount GetFee() const { return nFee; }
    size_t GetTxSize() const { return nTxSize; }
    size_t GetTxVirtualSize() const {
        return GetVirtualTransactionSize(nTxSize, sigChecks,
                                         ::nBytesPerSigCheck);
    }
 
    std::chrono::seconds GetTime() const { return std::chrono::seconds{nTime}; }
    unsigned int GetHeight() const { return entryHeight; }
    int64_t GetSigChecks() const { return sigChecks; }
    Amount GetModifiedFee() const { return m_modified_fee; }
    CFeeRate GetModifiedFeeRate() const {
        return CFeeRate(GetModifiedFee(), GetTxVirtualSize());
    }
    size_t DynamicMemoryUsage() const { return nUsageSize; }
    const LockPoints &GetLockPoints() const { return lockPoints; }
 
    // Updates the modified fees used for mining priority score
    void UpdateModifiedFee(Amount fee_diff) {
        m_modified_fee.SaturatingAdd(fee_diff);
    };
 
    const Parents &GetMemPoolParentsConst() const { return m_parents; }
    const Children &GetMemPoolChildrenConst() const { return m_children; }
    Parents &GetMemPoolParents() const { return m_parents; }
    Children &GetMemPoolChildren() const { return m_children; }
};
 
#endif // BITCOIN_KERNEL_MEMPOOL_ENTRY_H