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 BITCOIN_POLICYESTIMATOR_H
#define BITCOIN_POLICYESTIMATOR_H

#include "amount.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 (both fee buckets and priority buckets)
    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

    // For 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 theses 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 priority/fee 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 fee/priority per bucket

    std::string dataTypeString;
    double decay;

    // 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, std::string dataTypeString);

    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;

static const double SUFFICIENT_PRITXS = .2;

// Minimum and Maximum values for tracking fees and priorities
static const double MIN_FEERATE = 10;
static const double MAX_FEERATE = 1e7;
static const double INF_FEERATE = MAX_MONEY;
static const double MIN_PRIORITY = 10;
static const double MAX_PRIORITY = 1e16;
static const double INF_PRIORITY = 1e9 * MAX_MONEY;

// We have to lump transactions into buckets based on fee or priority, 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;

static const double PRI_SPACING = 2;

class CBlockPolicyEstimator
{
public:
    CBlockPolicyEstimator(const CFeeRate& minRelayFee);

    void processBlock(unsigned int nBlockHeight,
                      std::vector<CTxMemPoolEntry>& entries, bool fCurrentEstimate);

    void processBlockTx(unsigned int nBlockHeight, const CTxMemPoolEntry& entry);

    void processTransaction(const CTxMemPoolEntry& entry, bool fCurrentEstimate);

    void removeTx(uint256 hash);

    bool isFeeDataPoint(const CFeeRate &fee, double pri);

    bool isPriDataPoint(const CFeeRate &fee, double pri);

    CFeeRate estimateFee(int confTarget);

    CFeeRate estimateSmartFee(int confTarget, int *answerFoundAtTarget, const CTxMemPool& pool);

    double estimatePriority(int confTarget);

    double estimateSmartPriority(int confTarget, int *answerFoundAtTarget, const CTxMemPool& pool);

    void Write(CAutoFile& fileout);

    void Read(CAutoFile& filein);

private:
    CFeeRate minTrackedFee; 
    double minTrackedPriority; 
    unsigned int nBestSeenHeight;
    struct TxStatsInfo
    {
        TxConfirmStats *stats;
        unsigned int blockHeight;
        unsigned int bucketIndex;
        TxStatsInfo() : stats(NULL), blockHeight(0), bucketIndex(0) {}
    };

    // map of txids to information about that transaction
    std::map<uint256, TxStatsInfo> mapMemPoolTxs;

    TxConfirmStats feeStats, priStats;

    CFeeRate feeLikely, feeUnlikely;
    double priLikely, priUnlikely;
};
#endif /*BITCOIN_POLICYESTIMATOR_H */