diff --git a/src/node/miner.cpp b/src/node/miner.cpp index 16ac9f200..d6ae39ed8 100644 --- a/src/node/miner.cpp +++ b/src/node/miner.cpp @@ -1,573 +1,445 @@ // Copyright (c) 2009-2010 Satoshi Nakamoto // Copyright (c) 2009-2019 The Bitcoin Core developers +// Copyright (c) 2020-2021 The Bitcoin developers // Distributed under the MIT software license, see the accompanying // file COPYING or http://www.opensource.org/licenses/mit-license.php. #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include +#include +#include #include namespace node { int64_t UpdateTime(CBlockHeader *pblock, const CChainParams &chainParams, const CBlockIndex *pindexPrev) { int64_t nOldTime = pblock->nTime; int64_t nNewTime = std::max(pindexPrev->GetMedianTimePast() + 1, GetAdjustedTime()); if (nOldTime < nNewTime) { pblock->nTime = nNewTime; } // Updating time can change work required on testnet: if (chainParams.GetConsensus().fPowAllowMinDifficultyBlocks) { pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, chainParams); } return nNewTime - nOldTime; } -uint64_t CTxMemPoolModifiedEntry::GetVirtualSizeWithAncestors() const { - return GetVirtualTransactionSize(nSizeWithAncestors, - nSigChecksWithAncestors); -} - BlockAssembler::Options::Options() : nExcessiveBlockSize(DEFAULT_MAX_BLOCK_SIZE), nMaxGeneratedBlockSize(DEFAULT_MAX_GENERATED_BLOCK_SIZE), blockMinFeeRate(DEFAULT_BLOCK_MIN_TX_FEE_PER_KB) {} BlockAssembler::BlockAssembler(CChainState &chainstate, const CChainParams ¶ms, const CTxMemPool &mempool, const Options &options) : chainParams(params), m_mempool(mempool), m_chainstate(chainstate) { blockMinFeeRate = options.blockMinFeeRate; // Limit size to between 1K and options.nExcessiveBlockSize -1K for sanity: nMaxGeneratedBlockSize = std::max( 1000, std::min(options.nExcessiveBlockSize - 1000, options.nMaxGeneratedBlockSize)); // Calculate the max consensus sigchecks for this block. auto nMaxBlockSigChecks = GetMaxBlockSigChecksCount(nMaxGeneratedBlockSize); // Allow the full amount of signature check operations in lieu of a separate // config option. (We are mining relayed transactions with validity cached // by everyone else, and so the block will propagate quickly, regardless of // how many sigchecks it contains.) nMaxGeneratedBlockSigChecks = nMaxBlockSigChecks; } static BlockAssembler::Options DefaultOptions(const Config &config) { // Block resource limits // If -blockmaxsize is not given, limit to DEFAULT_MAX_GENERATED_BLOCK_SIZE // If only one is given, only restrict the specified resource. // If both are given, restrict both. BlockAssembler::Options options; options.nExcessiveBlockSize = config.GetMaxBlockSize(); if (gArgs.IsArgSet("-blockmaxsize")) { options.nMaxGeneratedBlockSize = gArgs.GetIntArg("-blockmaxsize", DEFAULT_MAX_GENERATED_BLOCK_SIZE); } Amount n = Amount::zero(); if (gArgs.IsArgSet("-blockmintxfee") && ParseMoney(gArgs.GetArg("-blockmintxfee", ""), n)) { options.blockMinFeeRate = CFeeRate(n); } return options; } BlockAssembler::BlockAssembler(const Config &config, CChainState &chainstate, const CTxMemPool &mempool) : BlockAssembler(chainstate, config.GetChainParams(), mempool, DefaultOptions(config)) {} void BlockAssembler::resetBlock() { - inBlock.clear(); - // Reserve space for coinbase tx. nBlockSize = 1000; nBlockSigChecks = 100; // These counters do not include coinbase tx. nBlockTx = 0; nFees = Amount::zero(); } std::optional BlockAssembler::m_last_block_num_txs{std::nullopt}; std::optional BlockAssembler::m_last_block_size{std::nullopt}; std::unique_ptr BlockAssembler::CreateNewBlock(const CScript &scriptPubKeyIn) { int64_t nTimeStart = GetTimeMicros(); resetBlock(); pblocktemplate.reset(new CBlockTemplate()); if (!pblocktemplate.get()) { return nullptr; } // Pointer for convenience. CBlock *const pblock = &pblocktemplate->block; // Add dummy coinbase tx as first transaction. It is updated at the end. pblocktemplate->entries.emplace_back(CTransactionRef(), -SATOSHI, -1); LOCK2(cs_main, m_mempool.cs); CBlockIndex *pindexPrev = m_chainstate.m_chain.Tip(); assert(pindexPrev != nullptr); nHeight = pindexPrev->nHeight + 1; const Consensus::Params &consensusParams = chainParams.GetConsensus(); pblock->nVersion = g_versionbitscache.ComputeBlockVersion(pindexPrev, consensusParams); // -regtest only: allow overriding block.nVersion with // -blockversion=N to test forking scenarios if (chainParams.MineBlocksOnDemand()) { pblock->nVersion = gArgs.GetIntArg("-blockversion", pblock->nVersion); } pblock->nTime = GetAdjustedTime(); nMedianTimePast = pindexPrev->GetMedianTimePast(); nLockTimeCutoff = (STANDARD_LOCKTIME_VERIFY_FLAGS & LOCKTIME_MEDIAN_TIME_PAST) ? nMedianTimePast : pblock->GetBlockTime(); - int nPackagesSelected = 0; - int nDescendantsUpdated = 0; - addPackageTxs(nPackagesSelected, nDescendantsUpdated); + addPackageTxs(); if (IsMagneticAnomalyEnabled(consensusParams, pindexPrev)) { // If magnetic anomaly is enabled, we make sure transaction are // canonically ordered. std::sort(std::begin(pblocktemplate->entries) + 1, std::end(pblocktemplate->entries), [](const CBlockTemplateEntry &a, const CBlockTemplateEntry &b) -> bool { return a.tx->GetId() < b.tx->GetId(); }); } // Copy all the transactions refs into the block pblock->vtx.reserve(pblocktemplate->entries.size()); for (const CBlockTemplateEntry &entry : pblocktemplate->entries) { pblock->vtx.push_back(entry.tx); } int64_t nTime1 = GetTimeMicros(); m_last_block_num_txs = nBlockTx; m_last_block_size = nBlockSize; // Create coinbase transaction. CMutableTransaction coinbaseTx; coinbaseTx.vin.resize(1); coinbaseTx.vin[0].prevout = COutPoint(); coinbaseTx.vout.resize(1); coinbaseTx.vout[0].scriptPubKey = scriptPubKeyIn; coinbaseTx.vout[0].nValue = nFees + GetBlockSubsidy(nHeight, consensusParams); coinbaseTx.vin[0].scriptSig = CScript() << nHeight << OP_0; const auto whitelisted = GetMinerFundWhitelist(consensusParams, pindexPrev); if (!whitelisted.empty()) { const Amount fund = GetMinerFundAmount(coinbaseTx.vout[0].nValue); coinbaseTx.vout[0].nValue -= fund; coinbaseTx.vout.emplace_back( fund, GetScriptForDestination(*whitelisted.begin())); } // Make sure the coinbase is big enough. uint64_t coinbaseSize = ::GetSerializeSize(coinbaseTx, PROTOCOL_VERSION); if (coinbaseSize < MIN_TX_SIZE) { coinbaseTx.vin[0].scriptSig << std::vector(MIN_TX_SIZE - coinbaseSize - 1); } pblocktemplate->entries[0].tx = MakeTransactionRef(coinbaseTx); pblocktemplate->entries[0].fees = -1 * nFees; pblock->vtx[0] = pblocktemplate->entries[0].tx; uint64_t nSerializeSize = GetSerializeSize(*pblock, PROTOCOL_VERSION); LogPrintf( "CreateNewBlock(): total size: %u txs: %u fees: %ld sigChecks %d\n", nSerializeSize, nBlockTx, nFees, nBlockSigChecks); // Fill in header. pblock->hashPrevBlock = pindexPrev->GetBlockHash(); UpdateTime(pblock, chainParams, pindexPrev); pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, chainParams); pblock->nNonce = 0; pblocktemplate->entries[0].sigChecks = 0; BlockValidationState state; if (!TestBlockValidity(state, chainParams, m_chainstate, *pblock, pindexPrev, BlockValidationOptions(nMaxGeneratedBlockSize) .withCheckPoW(false) .withCheckMerkleRoot(false))) { throw std::runtime_error(strprintf("%s: TestBlockValidity failed: %s", __func__, state.ToString())); } int64_t nTime2 = GetTimeMicros(); - LogPrint(BCLog::BENCH, - "CreateNewBlock() packages: %.2fms (%d packages, %d updated " - "descendants), validity: %.2fms (total %.2fms)\n", - 0.001 * (nTime1 - nTimeStart), nPackagesSelected, - nDescendantsUpdated, 0.001 * (nTime2 - nTime1), - 0.001 * (nTime2 - nTimeStart)); + LogPrint( + BCLog::BENCH, + "CreateNewBlock() packages: %.2fms, validity: %.2fms (total %.2fms)\n", + 0.001 * (nTime1 - nTimeStart), 0.001 * (nTime2 - nTime1), + 0.001 * (nTime2 - nTimeStart)); return std::move(pblocktemplate); } -void BlockAssembler::onlyUnconfirmed(CTxMemPool::setEntries &testSet) { - for (CTxMemPool::setEntries::iterator iit = testSet.begin(); - iit != testSet.end();) { - // Only test txs not already in the block. - if (inBlock.count(*iit)) { - testSet.erase(iit++); - } else { - iit++; - } - } -} - bool BlockAssembler::TestPackage(uint64_t packageSize, int64_t packageSigChecks) const { auto blockSizeWithPackage = nBlockSize + packageSize; if (blockSizeWithPackage >= nMaxGeneratedBlockSize) { return false; } if (nBlockSigChecks + packageSigChecks >= nMaxGeneratedBlockSigChecks) { return false; } return true; } -/** - * Perform transaction-level checks before adding to block: - * - Transaction finality (locktime) - * - Serialized size (in case -blockmaxsize is in use) - */ -bool BlockAssembler::TestPackageTransactions( - const CTxMemPool::setEntries &package) const { - uint64_t nPotentialBlockSize = nBlockSize; - for (CTxMemPool::txiter it : package) { - TxValidationState state; - if (!ContextualCheckTransaction(chainParams.GetConsensus(), it->GetTx(), - state, nHeight, nLockTimeCutoff)) { - return false; - } - - uint64_t nTxSize = ::GetSerializeSize(it->GetTx(), PROTOCOL_VERSION); - if (nPotentialBlockSize + nTxSize >= nMaxGeneratedBlockSize) { - return false; - } - - nPotentialBlockSize += nTxSize; - } - - return true; -} - void BlockAssembler::AddToBlock(CTxMemPool::txiter iter) { pblocktemplate->entries.emplace_back(iter->GetSharedTx(), iter->GetFee(), iter->GetSigChecks()); nBlockSize += iter->GetTxSize(); ++nBlockTx; nBlockSigChecks += iter->GetSigChecks(); nFees += iter->GetFee(); - inBlock.insert(iter); bool fPrintPriority = gArgs.GetBoolArg("-printpriority", DEFAULT_PRINTPRIORITY); if (fPrintPriority) { LogPrintf( "fee rate %s txid %s\n", CFeeRate(iter->GetModifiedFee(), iter->GetTxSize()).ToString(), iter->GetTx().GetId().ToString()); } } -int BlockAssembler::UpdatePackagesForAdded( - const CTxMemPool::setEntries &alreadyAdded, - indexed_modified_transaction_set &mapModifiedTx) { - int nDescendantsUpdated = 0; - for (CTxMemPool::txiter it : alreadyAdded) { - CTxMemPool::setEntries descendants; - m_mempool.CalculateDescendants(it, descendants); - // Insert all descendants (not yet in block) into the modified set. - for (CTxMemPool::txiter desc : descendants) { - if (alreadyAdded.count(desc)) { - continue; - } - - ++nDescendantsUpdated; - modtxiter mit = mapModifiedTx.find(desc); - if (mit == mapModifiedTx.end()) { - CTxMemPoolModifiedEntry modEntry(desc); - mit = mapModifiedTx.insert(modEntry).first; - } - mapModifiedTx.modify(mit, update_for_parent_inclusion(it)); - } - } - - return nDescendantsUpdated; -} - -// Skip entries in mapTx that are already in a block or are present in -// mapModifiedTx (which implies that the mapTx ancestor state is stale due to -// ancestor inclusion in the block). Also skip transactions that we've already -// failed to add. This can happen if we consider a transaction in mapModifiedTx -// and it fails: we can then potentially consider it again while walking mapTx. -// It's currently guaranteed to fail again, but as a belt-and-suspenders check -// we put it in failedTx and avoid re-evaluation, since the re-evaluation would -// be using cached size/sigChecks/fee values that are not actually correct. -bool BlockAssembler::SkipMapTxEntry( - CTxMemPool::txiter it, indexed_modified_transaction_set &mapModifiedTx, - CTxMemPool::setEntries &failedTx) { - assert(it != m_mempool.mapTx.end()); - return mapModifiedTx.count(it) || inBlock.count(it) || failedTx.count(it); -} - -void BlockAssembler::SortForBlock( - const CTxMemPool::setEntries &package, - std::vector &sortedEntries) { - // Sort package by ancestor count. If a transaction A depends on transaction - // B, then A's ancestor count must be greater than B's. So this is - // sufficient to validly order the transactions for block inclusion. - sortedEntries.clear(); - sortedEntries.insert(sortedEntries.begin(), package.begin(), package.end()); - std::sort(sortedEntries.begin(), sortedEntries.end(), - CompareTxIterByAncestorCount()); +bool BlockAssembler::CheckTx(const CTransaction &tx) const { + TxValidationState state; + return ContextualCheckTransaction(chainParams.GetConsensus(), tx, state, + nHeight, nLockTimeCutoff); } /** * addPackageTx includes transactions paying a fee by ensuring that * the partial ordering of transactions is maintained. That is to say * children come after parents, despite having a potentially larger fee. - * @param[out] nPackagesSelected How many packages were selected - * @param[out] nDescendantsUpdated Number of descendant transactions updated */ -void BlockAssembler::addPackageTxs(int &nPackagesSelected, - int &nDescendantsUpdated) { - // selection algorithm orders the mempool based on feerate of a - // transaction including all unconfirmed ancestors. Since we don't remove - // transactions from the mempool as we select them for block inclusion, we - // need an alternate method of updating the feerate of a transaction with - // its not-yet-selected ancestors as we go. This is accomplished by - // walking the in-mempool descendants of selected transactions and storing - // a temporary modified state in mapModifiedTxs. Each time through the - // loop, we compare the best transaction in mapModifiedTxs with the next - // transaction in the mempool to decide what transaction package to work - // on next. - - // mapModifiedTx will store sorted packages after they are modified because - // some of their txs are already in the block. - indexed_modified_transaction_set mapModifiedTx; - // Keep track of entries that failed inclusion, to avoid duplicate work. - CTxMemPool::setEntries failedTx; - - CTxMemPool::indexed_transaction_set::index::type::iterator - mi = m_mempool.mapTx.get().begin(); - CTxMemPool::txiter iter; +void BlockAssembler::addPackageTxs() { + // mapped_value is the number of mempool parents that are still needed for + // the entry. We decrement this count each time we add a parent of the entry + // to the block. + std::unordered_map missingParentCount; + missingParentCount.reserve(m_mempool.size() / 2); + + CTxMemPoolEntry::Children skippedChildren; + + auto hasMissingParents = + [&missingParentCount](const auto &iter) + EXCLUSIVE_LOCKS_REQUIRED(m_mempool.cs) { + // If we've added any of this tx's parents already, then + // missingParentCount will have the current count + if (auto pcIt = missingParentCount.find(&*iter); + pcIt != missingParentCount.end()) { + // when pcIt->second reaches 0, we have added all of this + // tx's parents + return pcIt->second != 0; + } + return !iter->GetMemPoolParentsConst().empty(); + }; // Limit the number of attempts to add transactions to the block when it is // close to full; this is just a simple heuristic to finish quickly if the // mempool has a lot of entries. const int64_t MAX_CONSECUTIVE_FAILURES = 1000; int64_t nConsecutiveFailed = 0; - while (mi != m_mempool.mapTx.get().end() || - !mapModifiedTx.empty()) { - // First try to find a new transaction in mapTx to evaluate. - if (mi != m_mempool.mapTx.get().end() && - SkipMapTxEntry(m_mempool.mapTx.project<0>(mi), mapModifiedTx, - failedTx)) { - ++mi; - continue; - } - - // Now that mi is not stale, determine which transaction to evaluate: - // the next entry from mapTx, or the best from mapModifiedTx? - bool fUsingModified = false; + // Transactions where a parent has been added and need to be checked for + // inclusion. + std::queue backlog; - modtxscoreiter modit = mapModifiedTx.get().begin(); - if (mi == m_mempool.mapTx.get().end()) { - // We're out of entries in mapTx; use the entry from mapModifiedTx - iter = modit->iter; - fUsingModified = true; + CTxMemPool::txiter iter; + auto mi = m_mempool.mapTx.get().begin(); + while (!backlog.empty() || + mi != m_mempool.mapTx.get().end()) { + // Get a new or old transaction in mapTx to evaluate. + bool isFromBacklog = false; + if (!backlog.empty()) { + iter = backlog.front(); + backlog.pop(); + isFromBacklog = true; } else { - // Try to compare the mapTx entry to the mapModifiedTx entry. - iter = m_mempool.mapTx.project<0>(mi); - if (modit != mapModifiedTx.get().end() && - CompareTxMemPoolEntryByAncestorFee()( - *modit, CTxMemPoolModifiedEntry(iter))) { - // The best entry in mapModifiedTx has higher score than the one - // from mapTx. Switch which transaction (package) to consider - iter = modit->iter; - fUsingModified = true; - } else { - // Either no entry in mapModifiedTx, or it's worse than mapTx. - // Increment mi for the next loop iteration. - ++mi; - } + // Cast the iterator to CTxMemPool::txiter + iter = m_mempool.mapTx.project<0>(mi++); } - // We skip mapTx entries that are inBlock, and mapModifiedTx shouldn't - // contain anything that is inBlock. - assert(!inBlock.count(iter)); - - uint64_t packageSize = iter->GetSizeWithAncestors(); - Amount packageFees = iter->GetModFeesWithAncestors(); - int64_t packageSigChecks = iter->GetSigChecksWithAncestors(); - if (fUsingModified) { - packageSize = modit->nSizeWithAncestors; - packageFees = modit->nModFeesWithAncestors; - packageSigChecks = modit->nSigChecksWithAncestors; + if (iter->GetModifiedFeeRate() < blockMinFeeRate) { + // Since the txs are sorted by fee, bail early if there is none that + // can be included in the block anymore. + break; } - if (packageFees < blockMinFeeRate.GetFee(packageSize)) { - // Don't include this package, but don't stop yet because something - // else we might consider may have a sufficient fee rate (since txes - // are ordered by virtualsize feerate, not actual feerate). - if (fUsingModified) { - // Since we always look at the best entry in mapModifiedTx, we - // must erase failed entries so that we can consider the next - // best entry on the next loop iteration - mapModifiedTx.get().erase(modit); - failedTx.insert(iter); - } + // Check whether all of this tx's parents are already in the block. If + // not, pass on it until later. + // + // If it's from the backlog, then we know all parents are already in + // the block. + if (!isFromBacklog && hasMissingParents(iter)) { + skippedChildren.insert(*iter); continue; } - // The following must not use virtual size since TestPackage relies on - // having an accurate call to - // GetMaxBlockSigChecks(blockSizeWithPackage). - if (!TestPackage(packageSize, packageSigChecks)) { - if (fUsingModified) { - // Since we always look at the best entry in mapModifiedTx, we - // must erase failed entries so that we can consider the next - // best entry on the next loop iteration - mapModifiedTx.get().erase(modit); - failedTx.insert(iter); - } - + // Check whether the tx will exceed the block limits. + if (!TestPackage(iter->GetTxSize(), iter->GetSigChecks())) { ++nConsecutiveFailed; - if (nConsecutiveFailed > MAX_CONSECUTIVE_FAILURES && nBlockSize > nMaxGeneratedBlockSize - 1000) { // Give up if we're close to full and haven't succeeded in a // while. break; } - continue; } - CTxMemPool::setEntries ancestors; - uint64_t nNoLimit = std::numeric_limits::max(); - std::string dummy; - m_mempool.CalculateMemPoolAncestors(*iter, ancestors, nNoLimit, - nNoLimit, nNoLimit, nNoLimit, dummy, - false); - - onlyUnconfirmed(ancestors); - ancestors.insert(iter); - - // Test if all tx's are Final. - if (!TestPackageTransactions(ancestors)) { - if (fUsingModified) { - mapModifiedTx.get().erase(modit); - failedTx.insert(iter); - } + // Test transaction finality (locktime) + if (!CheckTx(iter->GetTx())) { continue; } // This transaction will make it in; reset the failed counter. nConsecutiveFailed = 0; - // Package can be added. Sort the entries in a valid order. - std::vector sortedEntries; - SortForBlock(ancestors, sortedEntries); + // Package can be added. + AddToBlock(iter); + + // This tx's children may now be candidates for addition if they have + // higher scores than the tx at the cursor. We can only process a + // child once all of that tx's parents have been added, though. To + // avoid O(n^2) checking of dependencies, we store and decrement the + // number of mempool parents for each child. Although this code + // ends up taking O(n) time to process a single tx with n children, + // that's okay because the amount of time taken is proportional to the + // tx's byte size and fee paid. + const CTxMemPoolEntry::Children &children = + iter->GetMemPoolChildrenConst(); + for (const CTxMemPoolEntry &child : children) { + const auto it = m_mempool.GetIter(child.GetTx().GetId()); + if (!it.has_value()) { + continue; + } - for (auto &entry : sortedEntries) { - AddToBlock(entry); - // Erase from the modified set, if present - mapModifiedTx.erase(entry); + // Remember this tx has missing parents. + // Create the map entry if it doesn't exist already, and init with + // the number of parents. + const auto &[parentCount, _] = missingParentCount.try_emplace( + &*(*it), (*it)->GetMemPoolParentsConst().size()); + // We just added one parent, so decrement the counter and check if + // we have any missing parent remaining. + const bool allParentsAdded = --parentCount->second == 0; + + // If all parents have been added to the block, and if this child + // has been previously skipped due to missing parents, enqueue it + // (if it hasn't been skipped it will come up in a later iteration) + if (allParentsAdded && skippedChildren.count(child) > 0) { + backlog.push(*it); + } } - - ++nPackagesSelected; - - // Update transactions that depend on each of these - nDescendantsUpdated += UpdatePackagesForAdded(ancestors, mapModifiedTx); } } static const std::vector getExcessiveBlockSizeSig(uint64_t nExcessiveBlockSize) { std::string cbmsg = "/EB" + getSubVersionEB(nExcessiveBlockSize) + "/"; std::vector vec(cbmsg.begin(), cbmsg.end()); return vec; } void IncrementExtraNonce(CBlock *pblock, const CBlockIndex *pindexPrev, uint64_t nExcessiveBlockSize, unsigned int &nExtraNonce) { // Update nExtraNonce static uint256 hashPrevBlock; if (hashPrevBlock != pblock->hashPrevBlock) { nExtraNonce = 0; hashPrevBlock = pblock->hashPrevBlock; } ++nExtraNonce; // Height first in coinbase required for block.version=2 unsigned int nHeight = pindexPrev->nHeight + 1; CMutableTransaction txCoinbase(*pblock->vtx[0]); txCoinbase.vin[0].scriptSig = (CScript() << nHeight << CScriptNum(nExtraNonce) << getExcessiveBlockSizeSig(nExcessiveBlockSize)); // Make sure the coinbase is big enough. uint64_t coinbaseSize = ::GetSerializeSize(txCoinbase, PROTOCOL_VERSION); if (coinbaseSize < MIN_TX_SIZE) { txCoinbase.vin[0].scriptSig << std::vector(MIN_TX_SIZE - coinbaseSize - 1); } assert(txCoinbase.vin[0].scriptSig.size() <= MAX_COINBASE_SCRIPTSIG_SIZE); assert(::GetSerializeSize(txCoinbase, PROTOCOL_VERSION) >= MIN_TX_SIZE); pblock->vtx[0] = MakeTransactionRef(std::move(txCoinbase)); pblock->hashMerkleRoot = BlockMerkleRoot(*pblock); } } // namespace node diff --git a/src/node/miner.h b/src/node/miner.h index 206b0d799..16d627b91 100644 --- a/src/node/miner.h +++ b/src/node/miner.h @@ -1,240 +1,126 @@ // Copyright (c) 2009-2010 Satoshi Nakamoto // Copyright (c) 2009-2019 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_NODE_MINER_H #define BITCOIN_NODE_MINER_H #include #include #include #include #include #include #include #include class CBlockIndex; class CChainParams; class Config; class CScript; namespace Consensus { struct Params; } namespace node { static const bool DEFAULT_PRINTPRIORITY = false; struct CBlockTemplateEntry { CTransactionRef tx; Amount fees; int64_t sigChecks; CBlockTemplateEntry(CTransactionRef _tx, Amount _fees, int64_t _sigChecks) : tx(_tx), fees(_fees), sigChecks(_sigChecks){}; }; struct CBlockTemplate { CBlock block; std::vector entries; }; -// Container for tracking updates to ancestor feerate as we include (parent) -// transactions in a block -struct CTxMemPoolModifiedEntry { - explicit CTxMemPoolModifiedEntry(CTxMemPool::txiter entry) { - iter = entry; - nSizeWithAncestors = entry->GetSizeWithAncestors(); - nModFeesWithAncestors = entry->GetModFeesWithAncestors(); - nSigChecksWithAncestors = entry->GetSigChecksWithAncestors(); - } - - Amount GetModifiedFee() const { return iter->GetModifiedFee(); } - uint64_t GetSizeWithAncestors() const { return nSizeWithAncestors; } - uint64_t GetVirtualSizeWithAncestors() const; - Amount GetModFeesWithAncestors() const { return nModFeesWithAncestors; } - size_t GetTxSize() const { return iter->GetTxSize(); } - size_t GetTxVirtualSize() const { return iter->GetTxVirtualSize(); } - const CTransaction &GetTx() const { return iter->GetTx(); } - - CTxMemPool::txiter iter; - uint64_t nSizeWithAncestors; - Amount nModFeesWithAncestors; - int64_t nSigChecksWithAncestors; -}; - -/** - * Comparator for CTxMemPool::txiter objects. - * It simply compares the internal memory address of the CTxMemPoolEntry object - * pointed to. This means it has no meaning, and is only useful for using them - * as key in other indexes. - */ -struct CompareCTxMemPoolIter { - bool operator()(const CTxMemPool::txiter &a, - const CTxMemPool::txiter &b) const { - return &(*a) < &(*b); - } -}; - -struct modifiedentry_iter { - typedef CTxMemPool::txiter result_type; - result_type operator()(const CTxMemPoolModifiedEntry &entry) const { - return entry.iter; - } -}; - -// A comparator that sorts transactions based on number of ancestors. -// This is sufficient to sort an ancestor package in an order that is valid -// to appear in a block. -struct CompareTxIterByAncestorCount { - bool operator()(const CTxMemPool::txiter &a, - const CTxMemPool::txiter &b) const { - if (a->GetCountWithAncestors() != b->GetCountWithAncestors()) { - return a->GetCountWithAncestors() < b->GetCountWithAncestors(); - } - return CompareIteratorById()(a, b); - } -}; - -typedef boost::multi_index_container< - CTxMemPoolModifiedEntry, - boost::multi_index::indexed_by< - boost::multi_index::ordered_unique, - // sorted by modified ancestor fee rate - boost::multi_index::ordered_non_unique< - // Reuse same tag from CTxMemPool's similar index - boost::multi_index::tag, - boost::multi_index::identity, - CompareTxMemPoolEntryByAncestorFee>>> - indexed_modified_transaction_set; - -typedef indexed_modified_transaction_set::nth_index<0>::type::iterator - modtxiter; -typedef indexed_modified_transaction_set::index::type::iterator - modtxscoreiter; - -struct update_for_parent_inclusion { - explicit update_for_parent_inclusion(CTxMemPool::txiter it) : iter(it) {} - - void operator()(CTxMemPoolModifiedEntry &e) { - e.nModFeesWithAncestors -= iter->GetModifiedFee(); - e.nSizeWithAncestors -= iter->GetTxSize(); - e.nSigChecksWithAncestors -= iter->GetSigChecks(); - } - - CTxMemPool::txiter iter; -}; - /** Generate a new block, without valid proof-of-work */ class BlockAssembler { private: // The constructed block template std::unique_ptr pblocktemplate; // Configuration parameters for the block size uint64_t nMaxGeneratedBlockSize; uint64_t nMaxGeneratedBlockSigChecks; CFeeRate blockMinFeeRate; // Information on the current status of the block uint64_t nBlockSize; uint64_t nBlockTx; uint64_t nBlockSigChecks; Amount nFees; - CTxMemPool::setEntries inBlock; // Chain context for the block int nHeight; int64_t nLockTimeCutoff; int64_t nMedianTimePast; const CChainParams &chainParams; const CTxMemPool &m_mempool; CChainState &m_chainstate; public: struct Options { Options(); uint64_t nExcessiveBlockSize; uint64_t nMaxGeneratedBlockSize; CFeeRate blockMinFeeRate; }; BlockAssembler(const Config &config, CChainState &chainstate, const CTxMemPool &mempool); BlockAssembler(CChainState &chainstate, const CChainParams ¶ms, const CTxMemPool &mempool, const Options &options); /** Construct a new block template with coinbase to scriptPubKeyIn */ std::unique_ptr CreateNewBlock(const CScript &scriptPubKeyIn); uint64_t GetMaxGeneratedBlockSize() const { return nMaxGeneratedBlockSize; } static std::optional m_last_block_num_txs; static std::optional m_last_block_size; private: // utility functions /** Clear the block's state and prepare for assembling a new block */ void resetBlock(); /** Add a tx to the block */ void AddToBlock(CTxMemPool::txiter iter); // Methods for how to add transactions to a block. /** * Add transactions based on feerate including unconfirmed ancestors. * Increments nPackagesSelected / nDescendantsUpdated with corresponding * statistics from the package selection (for logging statistics). */ - void addPackageTxs(int &nPackagesSelected, int &nDescendantsUpdated) - EXCLUSIVE_LOCKS_REQUIRED(m_mempool.cs); + void addPackageTxs() EXCLUSIVE_LOCKS_REQUIRED(m_mempool.cs); // helper functions for addPackageTxs() - /** Remove confirmed (inBlock) entries from given set */ - void onlyUnconfirmed(CTxMemPool::setEntries &testSet); /** Test if a new package would "fit" in the block */ bool TestPackage(uint64_t packageSize, int64_t packageSigChecks) const; - /** - * Perform checks on each transaction in a package: - * locktime, serialized size (if necessary). These checks should always - * succeed, and they're here only as an extra check in case of suboptimal - * node configuration. - */ - bool TestPackageTransactions(const CTxMemPool::setEntries &package) const; - /** - * Return true if given transaction from mapTx has already been evaluated, - * or if the transaction's cached data in mapTx is incorrect. - */ - bool SkipMapTxEntry(CTxMemPool::txiter it, - indexed_modified_transaction_set &mapModifiedTx, - CTxMemPool::setEntries &failedTx) - EXCLUSIVE_LOCKS_REQUIRED(m_mempool.cs); - /** Sort the package in an order that is valid to appear in a block */ - void SortForBlock(const CTxMemPool::setEntries &package, - std::vector &sortedEntries); - /** - * Add descendants of given transactions to mapModifiedTx with ancestor - * state updated assuming given transactions are inBlock. Returns number of - * updated descendants. - */ - int UpdatePackagesForAdded(const CTxMemPool::setEntries &alreadyAdded, - indexed_modified_transaction_set &mapModifiedTx) - EXCLUSIVE_LOCKS_REQUIRED(m_mempool.cs); + + /// Check the transaction for finality, etc before adding to block + bool CheckTx(const CTransaction &tx) const; }; /** Modify the extranonce in a block */ void IncrementExtraNonce(CBlock *pblock, const CBlockIndex *pindexPrev, uint64_t nExcessiveBlockSize, unsigned int &nExtraNonce); int64_t UpdateTime(CBlockHeader *pblock, const CChainParams &chainParams, const CBlockIndex *pindexPrev); } // namespace node #endif // BITCOIN_NODE_MINER_H diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp index 77b25b39e..084eb3128 100644 --- a/src/test/miner_tests.cpp +++ b/src/test/miner_tests.cpp @@ -1,899 +1,848 @@ // Copyright (c) 2011-2019 The Bitcoin Core developers // Copyright (c) 2017-2020 The Bitcoin developers // Distributed under the MIT software license, see the accompanying // file COPYING or http://www.opensource.org/licenses/mit-license.php. #include #include #include #include #include #include #include #include #include #include #include