|
|
@ -71,231 +71,299 @@ int64_t UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParam |
|
|
|
return nNewTime - nOldTime; |
|
|
|
return nNewTime - nOldTime; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
CBlockTemplate* CreateNewBlock(const CChainParams& chainparams, const CScript& scriptPubKeyIn) |
|
|
|
BlockAssembler::BlockAssembler(const CChainParams& _chainparams) |
|
|
|
|
|
|
|
: chainparams(_chainparams) |
|
|
|
{ |
|
|
|
{ |
|
|
|
// Create new block
|
|
|
|
// Largest block you're willing to create:
|
|
|
|
std::unique_ptr<CBlockTemplate> pblocktemplate(new CBlockTemplate()); |
|
|
|
nBlockMaxSize = GetArg("-blockmaxsize", DEFAULT_BLOCK_MAX_SIZE); |
|
|
|
|
|
|
|
// Limit to between 1K and MAX_BLOCK_SIZE-1K for sanity:
|
|
|
|
|
|
|
|
nBlockMaxSize = std::max((unsigned int)1000, std::min((unsigned int)(MAX_BLOCK_SIZE-1000), nBlockMaxSize)); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Minimum block size you want to create; block will be filled with free transactions
|
|
|
|
|
|
|
|
// until there are no more or the block reaches this size:
|
|
|
|
|
|
|
|
nBlockMinSize = GetArg("-blockminsize", DEFAULT_BLOCK_MIN_SIZE); |
|
|
|
|
|
|
|
nBlockMinSize = std::min(nBlockMaxSize, nBlockMinSize); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void BlockAssembler::resetBlock() |
|
|
|
|
|
|
|
{ |
|
|
|
|
|
|
|
inBlock.clear(); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Reserve space for coinbase tx
|
|
|
|
|
|
|
|
nBlockSize = 1000; |
|
|
|
|
|
|
|
nBlockSigOps = 100; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// These counters do not include coinbase tx
|
|
|
|
|
|
|
|
nBlockTx = 0; |
|
|
|
|
|
|
|
nFees = 0; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
lastFewTxs = 0; |
|
|
|
|
|
|
|
blockFinished = false; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
CBlockTemplate* BlockAssembler::CreateNewBlock(const CScript& scriptPubKeyIn) |
|
|
|
|
|
|
|
{ |
|
|
|
|
|
|
|
resetBlock(); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
pblocktemplate.reset(new CBlockTemplate()); |
|
|
|
|
|
|
|
|
|
|
|
if(!pblocktemplate.get()) |
|
|
|
if(!pblocktemplate.get()) |
|
|
|
return NULL; |
|
|
|
return NULL; |
|
|
|
CBlock *pblock = &pblocktemplate->block; // pointer for convenience
|
|
|
|
pblock = &pblocktemplate->block; // pointer for convenience
|
|
|
|
|
|
|
|
|
|
|
|
// Create coinbase tx
|
|
|
|
|
|
|
|
CMutableTransaction txNew; |
|
|
|
|
|
|
|
txNew.vin.resize(1); |
|
|
|
|
|
|
|
txNew.vin[0].prevout.SetNull(); |
|
|
|
|
|
|
|
txNew.vout.resize(1); |
|
|
|
|
|
|
|
txNew.vout[0].scriptPubKey = scriptPubKeyIn; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Add dummy coinbase tx as first transaction
|
|
|
|
// Add dummy coinbase tx as first transaction
|
|
|
|
pblock->vtx.push_back(CTransaction()); |
|
|
|
pblock->vtx.push_back(CTransaction()); |
|
|
|
pblocktemplate->vTxFees.push_back(-1); // updated at end
|
|
|
|
pblocktemplate->vTxFees.push_back(-1); // updated at end
|
|
|
|
pblocktemplate->vTxSigOps.push_back(-1); // updated at end
|
|
|
|
pblocktemplate->vTxSigOps.push_back(-1); // updated at end
|
|
|
|
|
|
|
|
|
|
|
|
// Largest block you're willing to create:
|
|
|
|
LOCK2(cs_main, mempool.cs); |
|
|
|
unsigned int nBlockMaxSize = GetArg("-blockmaxsize", DEFAULT_BLOCK_MAX_SIZE); |
|
|
|
CBlockIndex* pindexPrev = chainActive.Tip(); |
|
|
|
// Limit to between 1K and MAX_BLOCK_SIZE-1K for sanity:
|
|
|
|
nHeight = pindexPrev->nHeight + 1; |
|
|
|
nBlockMaxSize = std::max((unsigned int)1000, std::min((unsigned int)(MAX_BLOCK_SIZE-1000), nBlockMaxSize)); |
|
|
|
|
|
|
|
|
|
|
|
pblock->nVersion = ComputeBlockVersion(pindexPrev, chainparams.GetConsensus()); |
|
|
|
|
|
|
|
// -regtest only: allow overriding block.nVersion with
|
|
|
|
|
|
|
|
// -blockversion=N to test forking scenarios
|
|
|
|
|
|
|
|
if (chainparams.MineBlocksOnDemand()) |
|
|
|
|
|
|
|
pblock->nVersion = GetArg("-blockversion", pblock->nVersion); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
pblock->nTime = GetAdjustedTime(); |
|
|
|
|
|
|
|
const int64_t nMedianTimePast = pindexPrev->GetMedianTimePast(); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
nLockTimeCutoff = (STANDARD_LOCKTIME_VERIFY_FLAGS & LOCKTIME_MEDIAN_TIME_PAST) |
|
|
|
|
|
|
|
? nMedianTimePast |
|
|
|
|
|
|
|
: pblock->GetBlockTime(); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
addPriorityTxs(); |
|
|
|
|
|
|
|
addScoreTxs(); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
nLastBlockTx = nBlockTx; |
|
|
|
|
|
|
|
nLastBlockSize = nBlockSize; |
|
|
|
|
|
|
|
LogPrintf("CreateNewBlock(): total size %u txs: %u fees: %ld sigops %d\n", nBlockSize, nBlockTx, nFees, nBlockSigOps); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Create coinbase transaction.
|
|
|
|
|
|
|
|
CMutableTransaction coinbaseTx; |
|
|
|
|
|
|
|
coinbaseTx.vin.resize(1); |
|
|
|
|
|
|
|
coinbaseTx.vin[0].prevout.SetNull(); |
|
|
|
|
|
|
|
coinbaseTx.vout.resize(1); |
|
|
|
|
|
|
|
coinbaseTx.vout[0].scriptPubKey = scriptPubKeyIn; |
|
|
|
|
|
|
|
coinbaseTx.vout[0].nValue = nFees + GetBlockSubsidy(nHeight, chainparams.GetConsensus()); |
|
|
|
|
|
|
|
coinbaseTx.vin[0].scriptSig = CScript() << nHeight << OP_0; |
|
|
|
|
|
|
|
pblock->vtx[0] = coinbaseTx; |
|
|
|
|
|
|
|
pblocktemplate->vTxFees[0] = -nFees; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Fill in header
|
|
|
|
|
|
|
|
pblock->hashPrevBlock = pindexPrev->GetBlockHash(); |
|
|
|
|
|
|
|
UpdateTime(pblock, chainparams.GetConsensus(), pindexPrev); |
|
|
|
|
|
|
|
pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, chainparams.GetConsensus()); |
|
|
|
|
|
|
|
pblock->nNonce = 0; |
|
|
|
|
|
|
|
pblocktemplate->vTxSigOps[0] = GetLegacySigOpCount(pblock->vtx[0]); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
CValidationState state; |
|
|
|
|
|
|
|
if (!TestBlockValidity(state, chainparams, *pblock, pindexPrev, false, false)) { |
|
|
|
|
|
|
|
throw std::runtime_error(strprintf("%s: TestBlockValidity failed: %s", __func__, FormatStateMessage(state))); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// How much of the block should be dedicated to high-priority transactions,
|
|
|
|
return pblocktemplate.release(); |
|
|
|
// included regardless of the fees they pay
|
|
|
|
} |
|
|
|
unsigned int nBlockPrioritySize = GetArg("-blockprioritysize", DEFAULT_BLOCK_PRIORITY_SIZE); |
|
|
|
|
|
|
|
nBlockPrioritySize = std::min(nBlockMaxSize, nBlockPrioritySize); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Minimum block size you want to create; block will be filled with free transactions
|
|
|
|
bool BlockAssembler::isStillDependent(CTxMemPool::txiter iter) |
|
|
|
// until there are no more or the block reaches this size:
|
|
|
|
{ |
|
|
|
unsigned int nBlockMinSize = GetArg("-blockminsize", DEFAULT_BLOCK_MIN_SIZE); |
|
|
|
BOOST_FOREACH(CTxMemPool::txiter parent, mempool.GetMemPoolParents(iter)) |
|
|
|
nBlockMinSize = std::min(nBlockMaxSize, nBlockMinSize); |
|
|
|
{ |
|
|
|
|
|
|
|
if (!inBlock.count(parent)) { |
|
|
|
|
|
|
|
return true; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
return false; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// Collect memory pool transactions into the block
|
|
|
|
|
|
|
|
CTxMemPool::setEntries inBlock; |
|
|
|
|
|
|
|
CTxMemPool::setEntries waitSet; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// This vector will be sorted into a priority queue:
|
|
|
|
|
|
|
|
vector<TxCoinAgePriority> vecPriority; |
|
|
|
|
|
|
|
TxCoinAgePriorityCompare pricomparer; |
|
|
|
|
|
|
|
std::map<CTxMemPool::txiter, double, CTxMemPool::CompareIteratorByHash> waitPriMap; |
|
|
|
|
|
|
|
typedef std::map<CTxMemPool::txiter, double, CTxMemPool::CompareIteratorByHash>::iterator waitPriIter; |
|
|
|
|
|
|
|
double actualPriority = -1; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
std::priority_queue<CTxMemPool::txiter, std::vector<CTxMemPool::txiter>, ScoreCompare> clearedTxs; |
|
|
|
bool BlockAssembler::TestForBlock(CTxMemPool::txiter iter) |
|
|
|
|
|
|
|
{ |
|
|
|
|
|
|
|
if (nBlockSize + iter->GetTxSize() >= nBlockMaxSize) { |
|
|
|
|
|
|
|
// If the block is so close to full that no more txs will fit
|
|
|
|
|
|
|
|
// or if we've tried more than 50 times to fill remaining space
|
|
|
|
|
|
|
|
// then flag that the block is finished
|
|
|
|
|
|
|
|
if (nBlockSize > nBlockMaxSize - 100 || lastFewTxs > 50) { |
|
|
|
|
|
|
|
blockFinished = true; |
|
|
|
|
|
|
|
return false; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
// Once we're within 1000 bytes of a full block, only look at 50 more txs
|
|
|
|
|
|
|
|
// to try to fill the remaining space.
|
|
|
|
|
|
|
|
if (nBlockSize > nBlockMaxSize - 1000) { |
|
|
|
|
|
|
|
lastFewTxs++; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
return false; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (nBlockSigOps + iter->GetSigOpCount() >= MAX_BLOCK_SIGOPS) { |
|
|
|
|
|
|
|
// If the block has room for no more sig ops then
|
|
|
|
|
|
|
|
// flag that the block is finished
|
|
|
|
|
|
|
|
if (nBlockSigOps > MAX_BLOCK_SIGOPS - 2) { |
|
|
|
|
|
|
|
blockFinished = true; |
|
|
|
|
|
|
|
return false; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
// Otherwise attempt to find another tx with fewer sigops
|
|
|
|
|
|
|
|
// to put in the block.
|
|
|
|
|
|
|
|
return false; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Must check that lock times are still valid
|
|
|
|
|
|
|
|
// This can be removed once MTP is always enforced
|
|
|
|
|
|
|
|
// as long as reorgs keep the mempool consistent.
|
|
|
|
|
|
|
|
if (!IsFinalTx(iter->GetTx(), nHeight, nLockTimeCutoff)) |
|
|
|
|
|
|
|
return false; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
return true; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void BlockAssembler::AddToBlock(CTxMemPool::txiter iter) |
|
|
|
|
|
|
|
{ |
|
|
|
|
|
|
|
pblock->vtx.push_back(iter->GetTx()); |
|
|
|
|
|
|
|
pblocktemplate->vTxFees.push_back(iter->GetFee()); |
|
|
|
|
|
|
|
pblocktemplate->vTxSigOps.push_back(iter->GetSigOpCount()); |
|
|
|
|
|
|
|
nBlockSize += iter->GetTxSize(); |
|
|
|
|
|
|
|
++nBlockTx; |
|
|
|
|
|
|
|
nBlockSigOps += iter->GetSigOpCount(); |
|
|
|
|
|
|
|
nFees += iter->GetFee(); |
|
|
|
|
|
|
|
inBlock.insert(iter); |
|
|
|
|
|
|
|
|
|
|
|
bool fPrintPriority = GetBoolArg("-printpriority", DEFAULT_PRINTPRIORITY); |
|
|
|
bool fPrintPriority = GetBoolArg("-printpriority", DEFAULT_PRINTPRIORITY); |
|
|
|
uint64_t nBlockSize = 1000; |
|
|
|
if (fPrintPriority) { |
|
|
|
uint64_t nBlockTx = 0; |
|
|
|
double dPriority = iter->GetPriority(nHeight); |
|
|
|
unsigned int nBlockSigOps = 100; |
|
|
|
CAmount dummy; |
|
|
|
int lastFewTxs = 0; |
|
|
|
mempool.ApplyDeltas(iter->GetTx().GetHash(), dPriority, dummy); |
|
|
|
CAmount nFees = 0; |
|
|
|
LogPrintf("priority %.1f fee %s txid %s\n", |
|
|
|
|
|
|
|
dPriority, |
|
|
|
|
|
|
|
CFeeRate(iter->GetModifiedFee(), iter->GetTxSize()).ToString(), |
|
|
|
|
|
|
|
iter->GetTx().GetHash().ToString()); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void BlockAssembler::addScoreTxs() |
|
|
|
|
|
|
|
{ |
|
|
|
|
|
|
|
std::priority_queue<CTxMemPool::txiter, std::vector<CTxMemPool::txiter>, ScoreCompare> clearedTxs; |
|
|
|
|
|
|
|
CTxMemPool::setEntries waitSet; |
|
|
|
|
|
|
|
CTxMemPool::indexed_transaction_set::index<mining_score>::type::iterator mi = mempool.mapTx.get<mining_score>().begin(); |
|
|
|
|
|
|
|
CTxMemPool::txiter iter; |
|
|
|
|
|
|
|
while (!blockFinished && (mi != mempool.mapTx.get<mining_score>().end() || !clearedTxs.empty())) |
|
|
|
{ |
|
|
|
{ |
|
|
|
LOCK2(cs_main, mempool.cs); |
|
|
|
// If no txs that were previously postponed are available to try
|
|
|
|
CBlockIndex* pindexPrev = chainActive.Tip(); |
|
|
|
// again, then try the next highest score tx
|
|
|
|
const int nHeight = pindexPrev->nHeight + 1; |
|
|
|
if (clearedTxs.empty()) { |
|
|
|
pblock->nTime = GetAdjustedTime(); |
|
|
|
iter = mempool.mapTx.project<0>(mi); |
|
|
|
const int64_t nMedianTimePast = pindexPrev->GetMedianTimePast(); |
|
|
|
mi++; |
|
|
|
|
|
|
|
} |
|
|
|
pblock->nVersion = ComputeBlockVersion(pindexPrev, chainparams.GetConsensus()); |
|
|
|
// If a previously postponed tx is available to try again, then it
|
|
|
|
// -regtest only: allow overriding block.nVersion with
|
|
|
|
// has higher score than all untried so far txs
|
|
|
|
// -blockversion=N to test forking scenarios
|
|
|
|
else { |
|
|
|
if (chainparams.MineBlocksOnDemand()) |
|
|
|
iter = clearedTxs.top(); |
|
|
|
pblock->nVersion = GetArg("-blockversion", pblock->nVersion); |
|
|
|
clearedTxs.pop(); |
|
|
|
|
|
|
|
|
|
|
|
int64_t nLockTimeCutoff = (STANDARD_LOCKTIME_VERIFY_FLAGS & LOCKTIME_MEDIAN_TIME_PAST) |
|
|
|
|
|
|
|
? nMedianTimePast |
|
|
|
|
|
|
|
: pblock->GetBlockTime(); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
bool fPriorityBlock = nBlockPrioritySize > 0; |
|
|
|
|
|
|
|
if (fPriorityBlock) { |
|
|
|
|
|
|
|
vecPriority.reserve(mempool.mapTx.size()); |
|
|
|
|
|
|
|
for (CTxMemPool::indexed_transaction_set::iterator mi = mempool.mapTx.begin(); |
|
|
|
|
|
|
|
mi != mempool.mapTx.end(); ++mi) |
|
|
|
|
|
|
|
{ |
|
|
|
|
|
|
|
double dPriority = mi->GetPriority(nHeight); |
|
|
|
|
|
|
|
CAmount dummy; |
|
|
|
|
|
|
|
mempool.ApplyDeltas(mi->GetTx().GetHash(), dPriority, dummy); |
|
|
|
|
|
|
|
vecPriority.push_back(TxCoinAgePriority(dPriority, mi)); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
std::make_heap(vecPriority.begin(), vecPriority.end(), pricomparer); |
|
|
|
|
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
CTxMemPool::indexed_transaction_set::index<mining_score>::type::iterator mi = mempool.mapTx.get<mining_score>().begin(); |
|
|
|
// If tx is dependent on other mempool txs which haven't yet been included
|
|
|
|
CTxMemPool::txiter iter; |
|
|
|
// then put it in the waitSet
|
|
|
|
|
|
|
|
if (isStillDependent(iter)) { |
|
|
|
while (mi != mempool.mapTx.get<mining_score>().end() || !clearedTxs.empty()) |
|
|
|
waitSet.insert(iter); |
|
|
|
{ |
|
|
|
continue; |
|
|
|
bool priorityTx = false; |
|
|
|
} |
|
|
|
if (fPriorityBlock && !vecPriority.empty()) { // add a tx from priority queue to fill the blockprioritysize
|
|
|
|
|
|
|
|
priorityTx = true; |
|
|
|
|
|
|
|
iter = vecPriority.front().second; |
|
|
|
|
|
|
|
actualPriority = vecPriority.front().first; |
|
|
|
|
|
|
|
std::pop_heap(vecPriority.begin(), vecPriority.end(), pricomparer); |
|
|
|
|
|
|
|
vecPriority.pop_back(); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
else if (clearedTxs.empty()) { // add tx with next highest score
|
|
|
|
|
|
|
|
iter = mempool.mapTx.project<0>(mi); |
|
|
|
|
|
|
|
mi++; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
else { // try to add a previously postponed child tx
|
|
|
|
|
|
|
|
iter = clearedTxs.top(); |
|
|
|
|
|
|
|
clearedTxs.pop(); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (inBlock.count(iter)) |
|
|
|
// If the fee rate is below the min fee rate for mining, then we're done
|
|
|
|
continue; // could have been added to the priorityBlock
|
|
|
|
// adding txs based on score (fee rate)
|
|
|
|
|
|
|
|
if (iter->GetModifiedFee() < ::minRelayTxFee.GetFee(iter->GetTxSize()) && nBlockSize >= nBlockMinSize) { |
|
|
|
|
|
|
|
return; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
const CTransaction& tx = iter->GetTx(); |
|
|
|
// If this tx fits in the block add it, otherwise keep looping
|
|
|
|
|
|
|
|
if (TestForBlock(iter)) { |
|
|
|
|
|
|
|
AddToBlock(iter); |
|
|
|
|
|
|
|
|
|
|
|
bool fOrphan = false; |
|
|
|
// This tx was successfully added, so
|
|
|
|
BOOST_FOREACH(CTxMemPool::txiter parent, mempool.GetMemPoolParents(iter)) |
|
|
|
// add transactions that depend on this one to the priority queue to try again
|
|
|
|
|
|
|
|
BOOST_FOREACH(CTxMemPool::txiter child, mempool.GetMemPoolChildren(iter)) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if (!inBlock.count(parent)) { |
|
|
|
if (waitSet.count(child)) { |
|
|
|
fOrphan = true; |
|
|
|
clearedTxs.push(child); |
|
|
|
break; |
|
|
|
waitSet.erase(child); |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
if (fOrphan) { |
|
|
|
} |
|
|
|
if (priorityTx) |
|
|
|
} |
|
|
|
waitPriMap.insert(std::make_pair(iter,actualPriority)); |
|
|
|
} |
|
|
|
else |
|
|
|
|
|
|
|
waitSet.insert(iter); |
|
|
|
|
|
|
|
continue; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
unsigned int nTxSize = iter->GetTxSize(); |
|
|
|
void BlockAssembler::addPriorityTxs() |
|
|
|
if (fPriorityBlock && |
|
|
|
{ |
|
|
|
(nBlockSize + nTxSize >= nBlockPrioritySize || !AllowFree(actualPriority))) { |
|
|
|
// How much of the block should be dedicated to high-priority transactions,
|
|
|
|
fPriorityBlock = false; |
|
|
|
// included regardless of the fees they pay
|
|
|
|
waitPriMap.clear(); |
|
|
|
unsigned int nBlockPrioritySize = GetArg("-blockprioritysize", DEFAULT_BLOCK_PRIORITY_SIZE); |
|
|
|
} |
|
|
|
nBlockPrioritySize = std::min(nBlockMaxSize, nBlockPrioritySize); |
|
|
|
if (!priorityTx && |
|
|
|
|
|
|
|
(iter->GetModifiedFee() < ::minRelayTxFee.GetFee(nTxSize) && nBlockSize >= nBlockMinSize)) { |
|
|
|
|
|
|
|
break; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
if (nBlockSize + nTxSize >= nBlockMaxSize) { |
|
|
|
|
|
|
|
if (nBlockSize > nBlockMaxSize - 100 || lastFewTxs > 50) { |
|
|
|
|
|
|
|
break; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
// Once we're within 1000 bytes of a full block, only look at 50 more txs
|
|
|
|
|
|
|
|
// to try to fill the remaining space.
|
|
|
|
|
|
|
|
if (nBlockSize > nBlockMaxSize - 1000) { |
|
|
|
|
|
|
|
lastFewTxs++; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
continue; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (!IsFinalTx(tx, nHeight, nLockTimeCutoff)) |
|
|
|
if (nBlockPrioritySize == 0) { |
|
|
|
continue; |
|
|
|
return; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
unsigned int nTxSigOps = iter->GetSigOpCount(); |
|
|
|
// This vector will be sorted into a priority queue:
|
|
|
|
if (nBlockSigOps + nTxSigOps >= MAX_BLOCK_SIGOPS) { |
|
|
|
vector<TxCoinAgePriority> vecPriority; |
|
|
|
if (nBlockSigOps > MAX_BLOCK_SIGOPS - 2) { |
|
|
|
TxCoinAgePriorityCompare pricomparer; |
|
|
|
break; |
|
|
|
std::map<CTxMemPool::txiter, double, CTxMemPool::CompareIteratorByHash> waitPriMap; |
|
|
|
} |
|
|
|
typedef std::map<CTxMemPool::txiter, double, CTxMemPool::CompareIteratorByHash>::iterator waitPriIter; |
|
|
|
continue; |
|
|
|
double actualPriority = -1; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
CAmount nTxFees = iter->GetFee(); |
|
|
|
vecPriority.reserve(mempool.mapTx.size()); |
|
|
|
// Added
|
|
|
|
for (CTxMemPool::indexed_transaction_set::iterator mi = mempool.mapTx.begin(); |
|
|
|
pblock->vtx.push_back(tx); |
|
|
|
mi != mempool.mapTx.end(); ++mi) |
|
|
|
pblocktemplate->vTxFees.push_back(nTxFees); |
|
|
|
{ |
|
|
|
pblocktemplate->vTxSigOps.push_back(nTxSigOps); |
|
|
|
double dPriority = mi->GetPriority(nHeight); |
|
|
|
nBlockSize += nTxSize; |
|
|
|
CAmount dummy; |
|
|
|
++nBlockTx; |
|
|
|
mempool.ApplyDeltas(mi->GetTx().GetHash(), dPriority, dummy); |
|
|
|
nBlockSigOps += nTxSigOps; |
|
|
|
vecPriority.push_back(TxCoinAgePriority(dPriority, mi)); |
|
|
|
nFees += nTxFees; |
|
|
|
} |
|
|
|
|
|
|
|
std::make_heap(vecPriority.begin(), vecPriority.end(), pricomparer); |
|
|
|
if (fPrintPriority) |
|
|
|
|
|
|
|
{ |
|
|
|
CTxMemPool::txiter iter; |
|
|
|
double dPriority = iter->GetPriority(nHeight); |
|
|
|
while (!vecPriority.empty() && !blockFinished) { // add a tx from priority queue to fill the blockprioritysize
|
|
|
|
CAmount dummy; |
|
|
|
iter = vecPriority.front().second; |
|
|
|
mempool.ApplyDeltas(tx.GetHash(), dPriority, dummy); |
|
|
|
actualPriority = vecPriority.front().first; |
|
|
|
LogPrintf("priority %.1f fee %s txid %s\n", |
|
|
|
std::pop_heap(vecPriority.begin(), vecPriority.end(), pricomparer); |
|
|
|
dPriority , CFeeRate(iter->GetModifiedFee(), nTxSize).ToString(), tx.GetHash().ToString()); |
|
|
|
vecPriority.pop_back(); |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// If tx already in block, skip
|
|
|
|
|
|
|
|
if (inBlock.count(iter)) { |
|
|
|
|
|
|
|
assert(false); // shouldn't happen for priority txs
|
|
|
|
|
|
|
|
continue; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// If tx is dependent on other mempool txs which haven't yet been included
|
|
|
|
|
|
|
|
// then put it in the waitSet
|
|
|
|
|
|
|
|
if (isStillDependent(iter)) { |
|
|
|
|
|
|
|
waitPriMap.insert(std::make_pair(iter, actualPriority)); |
|
|
|
|
|
|
|
continue; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
inBlock.insert(iter); |
|
|
|
// If this tx fits in the block add it, otherwise keep looping
|
|
|
|
|
|
|
|
if (TestForBlock(iter)) { |
|
|
|
|
|
|
|
AddToBlock(iter); |
|
|
|
|
|
|
|
|
|
|
|
// Add transactions that depend on this one to the priority queue
|
|
|
|
// If now that this txs is added we've surpassed our desired priority size
|
|
|
|
|
|
|
|
// or have dropped below the AllowFreeThreshold, then we're done adding priority txs
|
|
|
|
|
|
|
|
if (nBlockSize + iter->GetTxSize() >= nBlockPrioritySize || !AllowFree(actualPriority)) { |
|
|
|
|
|
|
|
return; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// This tx was successfully added, so
|
|
|
|
|
|
|
|
// add transactions that depend on this one to the priority queue to try again
|
|
|
|
BOOST_FOREACH(CTxMemPool::txiter child, mempool.GetMemPoolChildren(iter)) |
|
|
|
BOOST_FOREACH(CTxMemPool::txiter child, mempool.GetMemPoolChildren(iter)) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if (fPriorityBlock) { |
|
|
|
waitPriIter wpiter = waitPriMap.find(child); |
|
|
|
waitPriIter wpiter = waitPriMap.find(child); |
|
|
|
if (wpiter != waitPriMap.end()) { |
|
|
|
if (wpiter != waitPriMap.end()) { |
|
|
|
vecPriority.push_back(TxCoinAgePriority(wpiter->second,child)); |
|
|
|
vecPriority.push_back(TxCoinAgePriority(wpiter->second,child)); |
|
|
|
std::push_heap(vecPriority.begin(), vecPriority.end(), pricomparer); |
|
|
|
std::push_heap(vecPriority.begin(), vecPriority.end(), pricomparer); |
|
|
|
waitPriMap.erase(wpiter); |
|
|
|
waitPriMap.erase(wpiter); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
else { |
|
|
|
|
|
|
|
if (waitSet.count(child)) { |
|
|
|
|
|
|
|
clearedTxs.push(child); |
|
|
|
|
|
|
|
waitSet.erase(child); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
nLastBlockTx = nBlockTx; |
|
|
|
|
|
|
|
nLastBlockSize = nBlockSize; |
|
|
|
|
|
|
|
LogPrintf("CreateNewBlock(): total size %u txs: %u fees: %ld sigops %d\n", nBlockSize, nBlockTx, nFees, nBlockSigOps); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Compute final coinbase transaction.
|
|
|
|
|
|
|
|
txNew.vout[0].nValue = nFees + GetBlockSubsidy(nHeight, chainparams.GetConsensus()); |
|
|
|
|
|
|
|
txNew.vin[0].scriptSig = CScript() << nHeight << OP_0; |
|
|
|
|
|
|
|
pblock->vtx[0] = txNew; |
|
|
|
|
|
|
|
pblocktemplate->vTxFees[0] = -nFees; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Fill in header
|
|
|
|
|
|
|
|
pblock->hashPrevBlock = pindexPrev->GetBlockHash(); |
|
|
|
|
|
|
|
UpdateTime(pblock, chainparams.GetConsensus(), pindexPrev); |
|
|
|
|
|
|
|
pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, chainparams.GetConsensus()); |
|
|
|
|
|
|
|
pblock->nNonce = 0; |
|
|
|
|
|
|
|
pblocktemplate->vTxSigOps[0] = GetLegacySigOpCount(pblock->vtx[0]); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
CValidationState state; |
|
|
|
|
|
|
|
if (!TestBlockValidity(state, chainparams, *pblock, pindexPrev, false, false)) { |
|
|
|
|
|
|
|
throw std::runtime_error(strprintf("%s: TestBlockValidity failed: %s", __func__, FormatStateMessage(state))); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
return pblocktemplate.release(); |
|
|
|
|
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
void IncrementExtraNonce(CBlock* pblock, const CBlockIndex* pindexPrev, unsigned int& nExtraNonce) |
|
|
|
void IncrementExtraNonce(CBlock* pblock, const CBlockIndex* pindexPrev, unsigned int& nExtraNonce) |
|
|
|