2013-07-31 15:43:35 +02:00
|
|
|
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
2018-01-02 18:12:05 +01:00
|
|
|
// Copyright (c) 2009-2017 The Bitcoin Core developers
|
2014-12-13 05:09:33 +01:00
|
|
|
// Distributed under the MIT software license, see the accompanying
|
2013-07-31 15:43:35 +02:00
|
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
|
2017-11-10 01:57:53 +01:00
|
|
|
#include <miner.h>
|
2013-04-13 07:13:08 +02:00
|
|
|
|
2017-11-10 01:57:53 +01:00
|
|
|
#include <amount.h>
|
|
|
|
#include <chain.h>
|
|
|
|
#include <chainparams.h>
|
|
|
|
#include <coins.h>
|
|
|
|
#include <consensus/consensus.h>
|
|
|
|
#include <consensus/tx_verify.h>
|
|
|
|
#include <consensus/merkle.h>
|
|
|
|
#include <consensus/validation.h>
|
|
|
|
#include <hash.h>
|
|
|
|
#include <net.h>
|
|
|
|
#include <policy/feerate.h>
|
|
|
|
#include <policy/policy.h>
|
|
|
|
#include <pow.h>
|
|
|
|
#include <primitives/transaction.h>
|
|
|
|
#include <script/standard.h>
|
|
|
|
#include <timedata.h>
|
|
|
|
#include <util.h>
|
|
|
|
#include <utilmoneystr.h>
|
|
|
|
#include <validationinterface.h>
|
2014-06-16 16:30:38 +02:00
|
|
|
|
2016-02-21 03:02:44 +01:00
|
|
|
#include <algorithm>
|
2015-11-03 16:35:39 +01:00
|
|
|
#include <queue>
|
2016-06-18 19:38:28 +02:00
|
|
|
#include <utility>
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
2014-08-21 16:11:09 +02:00
|
|
|
|
2014-04-10 20:14:18 +02:00
|
|
|
// Unconfirmed transactions in the memory pool often depend on other
|
|
|
|
// transactions in the memory pool. When we select transactions from the
|
2017-01-19 19:58:42 +01:00
|
|
|
// pool, we select by highest fee rate of a transaction combined with all
|
|
|
|
// its ancestors.
|
2013-07-31 15:43:35 +02:00
|
|
|
|
2013-04-13 07:13:08 +02:00
|
|
|
uint64_t nLastBlockTx = 0;
|
2016-07-18 19:28:26 +02:00
|
|
|
uint64_t nLastBlockWeight = 0;
|
2013-07-31 15:43:35 +02:00
|
|
|
|
2015-05-22 23:49:50 +02:00
|
|
|
int64_t UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParams, const CBlockIndex* pindexPrev)
|
2014-10-22 01:31:01 +02:00
|
|
|
{
|
2015-05-22 23:49:50 +02:00
|
|
|
int64_t nOldTime = pblock->nTime;
|
|
|
|
int64_t nNewTime = std::max(pindexPrev->GetMedianTimePast()+1, GetAdjustedTime());
|
|
|
|
|
|
|
|
if (nOldTime < nNewTime)
|
|
|
|
pblock->nTime = nNewTime;
|
2014-10-22 01:31:01 +02:00
|
|
|
|
|
|
|
// Updating time can change work required on testnet:
|
2015-04-10 18:42:50 +02:00
|
|
|
if (consensusParams.fPowAllowMinDifficultyBlocks)
|
|
|
|
pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, consensusParams);
|
2015-05-22 23:49:50 +02:00
|
|
|
|
|
|
|
return nNewTime - nOldTime;
|
2014-10-22 01:31:01 +02:00
|
|
|
}
|
|
|
|
|
2017-02-27 01:13:17 +01:00
|
|
|
BlockAssembler::Options::Options() {
|
|
|
|
blockMinFeeRate = CFeeRate(DEFAULT_BLOCK_MIN_TX_FEE);
|
|
|
|
nBlockMaxWeight = DEFAULT_BLOCK_MAX_WEIGHT;
|
|
|
|
}
|
|
|
|
|
|
|
|
BlockAssembler::BlockAssembler(const CChainParams& params, const Options& options) : chainparams(params)
|
|
|
|
{
|
|
|
|
blockMinFeeRate = options.blockMinFeeRate;
|
|
|
|
// Limit weight to between 4K and MAX_BLOCK_WEIGHT-4K for sanity:
|
|
|
|
nBlockMaxWeight = std::max<size_t>(4000, std::min<size_t>(MAX_BLOCK_WEIGHT - 4000, options.nBlockMaxWeight));
|
|
|
|
}
|
|
|
|
|
2018-06-27 23:26:15 +02:00
|
|
|
static BlockAssembler::Options DefaultOptions()
|
2013-07-31 15:43:35 +02:00
|
|
|
{
|
2016-01-03 18:54:50 +01:00
|
|
|
// Block resource limits
|
2018-03-22 15:28:52 +01:00
|
|
|
// If -blockmaxweight is not given, limit to DEFAULT_BLOCK_MAX_WEIGHT
|
2017-02-27 01:13:17 +01:00
|
|
|
BlockAssembler::Options options;
|
2017-08-24 17:36:07 +02:00
|
|
|
options.nBlockMaxWeight = gArgs.GetArg("-blockmaxweight", DEFAULT_BLOCK_MAX_WEIGHT);
|
2017-08-01 21:17:40 +02:00
|
|
|
if (gArgs.IsArgSet("-blockmintxfee")) {
|
2016-12-13 17:51:51 +01:00
|
|
|
CAmount n = 0;
|
2017-08-01 21:17:40 +02:00
|
|
|
ParseMoney(gArgs.GetArg("-blockmintxfee", ""), n);
|
2017-02-27 01:13:17 +01:00
|
|
|
options.blockMinFeeRate = CFeeRate(n);
|
2016-12-13 17:51:51 +01:00
|
|
|
} else {
|
2017-02-27 01:13:17 +01:00
|
|
|
options.blockMinFeeRate = CFeeRate(DEFAULT_BLOCK_MIN_TX_FEE);
|
2016-12-13 17:51:51 +01:00
|
|
|
}
|
2017-02-27 01:13:17 +01:00
|
|
|
return options;
|
2015-12-15 21:26:44 +01:00
|
|
|
}
|
|
|
|
|
2018-06-27 23:26:15 +02:00
|
|
|
BlockAssembler::BlockAssembler(const CChainParams& params) : BlockAssembler(params, DefaultOptions()) {}
|
2017-02-27 01:13:17 +01:00
|
|
|
|
2015-12-15 21:26:44 +01:00
|
|
|
void BlockAssembler::resetBlock()
|
|
|
|
{
|
|
|
|
inBlock.clear();
|
|
|
|
|
|
|
|
// Reserve space for coinbase tx
|
2016-07-18 19:28:26 +02:00
|
|
|
nBlockWeight = 4000;
|
2016-01-03 18:54:50 +01:00
|
|
|
nBlockSigOpsCost = 400;
|
2015-11-06 01:42:38 +01:00
|
|
|
fIncludeWitness = false;
|
2015-12-15 21:26:44 +01:00
|
|
|
|
|
|
|
// These counters do not include coinbase tx
|
|
|
|
nBlockTx = 0;
|
|
|
|
nFees = 0;
|
|
|
|
}
|
|
|
|
|
2017-03-08 21:56:59 +01:00
|
|
|
std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& scriptPubKeyIn, bool fMineWitnessTx)
|
2015-12-15 21:26:44 +01:00
|
|
|
{
|
2017-03-08 16:17:58 +01:00
|
|
|
int64_t nTimeStart = GetTimeMicros();
|
|
|
|
|
2015-12-15 21:26:44 +01:00
|
|
|
resetBlock();
|
|
|
|
|
|
|
|
pblocktemplate.reset(new CBlockTemplate());
|
|
|
|
|
2013-07-31 15:43:35 +02:00
|
|
|
if(!pblocktemplate.get())
|
2016-06-18 19:38:28 +02:00
|
|
|
return nullptr;
|
2015-12-15 21:26:44 +01:00
|
|
|
pblock = &pblocktemplate->block; // pointer for convenience
|
2013-07-31 15:43:35 +02:00
|
|
|
|
2014-06-07 13:53:27 +02:00
|
|
|
// Add dummy coinbase tx as first transaction
|
2016-11-11 02:26:00 +01:00
|
|
|
pblock->vtx.emplace_back();
|
2013-07-31 15:43:35 +02:00
|
|
|
pblocktemplate->vTxFees.push_back(-1); // updated at end
|
2016-01-03 18:54:50 +01:00
|
|
|
pblocktemplate->vTxSigOpsCost.push_back(-1); // updated at end
|
2013-07-31 15:43:35 +02:00
|
|
|
|
2015-12-15 21:26:44 +01:00
|
|
|
LOCK2(cs_main, mempool.cs);
|
|
|
|
CBlockIndex* pindexPrev = chainActive.Tip();
|
2017-08-23 09:47:56 +02:00
|
|
|
assert(pindexPrev != nullptr);
|
2015-12-15 21:26:44 +01:00
|
|
|
nHeight = pindexPrev->nHeight + 1;
|
|
|
|
|
|
|
|
pblock->nVersion = ComputeBlockVersion(pindexPrev, chainparams.GetConsensus());
|
|
|
|
// -regtest only: allow overriding block.nVersion with
|
|
|
|
// -blockversion=N to test forking scenarios
|
|
|
|
if (chainparams.MineBlocksOnDemand())
|
2017-08-01 21:17:40 +02:00
|
|
|
pblock->nVersion = gArgs.GetArg("-blockversion", pblock->nVersion);
|
2015-12-15 21:26:44 +01:00
|
|
|
|
|
|
|
pblock->nTime = GetAdjustedTime();
|
|
|
|
const int64_t nMedianTimePast = pindexPrev->GetMedianTimePast();
|
|
|
|
|
|
|
|
nLockTimeCutoff = (STANDARD_LOCKTIME_VERIFY_FLAGS & LOCKTIME_MEDIAN_TIME_PAST)
|
|
|
|
? nMedianTimePast
|
|
|
|
: pblock->GetBlockTime();
|
|
|
|
|
2015-11-06 01:42:38 +01:00
|
|
|
// Decide whether to include witness transactions
|
|
|
|
// This is only needed in case the witness softfork activation is reverted
|
|
|
|
// (which would require a very deep reorganization) or when
|
|
|
|
// -promiscuousmempoolflags is used.
|
|
|
|
// TODO: replace this with a call to main to assess validity of a mempool
|
|
|
|
// transaction (which in most cases can be a no-op).
|
2017-03-08 21:56:59 +01:00
|
|
|
fIncludeWitness = IsWitnessEnabled(pindexPrev, chainparams.GetConsensus()) && fMineWitnessTx;
|
2015-11-06 01:42:38 +01:00
|
|
|
|
2017-03-08 16:56:29 +01:00
|
|
|
int nPackagesSelected = 0;
|
|
|
|
int nDescendantsUpdated = 0;
|
|
|
|
addPackageTxs(nPackagesSelected, nDescendantsUpdated);
|
2015-12-15 21:26:44 +01:00
|
|
|
|
2017-03-08 16:17:58 +01:00
|
|
|
int64_t nTime1 = GetTimeMicros();
|
2015-12-15 21:26:44 +01:00
|
|
|
|
|
|
|
nLastBlockTx = nBlockTx;
|
2016-07-18 19:28:26 +02:00
|
|
|
nLastBlockWeight = nBlockWeight;
|
2015-12-15 21:26:44 +01:00
|
|
|
|
|
|
|
// 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;
|
2016-11-11 02:34:17 +01:00
|
|
|
pblock->vtx[0] = MakeTransactionRef(std::move(coinbaseTx));
|
2015-11-06 01:42:38 +01:00
|
|
|
pblocktemplate->vchCoinbaseCommitment = GenerateCoinbaseCommitment(*pblock, pindexPrev, chainparams.GetConsensus());
|
2015-12-15 21:26:44 +01:00
|
|
|
pblocktemplate->vTxFees[0] = -nFees;
|
|
|
|
|
2017-08-24 17:36:07 +02:00
|
|
|
LogPrintf("CreateNewBlock(): block weight: %u txs: %u fees: %ld sigops %d\n", GetBlockWeight(*pblock), nBlockTx, nFees, nBlockSigOpsCost);
|
2016-09-27 19:40:16 +02:00
|
|
|
|
2015-12-15 21:26:44 +01:00
|
|
|
// Fill in header
|
|
|
|
pblock->hashPrevBlock = pindexPrev->GetBlockHash();
|
|
|
|
UpdateTime(pblock, chainparams.GetConsensus(), pindexPrev);
|
|
|
|
pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, chainparams.GetConsensus());
|
|
|
|
pblock->nNonce = 0;
|
2016-11-11 02:26:00 +01:00
|
|
|
pblocktemplate->vTxSigOpsCost[0] = WITNESS_SCALE_FACTOR * GetLegacySigOpCount(*pblock->vtx[0]);
|
2015-12-15 21:26:44 +01:00
|
|
|
|
|
|
|
CValidationState state;
|
|
|
|
if (!TestBlockValidity(state, chainparams, *pblock, pindexPrev, false, false)) {
|
|
|
|
throw std::runtime_error(strprintf("%s: TestBlockValidity failed: %s", __func__, FormatStateMessage(state)));
|
|
|
|
}
|
2017-03-08 16:17:58 +01:00
|
|
|
int64_t nTime2 = GetTimeMicros();
|
|
|
|
|
2016-12-25 21:19:40 +01:00
|
|
|
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));
|
2013-07-31 15:43:35 +02:00
|
|
|
|
2016-06-18 19:38:28 +02:00
|
|
|
return std::move(pblocktemplate);
|
2015-12-15 21:26:44 +01:00
|
|
|
}
|
2013-07-31 15:43:35 +02:00
|
|
|
|
2016-02-21 03:02:44 +01:00
|
|
|
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++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-09 13:34:54 +01:00
|
|
|
bool BlockAssembler::TestPackage(uint64_t packageSize, int64_t packageSigOpsCost) const
|
2016-02-21 03:02:44 +01:00
|
|
|
{
|
2016-07-18 19:28:26 +02:00
|
|
|
// TODO: switch to weight-based accounting for packages instead of vsize-based accounting.
|
|
|
|
if (nBlockWeight + WITNESS_SCALE_FACTOR * packageSize >= nBlockMaxWeight)
|
2016-02-21 03:02:44 +01:00
|
|
|
return false;
|
2016-01-03 18:54:50 +01:00
|
|
|
if (nBlockSigOpsCost + packageSigOpsCost >= MAX_BLOCK_SIGOPS_COST)
|
2016-02-21 03:02:44 +01:00
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
2015-11-03 16:35:39 +01:00
|
|
|
|
2016-06-30 17:22:31 +02:00
|
|
|
// Perform transaction-level checks before adding to block:
|
|
|
|
// - transaction finality (locktime)
|
|
|
|
// - premature witness (in case segwit transactions are added to mempool before
|
|
|
|
// segwit activation)
|
|
|
|
bool BlockAssembler::TestPackageTransactions(const CTxMemPool::setEntries& package)
|
2016-02-21 03:02:44 +01:00
|
|
|
{
|
2018-06-15 19:38:54 +02:00
|
|
|
for (CTxMemPool::txiter it : package) {
|
2016-02-21 03:02:44 +01:00
|
|
|
if (!IsFinalTx(it->GetTx(), nHeight, nLockTimeCutoff))
|
|
|
|
return false;
|
2016-08-04 02:49:16 +02:00
|
|
|
if (!fIncludeWitness && it->GetTx().HasWitness())
|
2016-06-30 17:22:31 +02:00
|
|
|
return false;
|
2016-02-21 03:02:44 +01:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
2015-11-03 16:35:39 +01:00
|
|
|
|
2015-12-15 21:26:44 +01:00
|
|
|
void BlockAssembler::AddToBlock(CTxMemPool::txiter iter)
|
|
|
|
{
|
2016-11-11 02:26:00 +01:00
|
|
|
pblock->vtx.emplace_back(iter->GetSharedTx());
|
2015-12-15 21:26:44 +01:00
|
|
|
pblocktemplate->vTxFees.push_back(iter->GetFee());
|
2016-01-03 18:54:50 +01:00
|
|
|
pblocktemplate->vTxSigOpsCost.push_back(iter->GetSigOpCost());
|
2016-07-18 19:28:26 +02:00
|
|
|
nBlockWeight += iter->GetTxWeight();
|
2015-12-15 21:26:44 +01:00
|
|
|
++nBlockTx;
|
2016-01-03 18:54:50 +01:00
|
|
|
nBlockSigOpsCost += iter->GetSigOpCost();
|
2015-12-15 21:26:44 +01:00
|
|
|
nFees += iter->GetFee();
|
|
|
|
inBlock.insert(iter);
|
|
|
|
|
2017-08-01 21:17:40 +02:00
|
|
|
bool fPrintPriority = gArgs.GetBoolArg("-printpriority", DEFAULT_PRINTPRIORITY);
|
2015-12-15 21:26:44 +01:00
|
|
|
if (fPrintPriority) {
|
2017-01-19 20:59:28 +01:00
|
|
|
LogPrintf("fee %s txid %s\n",
|
2015-12-15 21:26:44 +01:00
|
|
|
CFeeRate(iter->GetModifiedFee(), iter->GetTxSize()).ToString(),
|
|
|
|
iter->GetTx().GetHash().ToString());
|
|
|
|
}
|
|
|
|
}
|
2014-05-10 14:47:16 +02:00
|
|
|
|
2017-03-08 16:56:29 +01:00
|
|
|
int BlockAssembler::UpdatePackagesForAdded(const CTxMemPool::setEntries& alreadyAdded,
|
2016-02-21 03:02:44 +01:00
|
|
|
indexed_modified_transaction_set &mapModifiedTx)
|
|
|
|
{
|
2017-03-08 16:56:29 +01:00
|
|
|
int nDescendantsUpdated = 0;
|
2018-06-15 19:38:54 +02:00
|
|
|
for (CTxMemPool::txiter it : alreadyAdded) {
|
2016-02-21 03:02:44 +01:00
|
|
|
CTxMemPool::setEntries descendants;
|
|
|
|
mempool.CalculateDescendants(it, descendants);
|
|
|
|
// Insert all descendants (not yet in block) into the modified set
|
2017-06-02 03:18:57 +02:00
|
|
|
for (CTxMemPool::txiter desc : descendants) {
|
2016-02-21 03:02:44 +01:00
|
|
|
if (alreadyAdded.count(desc))
|
|
|
|
continue;
|
2017-03-08 16:56:29 +01:00
|
|
|
++nDescendantsUpdated;
|
2016-02-21 03:02:44 +01:00
|
|
|
modtxiter mit = mapModifiedTx.find(desc);
|
|
|
|
if (mit == mapModifiedTx.end()) {
|
|
|
|
CTxMemPoolModifiedEntry modEntry(desc);
|
|
|
|
modEntry.nSizeWithAncestors -= it->GetTxSize();
|
|
|
|
modEntry.nModFeesWithAncestors -= it->GetModifiedFee();
|
2016-01-03 18:54:50 +01:00
|
|
|
modEntry.nSigOpCostWithAncestors -= it->GetSigOpCost();
|
2016-02-21 03:02:44 +01:00
|
|
|
mapModifiedTx.insert(modEntry);
|
|
|
|
} else {
|
|
|
|
mapModifiedTx.modify(mit, update_for_parent_inclusion(it));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-03-08 16:56:29 +01:00
|
|
|
return nDescendantsUpdated;
|
2016-02-21 03:02:44 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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/sigops/fee values that are not actually correct.
|
|
|
|
bool BlockAssembler::SkipMapTxEntry(CTxMemPool::txiter it, indexed_modified_transaction_set &mapModifiedTx, CTxMemPool::setEntries &failedTx)
|
|
|
|
{
|
|
|
|
assert (it != mempool.mapTx.end());
|
2017-04-10 10:24:49 +02:00
|
|
|
return mapModifiedTx.count(it) || inBlock.count(it) || failedTx.count(it);
|
2016-02-21 03:02:44 +01:00
|
|
|
}
|
|
|
|
|
2018-03-15 07:10:39 +01:00
|
|
|
void BlockAssembler::SortForBlock(const CTxMemPool::setEntries& package, std::vector<CTxMemPool::txiter>& sortedEntries)
|
2016-02-21 03:02:44 +01:00
|
|
|
{
|
|
|
|
// 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());
|
|
|
|
}
|
|
|
|
|
|
|
|
// This transaction 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.
|
2017-03-08 16:56:29 +01:00
|
|
|
void BlockAssembler::addPackageTxs(int &nPackagesSelected, int &nDescendantsUpdated)
|
2016-02-21 03:02:44 +01:00
|
|
|
{
|
|
|
|
// 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;
|
|
|
|
|
|
|
|
// Start by adding all descendants of previously added txs to mapModifiedTx
|
|
|
|
// and modifying them for their already included ancestors
|
|
|
|
UpdatePackagesForAdded(inBlock, mapModifiedTx);
|
|
|
|
|
|
|
|
CTxMemPool::indexed_transaction_set::index<ancestor_score>::type::iterator mi = mempool.mapTx.get<ancestor_score>().begin();
|
|
|
|
CTxMemPool::txiter iter;
|
2017-03-06 17:16:06 +01:00
|
|
|
|
|
|
|
// 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;
|
|
|
|
|
2016-02-21 03:02:44 +01:00
|
|
|
while (mi != mempool.mapTx.get<ancestor_score>().end() || !mapModifiedTx.empty())
|
|
|
|
{
|
|
|
|
// First try to find a new transaction in mapTx to evaluate.
|
|
|
|
if (mi != mempool.mapTx.get<ancestor_score>().end() &&
|
|
|
|
SkipMapTxEntry(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;
|
|
|
|
|
|
|
|
modtxscoreiter modit = mapModifiedTx.get<ancestor_score>().begin();
|
|
|
|
if (mi == mempool.mapTx.get<ancestor_score>().end()) {
|
|
|
|
// We're out of entries in mapTx; use the entry from mapModifiedTx
|
|
|
|
iter = modit->iter;
|
|
|
|
fUsingModified = true;
|
|
|
|
} else {
|
|
|
|
// Try to compare the mapTx entry to the mapModifiedTx entry
|
|
|
|
iter = mempool.mapTx.project<0>(mi);
|
|
|
|
if (modit != mapModifiedTx.get<ancestor_score>().end() &&
|
2018-01-13 21:57:30 +01:00
|
|
|
CompareTxMemPoolEntryByAncestorFee()(*modit, CTxMemPoolModifiedEntry(iter))) {
|
2016-02-21 03:02:44 +01:00
|
|
|
// 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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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();
|
|
|
|
CAmount packageFees = iter->GetModFeesWithAncestors();
|
2016-01-03 18:54:50 +01:00
|
|
|
int64_t packageSigOpsCost = iter->GetSigOpCostWithAncestors();
|
2016-02-21 03:02:44 +01:00
|
|
|
if (fUsingModified) {
|
|
|
|
packageSize = modit->nSizeWithAncestors;
|
|
|
|
packageFees = modit->nModFeesWithAncestors;
|
2016-01-03 18:54:50 +01:00
|
|
|
packageSigOpsCost = modit->nSigOpCostWithAncestors;
|
2016-02-21 03:02:44 +01:00
|
|
|
}
|
|
|
|
|
2016-12-13 17:51:51 +01:00
|
|
|
if (packageFees < blockMinFeeRate.GetFee(packageSize)) {
|
2016-02-21 03:02:44 +01:00
|
|
|
// Everything else we might consider has a lower fee rate
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-01-03 18:54:50 +01:00
|
|
|
if (!TestPackage(packageSize, packageSigOpsCost)) {
|
2016-02-21 03:02:44 +01:00
|
|
|
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<ancestor_score>().erase(modit);
|
|
|
|
failedTx.insert(iter);
|
|
|
|
}
|
2017-03-06 17:16:06 +01:00
|
|
|
|
|
|
|
++nConsecutiveFailed;
|
|
|
|
|
|
|
|
if (nConsecutiveFailed > MAX_CONSECUTIVE_FAILURES && nBlockWeight >
|
|
|
|
nBlockMaxWeight - 4000) {
|
|
|
|
// Give up if we're close to full and haven't succeeded in a while
|
|
|
|
break;
|
|
|
|
}
|
2016-02-21 03:02:44 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
CTxMemPool::setEntries ancestors;
|
|
|
|
uint64_t nNoLimit = std::numeric_limits<uint64_t>::max();
|
|
|
|
std::string dummy;
|
|
|
|
mempool.CalculateMemPoolAncestors(*iter, ancestors, nNoLimit, nNoLimit, nNoLimit, nNoLimit, dummy, false);
|
|
|
|
|
|
|
|
onlyUnconfirmed(ancestors);
|
|
|
|
ancestors.insert(iter);
|
|
|
|
|
|
|
|
// Test if all tx's are Final
|
2016-06-30 17:22:31 +02:00
|
|
|
if (!TestPackageTransactions(ancestors)) {
|
2016-02-21 03:02:44 +01:00
|
|
|
if (fUsingModified) {
|
|
|
|
mapModifiedTx.get<ancestor_score>().erase(modit);
|
|
|
|
failedTx.insert(iter);
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2017-03-06 17:16:06 +01:00
|
|
|
// This transaction will make it in; reset the failed counter.
|
|
|
|
nConsecutiveFailed = 0;
|
|
|
|
|
2016-02-21 03:02:44 +01:00
|
|
|
// Package can be added. Sort the entries in a valid order.
|
2017-01-27 09:43:41 +01:00
|
|
|
std::vector<CTxMemPool::txiter> sortedEntries;
|
2018-03-15 07:10:39 +01:00
|
|
|
SortForBlock(ancestors, sortedEntries);
|
2016-02-21 03:02:44 +01:00
|
|
|
|
|
|
|
for (size_t i=0; i<sortedEntries.size(); ++i) {
|
|
|
|
AddToBlock(sortedEntries[i]);
|
|
|
|
// Erase from the modified set, if present
|
|
|
|
mapModifiedTx.erase(sortedEntries[i]);
|
|
|
|
}
|
|
|
|
|
2017-03-08 16:56:29 +01:00
|
|
|
++nPackagesSelected;
|
|
|
|
|
2016-02-21 03:02:44 +01:00
|
|
|
// Update transactions that depend on each of these
|
2017-03-08 16:56:29 +01:00
|
|
|
nDescendantsUpdated += UpdatePackagesForAdded(ancestors, mapModifiedTx);
|
2016-02-21 03:02:44 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-08 18:18:41 +02:00
|
|
|
void IncrementExtraNonce(CBlock* pblock, const CBlockIndex* pindexPrev, unsigned int& nExtraNonce)
|
2013-07-31 15:43:35 +02:00
|
|
|
{
|
|
|
|
// Update nExtraNonce
|
|
|
|
static uint256 hashPrevBlock;
|
|
|
|
if (hashPrevBlock != pblock->hashPrevBlock)
|
|
|
|
{
|
|
|
|
nExtraNonce = 0;
|
|
|
|
hashPrevBlock = pblock->hashPrevBlock;
|
|
|
|
}
|
|
|
|
++nExtraNonce;
|
|
|
|
unsigned int nHeight = pindexPrev->nHeight+1; // Height first in coinbase required for block.version=2
|
2016-11-11 02:26:00 +01:00
|
|
|
CMutableTransaction txCoinbase(*pblock->vtx[0]);
|
2014-06-07 13:53:27 +02:00
|
|
|
txCoinbase.vin[0].scriptSig = (CScript() << nHeight << CScriptNum(nExtraNonce)) + COINBASE_FLAGS;
|
|
|
|
assert(txCoinbase.vin[0].scriptSig.size() <= 100);
|
2013-07-31 15:43:35 +02:00
|
|
|
|
2016-11-11 02:34:17 +01:00
|
|
|
pblock->vtx[0] = MakeTransactionRef(std::move(txCoinbase));
|
2015-11-17 17:35:44 +01:00
|
|
|
pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
|
2013-07-31 15:43:35 +02:00
|
|
|
}
|