foster/bitcoin-bitcoin-core
0
0
Fork 0
mirror of https://github.com/bitcoin/bitcoin.git synced 2025-02-08 10:31:50 -05:00
Code Issues Activity

rpc/mining: Use existing NodeContext

Browse source 
Also pass in appropriate object to:
- GetNetworkHashPS
- [gG]enerateBlock{,s}

Also:
- Misc style/constness changes
This commit is contained in:
Carl Dong 2020-10-14 15:57:17 -04:00
parent d485e815e2
commit 60dc05afc6
1 changed files with 37 additions and 28 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

65
src/rpc/mining.cpp
View file

@ -44,11 +44,12 @@
* or from the last difficulty change if 'lookup' is nonpositive. * or from the last difficulty change if 'lookup' is nonpositive.
* If 'height' is nonnegative, compute the estimate at the time when a given block was found. * If 'height' is nonnegative, compute the estimate at the time when a given block was found.
*/ */
static UniValue GetNetworkHashPS(int lookup, int height) { static UniValue GetNetworkHashPS(int lookup, int height, const CChain& active_chain) {
CBlockIndex *pb = ::ChainActive().Tip(); const CBlockIndex* pb = active_chain.Tip();
if (height >= 0 && height < ::ChainActive().Height()) if (height >= 0 && height < active_chain.Height()) {
pb = ::ChainActive()[height]; pb = active_chain[height];
}
if (pb == nullptr || !pb->nHeight) if (pb == nullptr || !pb->nHeight)
return 0; return 0;
@ -61,7 +62,7 @@ static UniValue GetNetworkHashPS(int lookup, int height) {
if (lookup > pb->nHeight) if (lookup > pb->nHeight)
lookup = pb->nHeight; lookup = pb->nHeight;
CBlockIndex *pb0 = pb; const CBlockIndex* pb0 = pb;
int64_t minTime = pb0->GetBlockTime(); int64_t minTime = pb0->GetBlockTime();
int64_t maxTime = minTime; int64_t maxTime = minTime;
for (int i = 0; i < lookup; i++) { for (int i = 0; i < lookup; i++) {
@ -100,7 +101,8 @@ static RPCHelpMan getnetworkhashps()
[&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
{ {
LOCK(cs_main); LOCK(cs_main);
return GetNetworkHashPS(!request.params[0].isNull() ? request.params[0].get_int() : 120, !request.params[1].isNull() ? request.params[1].get_int() : -1); const CChain& active_chain = EnsureChainman(request.context).ActiveChain();
return GetNetworkHashPS(!request.params[0].isNull() ? request.params[0].get_int() : 120, !request.params[1].isNull() ? request.params[1].get_int() : -1, active_chain);
}, },
}; };
} }
@ -111,7 +113,8 @@ static bool GenerateBlock(ChainstateManager& chainman, CBlock& block, uint64_t&
{ {
LOCK(cs_main); LOCK(cs_main);
IncrementExtraNonce(&block, ::ChainActive().Tip(), extra_nonce); CHECK_NONFATAL(std::addressof(::ChainActive()) == std::addressof(chainman.ActiveChain()));
IncrementExtraNonce(&block, chainman.ActiveChain().Tip(), extra_nonce);
} }
CChainParams chainparams(Params()); CChainParams chainparams(Params());
@ -143,7 +146,8 @@ static UniValue generateBlocks(ChainstateManager& chainman, const CTxMemPool& me
{ // Don't keep cs_main locked { // Don't keep cs_main locked
LOCK(cs_main); LOCK(cs_main);
nHeight = ::ChainActive().Height(); CHECK_NONFATAL(std::addressof(::ChainActive()) == std::addressof(chainman.ActiveChain()));
nHeight = chainman.ActiveChain().Height();
nHeightEnd = nHeight+nGenerate; nHeightEnd = nHeight+nGenerate;
} }
unsigned int nExtraNonce = 0; unsigned int nExtraNonce = 0;
@ -354,11 +358,12 @@ static RPCHelpMan generateblock()
CChainParams chainparams(Params()); CChainParams chainparams(Params());
CBlock block; CBlock block;
ChainstateManager& chainman = EnsureChainman(request.context);
{ {
LOCK(cs_main); LOCK(cs_main);
CTxMemPool empty_mempool; CTxMemPool empty_mempool;
std::unique_ptr<CBlockTemplate> blocktemplate(BlockAssembler(::ChainstateActive(), empty_mempool, chainparams).CreateNewBlock(coinbase_script)); std::unique_ptr<CBlockTemplate> blocktemplate(BlockAssembler(chainman.ActiveChainstate(), empty_mempool, chainparams).CreateNewBlock(coinbase_script));
if (!blocktemplate) { if (!blocktemplate) {
throw JSONRPCError(RPC_INTERNAL_ERROR, "Couldn't create new block"); throw JSONRPCError(RPC_INTERNAL_ERROR, "Couldn't create new block");
} }
@ -369,14 +374,14 @@ static RPCHelpMan generateblock()
// Add transactions // Add transactions
block.vtx.insert(block.vtx.end(), txs.begin(), txs.end()); block.vtx.insert(block.vtx.end(), txs.begin(), txs.end());
CBlockIndex* prev_block = WITH_LOCK(::cs_main, return g_chainman.m_blockman.LookupBlockIndex(block.hashPrevBlock)); CBlockIndex* prev_block = WITH_LOCK(::cs_main, return chainman.m_blockman.LookupBlockIndex(block.hashPrevBlock));
RegenerateCommitments(block, prev_block); RegenerateCommitments(block, prev_block);
{ {
LOCK(cs_main); LOCK(cs_main);
BlockValidationState state; BlockValidationState state;
if (!TestBlockValidity(state, chainparams, ::ChainstateActive(), block, g_chainman.m_blockman.LookupBlockIndex(block.hashPrevBlock), false, false)) { if (!TestBlockValidity(state, chainparams, chainman.ActiveChainstate(), block, chainman.m_blockman.LookupBlockIndex(block.hashPrevBlock), false, false)) {
throw JSONRPCError(RPC_VERIFY_ERROR, strprintf("TestBlockValidity failed: %s", state.ToString())); throw JSONRPCError(RPC_VERIFY_ERROR, strprintf("TestBlockValidity failed: %s", state.ToString()));
} }
} }
@ -385,7 +390,7 @@ static RPCHelpMan generateblock()
uint64_t max_tries{DEFAULT_MAX_TRIES}; uint64_t max_tries{DEFAULT_MAX_TRIES};
unsigned int extra_nonce{0}; unsigned int extra_nonce{0};
if (!GenerateBlock(EnsureChainman(request.context), block, max_tries, extra_nonce, block_hash) || block_hash.IsNull()) { if (!GenerateBlock(chainman, block, max_tries, extra_nonce, block_hash) || block_hash.IsNull()) {
throw JSONRPCError(RPC_MISC_ERROR, "Failed to make block."); throw JSONRPCError(RPC_MISC_ERROR, "Failed to make block.");
} }
@ -421,12 +426,13 @@ static RPCHelpMan getmininginfo()
{ {
LOCK(cs_main); LOCK(cs_main);
const CTxMemPool& mempool = EnsureMemPool(request.context); const CTxMemPool& mempool = EnsureMemPool(request.context);
const CChain& active_chain = EnsureChainman(request.context).ActiveChain();
UniValue obj(UniValue::VOBJ); UniValue obj(UniValue::VOBJ);
obj.pushKV("blocks", (int)::ChainActive().Height()); obj.pushKV("blocks", (int)active_chain.Height());
if (BlockAssembler::m_last_block_weight) obj.pushKV("currentblockweight", *BlockAssembler::m_last_block_weight); if (BlockAssembler::m_last_block_weight) obj.pushKV("currentblockweight", *BlockAssembler::m_last_block_weight);
if (BlockAssembler::m_last_block_num_txs) obj.pushKV("currentblocktx", *BlockAssembler::m_last_block_num_txs); if (BlockAssembler::m_last_block_num_txs) obj.pushKV("currentblocktx", *BlockAssembler::m_last_block_num_txs);
obj.pushKV("difficulty", (double)GetDifficulty(::ChainActive().Tip())); obj.pushKV("difficulty", (double)GetDifficulty(active_chain.Tip()));
obj.pushKV("networkhashps", getnetworkhashps().HandleRequest(request)); obj.pushKV("networkhashps", getnetworkhashps().HandleRequest(request));
obj.pushKV("pooledtx", (uint64_t)mempool.size()); obj.pushKV("pooledtx", (uint64_t)mempool.size());
obj.pushKV("chain", Params().NetworkIDString()); obj.pushKV("chain", Params().NetworkIDString());
@ -590,6 +596,7 @@ static RPCHelpMan getblocktemplate()
[&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
{ {
LOCK(cs_main); LOCK(cs_main);
ChainstateManager& chainman = EnsureChainman(request.context);
std::string strMode = "template"; std::string strMode = "template";
UniValue lpval = NullUniValue; UniValue lpval = NullUniValue;
@ -620,7 +627,7 @@ static RPCHelpMan getblocktemplate()
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed"); throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed");
uint256 hash = block.GetHash(); uint256 hash = block.GetHash();
const CBlockIndex* pindex = g_chainman.m_blockman.LookupBlockIndex(hash); const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(hash);
if (pindex) { if (pindex) {
if (pindex->IsValid(BLOCK_VALID_SCRIPTS)) if (pindex->IsValid(BLOCK_VALID_SCRIPTS))
return "duplicate"; return "duplicate";
@ -629,12 +636,12 @@ static RPCHelpMan getblocktemplate()
return "duplicate-inconclusive"; return "duplicate-inconclusive";
} }
CBlockIndex* const pindexPrev = ::ChainActive().Tip(); CBlockIndex* const pindexPrev = chainman.ActiveChain().Tip();
// TestBlockValidity only supports blocks built on the current Tip // TestBlockValidity only supports blocks built on the current Tip
if (block.hashPrevBlock != pindexPrev->GetBlockHash()) if (block.hashPrevBlock != pindexPrev->GetBlockHash())
return "inconclusive-not-best-prevblk"; return "inconclusive-not-best-prevblk";
BlockValidationState state; BlockValidationState state;
TestBlockValidity(state, Params(), ::ChainstateActive(), block, pindexPrev, false, true); TestBlockValidity(state, Params(), chainman.ActiveChainstate(), block, pindexPrev, false, true);
return BIP22ValidationResult(state); return BIP22ValidationResult(state);
} }
@ -665,7 +672,7 @@ static RPCHelpMan getblocktemplate()
throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, PACKAGE_NAME " is not connected!"); throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, PACKAGE_NAME " is not connected!");
} }
if (::ChainstateActive().IsInitialBlockDownload()) { if (chainman.ActiveChainstate().IsInitialBlockDownload()) {
throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, PACKAGE_NAME " is in initial sync and waiting for blocks..."); throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, PACKAGE_NAME " is in initial sync and waiting for blocks...");
} }
} }
@ -691,7 +698,7 @@ static RPCHelpMan getblocktemplate()
else else
{ {
// NOTE: Spec does not specify behaviour for non-string longpollid, but this makes testing easier // NOTE: Spec does not specify behaviour for non-string longpollid, but this makes testing easier
hashWatchedChain = ::ChainActive().Tip()->GetBlockHash(); hashWatchedChain = chainman.ActiveChain().Tip()->GetBlockHash();
nTransactionsUpdatedLastLP = nTransactionsUpdatedLast; nTransactionsUpdatedLastLP = nTransactionsUpdatedLast;
} }
@ -736,7 +743,7 @@ static RPCHelpMan getblocktemplate()
static CBlockIndex* pindexPrev; static CBlockIndex* pindexPrev;
static int64_t nStart; static int64_t nStart;
static std::unique_ptr<CBlockTemplate> pblocktemplate; static std::unique_ptr<CBlockTemplate> pblocktemplate;
if (pindexPrev != ::ChainActive().Tip() || if (pindexPrev != chainman.ActiveChain().Tip() ||
(mempool.GetTransactionsUpdated() != nTransactionsUpdatedLast && GetTime() - nStart > 5)) (mempool.GetTransactionsUpdated() != nTransactionsUpdatedLast && GetTime() - nStart > 5))
{ {
// Clear pindexPrev so future calls make a new block, despite any failures from here on // Clear pindexPrev so future calls make a new block, despite any failures from here on
@ -744,12 +751,12 @@ static RPCHelpMan getblocktemplate()
// Store the pindexBest used before CreateNewBlock, to avoid races // Store the pindexBest used before CreateNewBlock, to avoid races
nTransactionsUpdatedLast = mempool.GetTransactionsUpdated(); nTransactionsUpdatedLast = mempool.GetTransactionsUpdated();
CBlockIndex* pindexPrevNew = ::ChainActive().Tip(); CBlockIndex* pindexPrevNew = chainman.ActiveChain().Tip();
nStart = GetTime(); nStart = GetTime();
// Create new block // Create new block
CScript scriptDummy = CScript() << OP_TRUE; CScript scriptDummy = CScript() << OP_TRUE;
pblocktemplate = BlockAssembler(::ChainstateActive(), mempool, Params()).CreateNewBlock(scriptDummy); pblocktemplate = BlockAssembler(chainman.ActiveChainstate(), mempool, Params()).CreateNewBlock(scriptDummy);
if (!pblocktemplate) if (!pblocktemplate)
throw JSONRPCError(RPC_OUT_OF_MEMORY, "Out of memory"); throw JSONRPCError(RPC_OUT_OF_MEMORY, "Out of memory");
@ -885,7 +892,7 @@ static RPCHelpMan getblocktemplate()
result.pushKV("transactions", transactions); result.pushKV("transactions", transactions);
result.pushKV("coinbaseaux", aux); result.pushKV("coinbaseaux", aux);
result.pushKV("coinbasevalue", (int64_t)pblock->vtx[0]->vout[0].nValue); result.pushKV("coinbasevalue", (int64_t)pblock->vtx[0]->vout[0].nValue);
result.pushKV("longpollid", ::ChainActive().Tip()->GetBlockHash().GetHex() + ToString(nTransactionsUpdatedLast)); result.pushKV("longpollid", chainman.ActiveChain().Tip()->GetBlockHash().GetHex() + ToString(nTransactionsUpdatedLast));
result.pushKV("target", hashTarget.GetHex()); result.pushKV("target", hashTarget.GetHex());
result.pushKV("mintime", (int64_t)pindexPrev->GetMedianTimePast()+1); result.pushKV("mintime", (int64_t)pindexPrev->GetMedianTimePast()+1);
result.pushKV("mutable", aMutable); result.pushKV("mutable", aMutable);
@ -968,10 +975,11 @@ static RPCHelpMan submitblock()
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block does not start with a coinbase"); throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block does not start with a coinbase");
} }
ChainstateManager& chainman = EnsureChainman(request.context);
uint256 hash = block.GetHash(); uint256 hash = block.GetHash();
{ {
LOCK(cs_main); LOCK(cs_main);
const CBlockIndex* pindex = g_chainman.m_blockman.LookupBlockIndex(hash); const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(hash);
if (pindex) { if (pindex) {
if (pindex->IsValid(BLOCK_VALID_SCRIPTS)) { if (pindex->IsValid(BLOCK_VALID_SCRIPTS)) {
return "duplicate"; return "duplicate";
@ -984,7 +992,7 @@ static RPCHelpMan submitblock()
{ {
LOCK(cs_main); LOCK(cs_main);
const CBlockIndex* pindex = g_chainman.m_blockman.LookupBlockIndex(block.hashPrevBlock); const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(block.hashPrevBlock);
if (pindex) { if (pindex) {
UpdateUncommittedBlockStructures(block, pindex, Params().GetConsensus()); UpdateUncommittedBlockStructures(block, pindex, Params().GetConsensus());
} }
@ -993,7 +1001,7 @@ static RPCHelpMan submitblock()
bool new_block; bool new_block;
auto sc = std::make_shared<submitblock_StateCatcher>(block.GetHash()); auto sc = std::make_shared<submitblock_StateCatcher>(block.GetHash());
RegisterSharedValidationInterface(sc); RegisterSharedValidationInterface(sc);
bool accepted = EnsureChainman(request.context).ProcessNewBlock(Params(), blockptr, /* fForceProcessing */ true, /* fNewBlock */ &new_block); bool accepted = chainman.ProcessNewBlock(Params(), blockptr, /* fForceProcessing */ true, /* fNewBlock */ &new_block);
UnregisterSharedValidationInterface(sc); UnregisterSharedValidationInterface(sc);
if (!new_block && accepted) { if (!new_block && accepted) {
return "duplicate"; return "duplicate";
@ -1026,15 +1034,16 @@ static RPCHelpMan submitheader()
if (!DecodeHexBlockHeader(h, request.params[0].get_str())) { if (!DecodeHexBlockHeader(h, request.params[0].get_str())) {
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block header decode failed"); throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block header decode failed");
} }
ChainstateManager& chainman = EnsureChainman(request.context);
{ {
LOCK(cs_main); LOCK(cs_main);
if (!g_chainman.m_blockman.LookupBlockIndex(h.hashPrevBlock)) { if (!chainman.m_blockman.LookupBlockIndex(h.hashPrevBlock)) {
throw JSONRPCError(RPC_VERIFY_ERROR, "Must submit previous header (" + h.hashPrevBlock.GetHex() + ") first"); throw JSONRPCError(RPC_VERIFY_ERROR, "Must submit previous header (" + h.hashPrevBlock.GetHex() + ") first");
} }
} }
BlockValidationState state; BlockValidationState state;
EnsureChainman(request.context).ProcessNewBlockHeaders({h}, state, Params()); chainman.ProcessNewBlockHeaders({h}, state, Params());
if (state.IsValid()) return NullUniValue; if (state.IsValid()) return NullUniValue;
if (state.IsError()) { if (state.IsError()) {
throw JSONRPCError(RPC_VERIFY_ERROR, state.ToString()); throw JSONRPCError(RPC_VERIFY_ERROR, state.ToString());