fees.h

Go to the documentation of this file.

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2015 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef PIVX_POLICY_FEES_H
#define PIVX_POLICY_FEES_H
 
#include "amount.h"
#include "feerate.h"
#include "uint256.h"
 
#include <map>
#include <string>
#include <vector>
 
class CAutoFile;
class CFeeRate;
class CTxMemPoolEntry;
class CTxMemPool;
 
class TxConfirmStats
{
private:
    //Define the buckets we will group transactions into
    std::vector<double> buckets;              // The upper-bound of the range for the bucket (inclusive)
    std::map<double, unsigned int> bucketMap; // Map of bucket upper-bound to index into all vectors by bucket
 
    // feerate each bucket X:
    // Count the total # of txs in each bucket
    // Track the historical moving average of this total over blocks
    std::vector<double> txCtAvg;
    // and calculate the total for the current block to update the moving average
    std::vector<int> curBlockTxCt;
 
    // Count the total # of txs confirmed within Y blocks in each bucket
    // Track the historical moving average of these totals over blocks
    std::vector<std::vector<double> > confAvg; // confAvg[Y][X]
    // and calculate the totals for the current block to update the moving averages
    std::vector<std::vector<int> > curBlockConf; // curBlockConf[Y][X]
 
    // Sum the total feerate of all tx's in each bucket
    // Track the historical moving average of this total over blocks
    std::vector<double> avg;
    // and calculate the total for the current block to update the moving average
    std::vector<double> curBlockVal;
 
    // Combine the conf counts with tx counts to calculate the confirmation % for each Y,X
    // Combine the total value with the tx counts to calculate the avg feerate per bucket
 
    double decay{0.0};
 
    // Mempool counts of outstanding transactions
    // For each bucket X, track the number of transactions in the mempool
    // that are unconfirmed for each possible confirmation value Y
    std::vector<std::vector<int> > unconfTxs;  //unconfTxs[Y][X]
    // transactions still unconfirmed after MAX_CONFIRMS for each bucket
    std::vector<int> oldUnconfTxs;
 
public:
    void Initialize(std::vector<double>& defaultBuckets, unsigned int maxConfirms, double decay);
 
    void ClearCurrent(unsigned int nBlockHeight);
 
    void Record(int blocksToConfirm, double val);
 
    unsigned int NewTx(unsigned int nBlockHeight, double val);
 
    void removeTx(unsigned int entryHeight, unsigned int nBestSeenHeight,
                  unsigned int bucketIndex);
 
    void UpdateMovingAverages();
 
    double EstimateMedianVal(int confTarget, double sufficientTxVal,
                             double minSuccess, bool requireGreater, unsigned int nBlockHeight);
 
    unsigned int GetMaxConfirms() { return confAvg.size(); }
 
    void Write(CAutoFile& fileout);
 
    void Read(CAutoFile& filein);
};
 
 
 
static const unsigned int MAX_BLOCK_CONFIRMS = 25;
 
static const double DEFAULT_DECAY = .998;
 
static const double MIN_SUCCESS_PCT = .95;
static const double UNLIKELY_PCT = .5;
 
static const double SUFFICIENT_FEETXS = 1;
 
// Minimum and Maximum values for tracking feerates
static constexpr double MIN_FEERATE = 10;
static const double MAX_FEERATE = 1e7;
static const double INF_FEERATE = 1e16;
 
// We have to lump transactions into buckets based on feerate, but we want to be able
// to give accurate estimates over a large range of potential fees and priorities
// Therefore it makes sense to exponentially space the buckets
static const double FEE_SPACING = 1.1;
 
 
class CBlockPolicyEstimator
{
public:
    explicit CBlockPolicyEstimator(const CFeeRate& minRelayFee);
 
    void processBlock(unsigned int nBlockHeight,
                      std::vector<const CTxMemPoolEntry*>& entries);
 
    bool processBlockTx(unsigned int nBlockHeight, const CTxMemPoolEntry* entry);
 
    void processTransaction(const CTxMemPoolEntry& entry, bool validFeeEstimate);
 
    bool removeTx(const uint256& hash);
 
    CFeeRate estimateFee(int confTarget);
 
    CFeeRate estimateSmartFee(int confTarget, int *answerFoundAtTarget, const CTxMemPool& pool);
 
    void Write(CAutoFile& fileout);
 
    void Read(CAutoFile& filein, int nFileVersion);
 
private:
    CFeeRate minTrackedFee; 
    unsigned int nBestSeenHeight;
    struct TxStatsInfo
    {
        unsigned int blockHeight;
        unsigned int bucketIndex;
        TxStatsInfo() : blockHeight(0), bucketIndex(0) {}
    };
 
    // map of txids to information about that transaction
    std::map<uint256, TxStatsInfo> mapMemPoolTxs;
 
    TxConfirmStats feeStats;
 
    unsigned int trackedTxs;
    unsigned int untrackedTxs;
};
#endif // PIVX_POLICY_FEES_H