b649e03954
This class groups transactions that have been confirmed in blocks into buckets, based on either their fee or their priority. Then for each bucket, the class calculates what percentage of the transactions were confirmed within various numbers of blocks. It does this by keeping an exponentially decaying moving history for each bucket and confirm block count of the percentage of transactions in that bucket that were confirmed within that number of blocks. -Eliminate txs which didn't have all inputs available at entry from fee/pri calcs -Add dynamic breakpoints and tracking of confirmation delays in mempool transactions -Remove old CMinerPolicyEstimator and CBlockAverage code -New smartfees.py -Pass a flag to the estimation code, using IsInitialBlockDownload as a proxy for when we are still catching up and we shouldn't be counting how many blocks it takes for transactions to be included. -Add a policyestimator unit test
420 lines
14 KiB
C++
420 lines
14 KiB
C++
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|
// Copyright (c) 2009-2014 The Bitcoin Core developers
|
|
// Distributed under the MIT software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include "txmempool.h"
|
|
|
|
#include "clientversion.h"
|
|
#include "main.h"
|
|
#include "policy/fees.h"
|
|
#include "streams.h"
|
|
#include "util.h"
|
|
#include "utilmoneystr.h"
|
|
#include "version.h"
|
|
|
|
using namespace std;
|
|
|
|
CTxMemPoolEntry::CTxMemPoolEntry():
|
|
nFee(0), nTxSize(0), nModSize(0), nTime(0), dPriority(0.0), hadNoDependencies(false)
|
|
{
|
|
nHeight = MEMPOOL_HEIGHT;
|
|
}
|
|
|
|
CTxMemPoolEntry::CTxMemPoolEntry(const CTransaction& _tx, const CAmount& _nFee,
|
|
int64_t _nTime, double _dPriority,
|
|
unsigned int _nHeight, bool poolHasNoInputsOf):
|
|
tx(_tx), nFee(_nFee), nTime(_nTime), dPriority(_dPriority), nHeight(_nHeight),
|
|
hadNoDependencies(poolHasNoInputsOf)
|
|
{
|
|
nTxSize = ::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION);
|
|
nModSize = tx.CalculateModifiedSize(nTxSize);
|
|
}
|
|
|
|
CTxMemPoolEntry::CTxMemPoolEntry(const CTxMemPoolEntry& other)
|
|
{
|
|
*this = other;
|
|
}
|
|
|
|
double
|
|
CTxMemPoolEntry::GetPriority(unsigned int currentHeight) const
|
|
{
|
|
CAmount nValueIn = tx.GetValueOut()+nFee;
|
|
double deltaPriority = ((double)(currentHeight-nHeight)*nValueIn)/nModSize;
|
|
double dResult = dPriority + deltaPriority;
|
|
return dResult;
|
|
}
|
|
|
|
CTxMemPool::CTxMemPool(const CFeeRate& _minRelayFee) :
|
|
nTransactionsUpdated(0)
|
|
{
|
|
// Sanity checks off by default for performance, because otherwise
|
|
// accepting transactions becomes O(N^2) where N is the number
|
|
// of transactions in the pool
|
|
fSanityCheck = false;
|
|
|
|
minerPolicyEstimator = new CBlockPolicyEstimator(_minRelayFee);
|
|
}
|
|
|
|
CTxMemPool::~CTxMemPool()
|
|
{
|
|
delete minerPolicyEstimator;
|
|
}
|
|
|
|
void CTxMemPool::pruneSpent(const uint256 &hashTx, CCoins &coins)
|
|
{
|
|
LOCK(cs);
|
|
|
|
std::map<COutPoint, CInPoint>::iterator it = mapNextTx.lower_bound(COutPoint(hashTx, 0));
|
|
|
|
// iterate over all COutPoints in mapNextTx whose hash equals the provided hashTx
|
|
while (it != mapNextTx.end() && it->first.hash == hashTx) {
|
|
coins.Spend(it->first.n); // and remove those outputs from coins
|
|
it++;
|
|
}
|
|
}
|
|
|
|
unsigned int CTxMemPool::GetTransactionsUpdated() const
|
|
{
|
|
LOCK(cs);
|
|
return nTransactionsUpdated;
|
|
}
|
|
|
|
void CTxMemPool::AddTransactionsUpdated(unsigned int n)
|
|
{
|
|
LOCK(cs);
|
|
nTransactionsUpdated += n;
|
|
}
|
|
|
|
|
|
bool CTxMemPool::addUnchecked(const uint256& hash, const CTxMemPoolEntry &entry, bool fCurrentEstimate)
|
|
{
|
|
// Add to memory pool without checking anything.
|
|
// Used by main.cpp AcceptToMemoryPool(), which DOES do
|
|
// all the appropriate checks.
|
|
LOCK(cs);
|
|
mapTx[hash] = entry;
|
|
const CTransaction& tx = mapTx[hash].GetTx();
|
|
for (unsigned int i = 0; i < tx.vin.size(); i++)
|
|
mapNextTx[tx.vin[i].prevout] = CInPoint(&tx, i);
|
|
nTransactionsUpdated++;
|
|
totalTxSize += entry.GetTxSize();
|
|
minerPolicyEstimator->processTransaction(entry, fCurrentEstimate);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void CTxMemPool::remove(const CTransaction &origTx, std::list<CTransaction>& removed, bool fRecursive)
|
|
{
|
|
// Remove transaction from memory pool
|
|
{
|
|
LOCK(cs);
|
|
std::deque<uint256> txToRemove;
|
|
txToRemove.push_back(origTx.GetHash());
|
|
if (fRecursive && !mapTx.count(origTx.GetHash())) {
|
|
// If recursively removing but origTx isn't in the mempool
|
|
// be sure to remove any children that are in the pool. This can
|
|
// happen during chain re-orgs if origTx isn't re-accepted into
|
|
// the mempool for any reason.
|
|
for (unsigned int i = 0; i < origTx.vout.size(); i++) {
|
|
std::map<COutPoint, CInPoint>::iterator it = mapNextTx.find(COutPoint(origTx.GetHash(), i));
|
|
if (it == mapNextTx.end())
|
|
continue;
|
|
txToRemove.push_back(it->second.ptx->GetHash());
|
|
}
|
|
}
|
|
while (!txToRemove.empty())
|
|
{
|
|
uint256 hash = txToRemove.front();
|
|
txToRemove.pop_front();
|
|
if (!mapTx.count(hash))
|
|
continue;
|
|
const CTransaction& tx = mapTx[hash].GetTx();
|
|
if (fRecursive) {
|
|
for (unsigned int i = 0; i < tx.vout.size(); i++) {
|
|
std::map<COutPoint, CInPoint>::iterator it = mapNextTx.find(COutPoint(hash, i));
|
|
if (it == mapNextTx.end())
|
|
continue;
|
|
txToRemove.push_back(it->second.ptx->GetHash());
|
|
}
|
|
}
|
|
BOOST_FOREACH(const CTxIn& txin, tx.vin)
|
|
mapNextTx.erase(txin.prevout);
|
|
|
|
removed.push_back(tx);
|
|
totalTxSize -= mapTx[hash].GetTxSize();
|
|
mapTx.erase(hash);
|
|
nTransactionsUpdated++;
|
|
minerPolicyEstimator->removeTx(hash);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CTxMemPool::removeCoinbaseSpends(const CCoinsViewCache *pcoins, unsigned int nMemPoolHeight)
|
|
{
|
|
// Remove transactions spending a coinbase which are now immature
|
|
LOCK(cs);
|
|
list<CTransaction> transactionsToRemove;
|
|
for (std::map<uint256, CTxMemPoolEntry>::const_iterator it = mapTx.begin(); it != mapTx.end(); it++) {
|
|
const CTransaction& tx = it->second.GetTx();
|
|
BOOST_FOREACH(const CTxIn& txin, tx.vin) {
|
|
std::map<uint256, CTxMemPoolEntry>::const_iterator it2 = mapTx.find(txin.prevout.hash);
|
|
if (it2 != mapTx.end())
|
|
continue;
|
|
const CCoins *coins = pcoins->AccessCoins(txin.prevout.hash);
|
|
if (fSanityCheck) assert(coins);
|
|
if (!coins || (coins->IsCoinBase() && nMemPoolHeight - coins->nHeight < COINBASE_MATURITY)) {
|
|
transactionsToRemove.push_back(tx);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
BOOST_FOREACH(const CTransaction& tx, transactionsToRemove) {
|
|
list<CTransaction> removed;
|
|
remove(tx, removed, true);
|
|
}
|
|
}
|
|
|
|
void CTxMemPool::removeConflicts(const CTransaction &tx, std::list<CTransaction>& removed)
|
|
{
|
|
// Remove transactions which depend on inputs of tx, recursively
|
|
list<CTransaction> result;
|
|
LOCK(cs);
|
|
BOOST_FOREACH(const CTxIn &txin, tx.vin) {
|
|
std::map<COutPoint, CInPoint>::iterator it = mapNextTx.find(txin.prevout);
|
|
if (it != mapNextTx.end()) {
|
|
const CTransaction &txConflict = *it->second.ptx;
|
|
if (txConflict != tx)
|
|
{
|
|
remove(txConflict, removed, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Called when a block is connected. Removes from mempool and updates the miner fee estimator.
|
|
*/
|
|
void CTxMemPool::removeForBlock(const std::vector<CTransaction>& vtx, unsigned int nBlockHeight,
|
|
std::list<CTransaction>& conflicts, bool fCurrentEstimate)
|
|
{
|
|
LOCK(cs);
|
|
std::vector<CTxMemPoolEntry> entries;
|
|
BOOST_FOREACH(const CTransaction& tx, vtx)
|
|
{
|
|
uint256 hash = tx.GetHash();
|
|
if (mapTx.count(hash))
|
|
entries.push_back(mapTx[hash]);
|
|
}
|
|
BOOST_FOREACH(const CTransaction& tx, vtx)
|
|
{
|
|
std::list<CTransaction> dummy;
|
|
remove(tx, dummy, false);
|
|
removeConflicts(tx, conflicts);
|
|
ClearPrioritisation(tx.GetHash());
|
|
}
|
|
// After the txs in the new block have been removed from the mempool, update policy estimates
|
|
minerPolicyEstimator->processBlock(nBlockHeight, entries, fCurrentEstimate);
|
|
}
|
|
|
|
void CTxMemPool::clear()
|
|
{
|
|
LOCK(cs);
|
|
mapTx.clear();
|
|
mapNextTx.clear();
|
|
totalTxSize = 0;
|
|
++nTransactionsUpdated;
|
|
}
|
|
|
|
void CTxMemPool::check(const CCoinsViewCache *pcoins) const
|
|
{
|
|
if (!fSanityCheck)
|
|
return;
|
|
|
|
LogPrint("mempool", "Checking mempool with %u transactions and %u inputs\n", (unsigned int)mapTx.size(), (unsigned int)mapNextTx.size());
|
|
|
|
uint64_t checkTotal = 0;
|
|
|
|
CCoinsViewCache mempoolDuplicate(const_cast<CCoinsViewCache*>(pcoins));
|
|
|
|
LOCK(cs);
|
|
list<const CTxMemPoolEntry*> waitingOnDependants;
|
|
for (std::map<uint256, CTxMemPoolEntry>::const_iterator it = mapTx.begin(); it != mapTx.end(); it++) {
|
|
unsigned int i = 0;
|
|
checkTotal += it->second.GetTxSize();
|
|
const CTransaction& tx = it->second.GetTx();
|
|
bool fDependsWait = false;
|
|
BOOST_FOREACH(const CTxIn &txin, tx.vin) {
|
|
// Check that every mempool transaction's inputs refer to available coins, or other mempool tx's.
|
|
std::map<uint256, CTxMemPoolEntry>::const_iterator it2 = mapTx.find(txin.prevout.hash);
|
|
if (it2 != mapTx.end()) {
|
|
const CTransaction& tx2 = it2->second.GetTx();
|
|
assert(tx2.vout.size() > txin.prevout.n && !tx2.vout[txin.prevout.n].IsNull());
|
|
fDependsWait = true;
|
|
} else {
|
|
const CCoins* coins = pcoins->AccessCoins(txin.prevout.hash);
|
|
assert(coins && coins->IsAvailable(txin.prevout.n));
|
|
}
|
|
// Check whether its inputs are marked in mapNextTx.
|
|
std::map<COutPoint, CInPoint>::const_iterator it3 = mapNextTx.find(txin.prevout);
|
|
assert(it3 != mapNextTx.end());
|
|
assert(it3->second.ptx == &tx);
|
|
assert(it3->second.n == i);
|
|
i++;
|
|
}
|
|
if (fDependsWait)
|
|
waitingOnDependants.push_back(&it->second);
|
|
else {
|
|
CValidationState state;
|
|
assert(CheckInputs(tx, state, mempoolDuplicate, false, 0, false, NULL));
|
|
UpdateCoins(tx, state, mempoolDuplicate, 1000000);
|
|
}
|
|
}
|
|
unsigned int stepsSinceLastRemove = 0;
|
|
while (!waitingOnDependants.empty()) {
|
|
const CTxMemPoolEntry* entry = waitingOnDependants.front();
|
|
waitingOnDependants.pop_front();
|
|
CValidationState state;
|
|
if (!mempoolDuplicate.HaveInputs(entry->GetTx())) {
|
|
waitingOnDependants.push_back(entry);
|
|
stepsSinceLastRemove++;
|
|
assert(stepsSinceLastRemove < waitingOnDependants.size());
|
|
} else {
|
|
assert(CheckInputs(entry->GetTx(), state, mempoolDuplicate, false, 0, false, NULL));
|
|
UpdateCoins(entry->GetTx(), state, mempoolDuplicate, 1000000);
|
|
stepsSinceLastRemove = 0;
|
|
}
|
|
}
|
|
for (std::map<COutPoint, CInPoint>::const_iterator it = mapNextTx.begin(); it != mapNextTx.end(); it++) {
|
|
uint256 hash = it->second.ptx->GetHash();
|
|
map<uint256, CTxMemPoolEntry>::const_iterator it2 = mapTx.find(hash);
|
|
const CTransaction& tx = it2->second.GetTx();
|
|
assert(it2 != mapTx.end());
|
|
assert(&tx == it->second.ptx);
|
|
assert(tx.vin.size() > it->second.n);
|
|
assert(it->first == it->second.ptx->vin[it->second.n].prevout);
|
|
}
|
|
|
|
assert(totalTxSize == checkTotal);
|
|
}
|
|
|
|
void CTxMemPool::queryHashes(vector<uint256>& vtxid)
|
|
{
|
|
vtxid.clear();
|
|
|
|
LOCK(cs);
|
|
vtxid.reserve(mapTx.size());
|
|
for (map<uint256, CTxMemPoolEntry>::iterator mi = mapTx.begin(); mi != mapTx.end(); ++mi)
|
|
vtxid.push_back((*mi).first);
|
|
}
|
|
|
|
bool CTxMemPool::lookup(uint256 hash, CTransaction& result) const
|
|
{
|
|
LOCK(cs);
|
|
map<uint256, CTxMemPoolEntry>::const_iterator i = mapTx.find(hash);
|
|
if (i == mapTx.end()) return false;
|
|
result = i->second.GetTx();
|
|
return true;
|
|
}
|
|
|
|
CFeeRate CTxMemPool::estimateFee(int nBlocks) const
|
|
{
|
|
LOCK(cs);
|
|
return minerPolicyEstimator->estimateFee(nBlocks);
|
|
}
|
|
double CTxMemPool::estimatePriority(int nBlocks) const
|
|
{
|
|
LOCK(cs);
|
|
return minerPolicyEstimator->estimatePriority(nBlocks);
|
|
}
|
|
|
|
bool
|
|
CTxMemPool::WriteFeeEstimates(CAutoFile& fileout) const
|
|
{
|
|
try {
|
|
LOCK(cs);
|
|
fileout << 109900; // version required to read: 0.10.99 or later
|
|
fileout << CLIENT_VERSION; // version that wrote the file
|
|
minerPolicyEstimator->Write(fileout);
|
|
}
|
|
catch (const std::exception&) {
|
|
LogPrintf("CTxMemPool::WriteFeeEstimates(): unable to write policy estimator data (non-fatal)");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
CTxMemPool::ReadFeeEstimates(CAutoFile& filein)
|
|
{
|
|
try {
|
|
int nVersionRequired, nVersionThatWrote;
|
|
filein >> nVersionRequired >> nVersionThatWrote;
|
|
if (nVersionRequired > CLIENT_VERSION)
|
|
return error("CTxMemPool::ReadFeeEstimates(): up-version (%d) fee estimate file", nVersionRequired);
|
|
|
|
LOCK(cs);
|
|
minerPolicyEstimator->Read(filein);
|
|
}
|
|
catch (const std::exception&) {
|
|
LogPrintf("CTxMemPool::ReadFeeEstimates(): unable to read policy estimator data (non-fatal)");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void CTxMemPool::PrioritiseTransaction(const uint256 hash, const string strHash, double dPriorityDelta, const CAmount& nFeeDelta)
|
|
{
|
|
{
|
|
LOCK(cs);
|
|
std::pair<double, CAmount> &deltas = mapDeltas[hash];
|
|
deltas.first += dPriorityDelta;
|
|
deltas.second += nFeeDelta;
|
|
}
|
|
LogPrintf("PrioritiseTransaction: %s priority += %f, fee += %d\n", strHash, dPriorityDelta, FormatMoney(nFeeDelta));
|
|
}
|
|
|
|
void CTxMemPool::ApplyDeltas(const uint256 hash, double &dPriorityDelta, CAmount &nFeeDelta)
|
|
{
|
|
LOCK(cs);
|
|
std::map<uint256, std::pair<double, CAmount> >::iterator pos = mapDeltas.find(hash);
|
|
if (pos == mapDeltas.end())
|
|
return;
|
|
const std::pair<double, CAmount> &deltas = pos->second;
|
|
dPriorityDelta += deltas.first;
|
|
nFeeDelta += deltas.second;
|
|
}
|
|
|
|
void CTxMemPool::ClearPrioritisation(const uint256 hash)
|
|
{
|
|
LOCK(cs);
|
|
mapDeltas.erase(hash);
|
|
}
|
|
|
|
bool CTxMemPool::HasNoInputsOf(const CTransaction &tx) const
|
|
{
|
|
for (unsigned int i = 0; i < tx.vin.size(); i++)
|
|
if (exists(tx.vin[i].prevout.hash))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
CCoinsViewMemPool::CCoinsViewMemPool(CCoinsView *baseIn, CTxMemPool &mempoolIn) : CCoinsViewBacked(baseIn), mempool(mempoolIn) { }
|
|
|
|
bool CCoinsViewMemPool::GetCoins(const uint256 &txid, CCoins &coins) const {
|
|
// If an entry in the mempool exists, always return that one, as it's guaranteed to never
|
|
// conflict with the underlying cache, and it cannot have pruned entries (as it contains full)
|
|
// transactions. First checking the underlying cache risks returning a pruned entry instead.
|
|
CTransaction tx;
|
|
if (mempool.lookup(txid, tx)) {
|
|
coins = CCoins(tx, MEMPOOL_HEIGHT);
|
|
return true;
|
|
}
|
|
return (base->GetCoins(txid, coins) && !coins.IsPruned());
|
|
}
|
|
|
|
bool CCoinsViewMemPool::HaveCoins(const uint256 &txid) const {
|
|
return mempool.exists(txid) || base->HaveCoins(txid);
|
|
}
|