maxmustermann
/
dogecoin
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

rpc: Add createauxblock and submitauxblock methods back 

Adds back Namecoin's createauxblock and submitauxblock rpc methods
to allow easier integration for mining pools that wish to reuse
existing implementations of Namecoin/Bitcoin merge mining.

Cherry-picked from: michilumin@1c5b9b33

Changes post-pick:
- Fixed issue with erroneously moved LOCK in getauxblock
- Disabled mining of witness tx as done for getauxblock
- Fixed indentation, increasing readability and fixing warnings
- Follow Dogecoin API for "target" instead of "_target"
- Remove personal comments
This commit is contained in:
Michi Lumin 2021-10-30 14:55:48 -04:00 committed by Patrick
parent e254dd665b
commit c2532d3f6a
No known key found for this signature in database
GPG Key ID: 7C523F5FBABE80E7
1 changed files with 196 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

220
src/rpc/mining.cpp
View File

@ -969,6 +969,145 @@ UniValue estimatesmartpriority(const JSONRPCRequest& request)
/* ************************************************************************** */
/* Merge mining. */
/**
* The variables below are used to keep track of created and not yet
* submitted auxpow blocks. Lock them to be sure even for multiple
* RPC threads running in parallel.
*/
static CCriticalSection cs_auxblockCache;
static std::map<uint256, CBlock*> mapNewBlock;
static std::vector<std::unique_ptr<CBlockTemplate>> vNewBlockTemplate;
void AuxMiningCheck()
{
if(!g_connman)
throw JSONRPCError(RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled");
if (g_connman->GetNodeCount(CConnman::CONNECTIONS_ALL) == 0 && !Params().MineBlocksOnDemand())
throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "Dogecoin is not connected!");
if (IsInitialBlockDownload() && !Params().MineBlocksOnDemand())
throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD,
"Dogecoin is downloading blocks...");
/* This should never fail, since the chain is already
past the point of merge-mining start. Check nevertheless. */
{
LOCK(cs_main);
if (Params().GetConsensus(chainActive.Height() + 1).fAllowLegacyBlocks)
throw std::runtime_error("getauxblock method is not yet available");
}
}
static UniValue AuxMiningCreateBlock(const CScript& scriptPubKey)
{
AuxMiningCheck();
LOCK(cs_auxblockCache);
static unsigned nTransactionsUpdatedLast;
static const CBlockIndex* pindexPrev = nullptr;
static uint64_t nStart;
static CBlock* pblock = nullptr;
static unsigned nExtraNonce = 0;
// Dogecoin: Never mine witness tx
const bool fMineWitnessTx = false;
// Update block
{
LOCK(cs_main);
if (pindexPrev != chainActive.Tip()
|| (mempool.GetTransactionsUpdated() != nTransactionsUpdatedLast
&& GetTime() - nStart > 60))
{
if (pindexPrev != chainActive.Tip())
{
// Clear old blocks since they're obsolete now.
mapNewBlock.clear();
vNewBlockTemplate.clear();
pblock = nullptr;
}
// Create new block with nonce = 0 and extraNonce = 1
std::unique_ptr<CBlockTemplate> newBlock
= BlockAssembler(Params()).CreateNewBlock(scriptPubKey, fMineWitnessTx);
if (!newBlock)
throw JSONRPCError(RPC_OUT_OF_MEMORY, "out of memory");
// Update state only when CreateNewBlock succeeded
nTransactionsUpdatedLast = mempool.GetTransactionsUpdated();
pindexPrev = chainActive.Tip();
nStart = GetTime();
// Finalise it by setting the version and building the merkle root
IncrementExtraNonce(&newBlock->block, pindexPrev, nExtraNonce);
newBlock->block.SetAuxpowFlag(true);
// Save
pblock = &newBlock->block;
mapNewBlock[pblock->GetHash()] = pblock;
vNewBlockTemplate.push_back(std::move(newBlock));
}
}
// At this point, pblock is always initialised: If we make it here
// without creating a new block above, it means that, in particular,
// pindexPrev == chainActive.Tip(). But for that to happen, we must
// already have created a pblock in a previous call, as pindexPrev is
// initialised only when pblock is.
assert(pblock);
arith_uint256 target;
bool fNegative, fOverflow;
target.SetCompact(pblock->nBits, &fNegative, &fOverflow);
if (fNegative || fOverflow || target == 0)
throw std::runtime_error("invalid difficulty bits in block");
UniValue result(UniValue::VOBJ);
result.pushKV("hash", pblock->GetHash().GetHex());
result.pushKV("chainid", pblock->GetChainId());
result.pushKV("previousblockhash", pblock->hashPrevBlock.GetHex());
result.pushKV("coinbasevalue", (int64_t)pblock->vtx[0]->vout[0].nValue);
result.pushKV("bits", strprintf("%08x", pblock->nBits));
result.pushKV("height", static_cast<int64_t> (pindexPrev->nHeight + 1));
result.pushKV("target", HexStr(BEGIN(target), END(target)));
return result;
}
static bool AuxMiningSubmitBlock(const std::string& hashHex, const std::string& auxpowHex)
{
AuxMiningCheck();
LOCK(cs_auxblockCache);
uint256 hash;
hash.SetHex(hashHex);
const std::map<uint256, CBlock*>::iterator mit = mapNewBlock.find(hash);
if (mit == mapNewBlock.end())
throw JSONRPCError(RPC_INVALID_PARAMETER, "block hash unknown");
CBlock& block = *mit->second;
const std::vector<unsigned char> vchAuxPow = ParseHex(auxpowHex);
CDataStream ss(vchAuxPow, SER_GETHASH, PROTOCOL_VERSION);
CAuxPow pow;
ss >> pow;
block.SetAuxpow(new CAuxPow(pow));
assert(block.GetHash() == hash);
submitblock_StateCatcher sc(block.GetHash());
RegisterValidationInterface(&sc);
std::shared_ptr<const CBlock> shared_block
= std::make_shared<const CBlock>(block);
bool fAccepted = ProcessNewBlock(Params(), shared_block, true, nullptr);
UnregisterValidationInterface(&sc);
return fAccepted;
}
UniValue getauxblockbip22(const JSONRPCRequest& request)
{
if (request.fHelp
@ -1011,31 +1150,8 @@ UniValue getauxblockbip22(const JSONRPCRequest& request)
if (!coinbaseScript->reserveScript.size())
throw JSONRPCError(RPC_INTERNAL_ERROR, "No coinbase script available (mining requires a wallet)");
if(!g_connman)
throw JSONRPCError(RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled");
if (g_connman->GetNodeCount(CConnman::CONNECTIONS_ALL) == 0 && !Params().MineBlocksOnDemand())
throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "Dogecoin is not connected!");
if (IsInitialBlockDownload() && !Params().MineBlocksOnDemand())
throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD,
"Dogecoin is downloading blocks...");
/* This should never fail, since the chain is already
past the point of merge-mining start. Check nevertheless. */
{
LOCK(cs_main);
if (Params().GetConsensus(chainActive.Height() + 1).fAllowLegacyBlocks)
throw std::runtime_error("getauxblock method is not yet available");
}
/* The variables below are used to keep track of created and not yet
submitted auxpow blocks. Lock them to be sure even for multiple
RPC threads running in parallel. */
static CCriticalSection cs_auxblockCache;
AuxMiningCheck();
LOCK(cs_auxblockCache);
static std::map<uint256, CBlock*> mapNewBlock;
static std::vector<std::unique_ptr<CBlockTemplate>> vNewBlockTemplate;
/* Create a new block? */
if (request.params.size() == 0)
@ -1135,6 +1251,59 @@ UniValue getauxblockbip22(const JSONRPCRequest& request)
return BIP22ValidationResult(sc.state);
}
UniValue createauxblock(const JSONRPCRequest& request)
{
if (request.fHelp || request.params.size() != 1)
throw std::runtime_error(
"createauxblock <address>\n"
"\ncreate a new block and return information required to merge-mine it.\n"
"\nArguments:\n"
"1. address (string, required) specify coinbase transaction payout address\n"
"\nResult:\n"
"{\n"
" \"hash\" (string) hash of the created block\n"
" \"chainid\" (numeric) chain ID for this block\n"
" \"previousblockhash\" (string) hash of the previous block\n"
" \"coinbasevalue\" (numeric) value of the block's coinbase\n"
" \"bits\" (string) compressed target of the block\n"
" \"height\" (numeric) height of the block\n"
" \"target\" (string) target in reversed byte order\n"
"}\n"
"\nExamples:\n"
+ HelpExampleCli("createauxblock", "\"address\"")
+ HelpExampleRpc("createauxblock", "\"address\"")
);
// Check coinbase payout address
CBitcoinAddress coinbaseAddress(request.params[0].get_str());
if (!coinbaseAddress.IsValid())
throw JSONRPCError(RPC_INVALID_PARAMETER,"Invalid coinbase payout address");
const CScript scriptPubKey = GetScriptForDestination(coinbaseAddress.Get());
return AuxMiningCreateBlock(scriptPubKey);
}
UniValue submitauxblock(const JSONRPCRequest& request)
{
if (request.fHelp || request.params.size() != 2)
throw std::runtime_error(
"submitauxblock <hash> <auxpow>\n"
"\nsubmit a solved auxpow for a previously block created by 'createauxblock'.\n"
"\nArguments:\n"
"1. hash (string, required) hash of the block to submit\n"
"2. auxpow (string, required) serialised auxpow found\n"
"\nResult:\n"
"xxxxx (boolean) whether the submitted block was correct\n"
"\nExamples:\n"
+ HelpExampleCli("submitauxblock", "\"hash\" \"serialised auxpow\"")
+ HelpExampleRpc("submitauxblock", "\"hash\" \"serialised auxpow\"")
);
return AuxMiningSubmitBlock(request.params[0].get_str(),
request.params[1].get_str());
}
UniValue getauxblock(const JSONRPCRequest& request)
{
const UniValue response = getauxblockbip22(request);
@ -1157,7 +1326,10 @@ static const CRPCCommand commands[] =
{ "mining", "prioritisetransaction", &prioritisetransaction, true, {"txid","priority_delta","fee_delta"} },
{ "mining", "getblocktemplate", &getblocktemplate, true, {"template_request"} },
{ "mining", "submitblock", &submitblock, true, {"hexdata","parameters"} },
{ "mining", "getauxblock", &getauxblock, true, {"hash", "auxpow"} },
{ "mining", "createauxblock", &createauxblock, true, {"address"} },
{ "mining", "submitauxblock", &submitauxblock, true, {"hash", "auxpow"} },
{ "generating", "generate", &generate, true, {"nblocks","maxtries","auxpow"} },
{ "generating", "generatetoaddress", &generatetoaddress, true, {"nblocks","address","maxtries","auxpow"} },