diff --git a/src/chainparams.cpp b/src/chainparams.cpp index d4c6e8c59..cfb48138c 100644 --- a/src/chainparams.cpp +++ b/src/chainparams.cpp @@ -105,10 +105,12 @@ public: consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 1199145601; // January 1, 2008 consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = 1230767999; // December 31, 2008 -// Deployment of BIP68, BIP112, and BIP113. -// consensus.vDeployments[Consensus::DEPLOYMENT_CSV].bit = 0; -// consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nStartTime = 999999999999ULL; // never -// consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nTimeout = 0; // out of time + /* + Deployment of BIP68, BIP112, and BIP113. + consensus.vDeployments[Consensus::DEPLOYMENT_CSV].bit = 0; + consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nStartTime = 999999999999ULL; // never + consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nTimeout = 0; // out of time + */ consensus.nProtocolV1RetargetingFixedTime = 1395631999; consensus.nProtocolV2Time = 1407053625; @@ -206,11 +208,11 @@ public: consensus.nProtocolV1RetargetingFixedTime = 1395631999; consensus.nProtocolV2Time = 1407053625; consensus.nProtocolV3Time = 1444028400; - consensus.nLastPOWBlock = 10000; - consensus.nStakeTimestampMask = 0xf; // 15 - consensus.nCoinbaseMaturity = 50; - consensus.nStakeMinConfirmations = 50; - consensus.nStakeMinAge = 1 * 60 * 60; // 1 hour + consensus.nLastPOWBlock = 0x7fffffff; + consensus.nStakeTimestampMask = 0xf; + consensus.nCoinbaseMaturity = 10; + consensus.nStakeMinConfirmations = 10; + consensus.nStakeMinAge = 8 * 60 * 60; pchMessageStart[0] = 0xcd; pchMessageStart[1] = 0xf2; @@ -222,6 +224,12 @@ public: // The best chain should have at least this much work. consensus.nMinimumChainWork = uint256S("0x00"); + /* + consensus.vDeployments[Consensus::DEPLOYMENT_CSV].bit = 0; + consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nStartTime = 999999999999ULL; // never + consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nTimeout = 0; // out of time + */ + nPruneAfterHeight = 1000; genesis = CreateGenesisBlock(1393221600, 216178, 0x1f00ffff, 1, 0); @@ -270,11 +278,11 @@ public: consensus.nMajorityEnforceBlockUpgrade = 51; consensus.nMajorityRejectBlockOutdated = 75; consensus.nMajorityWindow = 100; - consensus.powLimit = uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); - consensus.posLimit = uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); - consensus.posLimitV2 = uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); + consensus.powLimit = uint256S("0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); + consensus.posLimit = uint256S("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); + consensus.posLimitV2 = uint256S("000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffff"); consensus.nTargetTimespan = 16 * 60; // 16 mins - consensus.nTargetSpacingV1 = 60; + consensus.nTargetSpacingV1 = 64; consensus.nTargetSpacing = 64; consensus.BIP34Height = -1; // BIP34 has not necessarily activated on regtest consensus.BIP34Hash = uint256(); @@ -290,18 +298,19 @@ public: // The best chain should have at least this much work. consensus.nMinimumChainWork = uint256S("0x00"); -// Deployment of BIP68, BIP112, and BIP113. -// consensus.vDeployments[Consensus::DEPLOYMENT_CSV].bit = 0; -// consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nStartTime = 999999999999ULL; // never -// consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nTimeout = 0; // out of time + /* + consensus.vDeployments[Consensus::DEPLOYMENT_CSV].bit = 0; + consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nStartTime = 999999999999ULL; // never + consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nTimeout = 0; // out of time + */ consensus.nProtocolV1RetargetingFixedTime = 1395631999; consensus.nProtocolV2Time = 1407053625; consensus.nProtocolV3Time = 1444028400; consensus.nLastPOWBlock = 1000; consensus.nStakeTimestampMask = 0xf; - consensus.nCoinbaseMaturity = 50; - consensus.nStakeMinConfirmations = 50; + consensus.nCoinbaseMaturity = 10; + consensus.nStakeMinConfirmations = 10; consensus.nStakeMinAge = 1 * 60 * 60; pchMessageStart[0] = 0x70; @@ -312,10 +321,10 @@ public: nMaxTipAge = 0x7fffffff; nPruneAfterHeight = 100000; - genesis = CreateGenesisBlock(1504695029, 17, 0x207fffff, 7, 0); + genesis = CreateGenesisBlock(1393221600, 216178, 0x1f00ffff, 1, 0); consensus.hashGenesisBlock = genesis.GetHash(); - assert(consensus.hashGenesisBlock == uint256S("0xf42eb1d043cb8003e491b48e6404f7c3465df16c04ba9370b8307fad87b21216")); - assert(genesis.hashMerkleRoot == uint256S("0xca4884e59066db370e5bf6d368c49d5ec8c7dc1161109f71be5f17c6aeb0e30f")); + assert(consensus.hashGenesisBlock == uint256S("0x0000724595fb3b9609d441cbfb9577615c292abf07d996d3edabc48de843642d")); + assert(genesis.hashMerkleRoot == uint256S("0x12630d16a97f24b287c8c2594dda5fb98c9e6c70fc61d44191931ea2aa08dc90")); vFixedSeeds.clear(); //! Regtest mode doesn't have any fixed seeds. vSeeds.clear(); //! Regtest mode doesn't have any DNS seeds. diff --git a/src/main.cpp b/src/main.cpp index b8d8134da..88ab1a05f 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1630,9 +1630,11 @@ bool ReadBlockFromDisk(CBlock& block, const CDiskBlockPos& pos, const Consensus: return error("%s: Deserialize or I/O error - %s at %s", __func__, e.what(), pos.ToString()); } - // Check the header -// if (!CheckProofOfWork(block.GetPoWHash(), block.nBits, consensusParams)) -// return error("ReadBlockFromDisk: Errors in block header at %s", pos.ToString()); + // Check headers for proof-of-work blocks + if (block.GetHash() != consensusParams.hashGenesisBlock && block.IsProofOfWork()) { + if (!CheckProofOfWork(block.GetPoWHash(), block.nBits, consensusParams)) + return error("ReadBlockFromDisk: Errors in block header at %s", pos.ToString()); + } return true; } @@ -2318,14 +2320,19 @@ bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pin return true; } - // Reject proof of work at height nLastPOWBlock + // Check block version + if (block.nVersion < 7 && chainparams.GetConsensus().IsProtocolV2(block.GetBlockTime())) + return state.DoS(100, error("%s: rejected nVersion=%d block", __func__, block.nVersion), + REJECT_OBSOLETE, "bad-version"); + + // Reject proof of work at height > nLastPOWBlock if (block.IsProofOfWork() && pindex->nHeight > chainparams.GetConsensus().nLastPOWBlock) - return state.DoS(100, error("ConnectBlock(): reject proof-of-work at height %d", pindex->nHeight), + return state.DoS(100, error("%s: reject proof-of-work at height %d", __func__, pindex->nHeight), REJECT_INVALID, "bad-pow-height"); - + // Check difficulty if (block.nBits != GetNextTargetRequired(pindex->pprev, &block, chainparams.GetConsensus(), block.IsProofOfStake())) - return state.DoS(100, error("ConnectBlock(): incorrect difficulty"), + return state.DoS(100, error("%s: incorrect difficulty", __func__), REJECT_INVALID, "bad-diffbits"); pindex->nStakeModifier = ComputeStakeModifier(pindex->pprev, block.IsProofOfStake() ? block.vtx[1].vin[0].prevout.hash : pindex->GetBlockHash()); @@ -2412,11 +2419,13 @@ bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pin flags |= SCRIPT_VERIFY_NULLDUMMY; } -// Start enforcing BIP68 (sequence locks) and BIP112 (CHECKSEQUENCEVERIFY) using versionbits logic. -// int nLockTimeFlags = 0; -// if (VersionBitsState(pindex->pprev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_CSV, versionbitscache) == THRESHOLD_ACTIVE) { -// flags |= SCRIPT_VERIFY_CHECKSEQUENCEVERIFY; -// } + /* + Start enforcing BIP68 (sequence locks) and BIP112 (CHECKSEQUENCEVERIFY) using versionbits logic. + int nLockTimeFlags = 0; + if (VersionBitsState(pindex->pprev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_CSV, versionbitscache) == THRESHOLD_ACTIVE) { + flags |= SCRIPT_VERIFY_CHECKSEQUENCEVERIFY; + } + */ int64_t nTime2 = GetTimeMicros(); nTimeForks += nTime2 - nTime1; LogPrint("bench", " - Fork checks: %.2fms [%.2fs]\n", 0.001 * (nTime2 - nTime1), nTimeForks * 0.000001); @@ -3399,14 +3408,7 @@ static bool CheckBlockSignature(const CBlock& block) bool CheckBlockHeader(const CBlockHeader& block, CValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW) { - if (block.nVersion < 7 && Params().GetConsensus().IsProtocolV2(block.GetBlockTime())) - return state.Invalid(error("%s: rejected nVersion=%d block", __func__, block.nVersion), - REJECT_OBSOLETE, "bad-version"); - - // Check proof of work matches claimed amount - if (fCheckPOW && !CheckProofOfWork(block.GetHash(), block.nBits, consensusParams)) - return state.DoS(50, error("CheckBlockHeader(): proof of work failed"), - REJECT_INVALID, "high-hash"); + // This is redundant for proof-of-stake currency as blocks have to be fully downloaded to be checked return true; } @@ -3451,21 +3453,23 @@ bool CheckBlock(const CBlock& block, CValidationState& state, const Consensus::P if (block.vtx.empty() || !block.vtx[0].IsCoinBase()) return state.DoS(100, error("CheckBlock(): first tx is not coinbase"), REJECT_INVALID, "bad-cb-missing"); + for (unsigned int i = 1; i < block.vtx.size(); i++) if (block.vtx[i].IsCoinBase()) return state.DoS(100, error("CheckBlock(): more than one coinbase"), REJECT_INVALID, "bad-cb-multiple"); + // Check coinbase timestamp if (block.GetBlockTime() > FutureDrift(block.vtx[0].nTime)) - return state.DoS(25, error("CheckBlock(): coinbase timestamp is too early"), + return state.DoS(50, error("CheckBlock(): coinbase timestamp is too early"), REJECT_INVALID, "bad-cb-time"); + // Check coinstake timestamp if (block.IsProofOfStake() && !CheckCoinStakeTimestamp(block.GetBlockTime(), block.vtx[1].nTime)) return state.DoS(50, error("CheckBlock(): coinstake timestamp violation nTimeBlock=%d nTimeTx=%u", block.GetBlockTime(), block.vtx[1].nTime), REJECT_INVALID, "bad-cs-time"); - if (block.IsProofOfStake()) - { + if (block.IsProofOfStake()) { // Coinbase output must be empty if proof-of-stake block if (block.vtx[0].vout.size() != 1 || !block.vtx[0].vout[0].IsEmpty()) return state.DoS(100, error("CheckBlock(): coinbase output not empty for proof-of-stake block"), @@ -3481,6 +3485,11 @@ bool CheckBlock(const CBlock& block, CValidationState& state, const Consensus::P REJECT_INVALID, "bad-cs-multiple"); } + // Check proof of work hash + if (block.IsProofOfWork() && fCheckPOW && !CheckProofOfWork(block.GetPoWHash(), block.nBits, consensusParams)) + return state.DoS(100, error("CheckBlock(): proof of work failed"), + REJECT_INVALID, "high-hash"); + // Check proof-of-stake block signature if (fCheckSig && !CheckBlockSignature(block)) return state.DoS(100, error("CheckBlock(): bad proof-of-stake block signature"), @@ -3592,6 +3601,100 @@ bool ContextualCheckBlock(const CBlock& block, CValidationState& state, CBlockIn return true; } +bool CheckStake(CBlock* pblock, CWallet& wallet, const CChainParams& chainparams) +{ + uint256 hashBlock = pblock->GetHash(); + + if(!pblock->IsProofOfStake()) + return error("CheckStake() : %s is not a proof-of-stake block", hashBlock.GetHex()); + + CValidationState state; + // verify hash target and signature of coinstake tx + if (!CheckProofOfStake(mapBlockIndex[pblock->hashPrevBlock], pblock->vtx[1], pblock->nBits, state)) + return error("CheckStake() : proof-of-stake checking failed"); + + //// debug print + LogPrintf("%s\n", pblock->ToString()); + LogPrintf("out %s\n", FormatMoney(pblock->vtx[1].GetValueOut())); + + // Found a solution + { + LOCK(cs_main); + if (pblock->hashPrevBlock != chainActive.Tip()->GetBlockHash()) + return error("CheckStake() : generated block is stale"); + + // Track how many getdata requests this block gets + { + LOCK(wallet.cs_wallet); + wallet.mapRequestCount[hashBlock] = 0; + } + + // Process this block the same as if we had received it from another node + if (!ProcessNewBlock(state, chainparams, NULL, pblock, true, NULL)) + return error("CheckStake() : ProcessNewBlock, block not accepted"); + } + + return true; +} + +// novacoin: attempt to generate suitable proof-of-stake +bool SignBlock(CBlock& block, CWallet& wallet, int64_t& nFees) +{ + // if we are trying to sign + // something except proof-of-stake block template + if (!block.vtx[0].vout[0].IsEmpty()){ + LogPrintf("something except proof-of-stake block\n"); + return false; + } + + // if we are trying to sign + // a complete proof-of-stake block + if (block.IsProofOfStake()){ + LogPrintf("trying to sign a complete proof-of-stake block\n"); + return true; + } + + static int64_t nLastCoinStakeSearchTime = GetAdjustedTime(); // startup timestamp + + CKey key; + CMutableTransaction txCoinBase(block.vtx[0]); + CMutableTransaction txCoinStake; + txCoinStake.nTime = GetAdjustedTime(); + txCoinStake.nTime &= ~Params().GetConsensus().nStakeTimestampMask; + + int64_t nSearchTime = txCoinStake.nTime; // search to current time + + if (nSearchTime > nLastCoinStakeSearchTime) + { + if (wallet.CreateCoinStake(wallet, block.nBits, 1, nFees, txCoinStake, key)) + { + if (txCoinStake.nTime >= pindexBestHeader->GetPastTimeLimit()+1) + { + // make sure coinstake would meet timestamp protocol + // as it would be the same as the block timestamp + txCoinBase.nTime = block.nTime = txCoinStake.nTime; + block.vtx[0] = txCoinBase; + + // we have to make sure that we have no future timestamps in + // our transactions set + for (vector::iterator it = block.vtx.begin(); it != block.vtx.end();) + if (it->nTime > block.nTime) { it = block.vtx.erase(it); } else { ++it; } + + block.vtx.insert(block.vtx.begin() + 1, txCoinStake); + + block.hashMerkleRoot = BlockMerkleRoot(block); + + // append a signature to our block + return key.Sign(block.GetHash(), block.vchBlockSig); + } + } + nLastCoinStakeSearchInterval = nSearchTime - nLastCoinStakeSearchTime; + nLastCoinStakeSearchTime = nSearchTime; + } + + return false; +} + static bool AcceptBlockHeader(const CBlockHeader& block, CValidationState& state, const CChainParams& chainparams, CBlockIndex** ppindex=NULL) { AssertLockHeld(cs_main); @@ -3781,7 +3884,7 @@ bool TestBlockValidity(CValidationState& state, const CChainParams& chainparams, if (!ContextualCheckBlock(block, state, pindexPrev)) return error("%s: Consensus::ContextualCheckBlock: %s", __func__, FormatStateMessage(state)); if (!ConnectBlock(block, state, &indexDummy, viewNew, chainparams, true)) - return false; + return error("%s: Consensus::ConnectBlock: %s", __func__, FormatStateMessage(state)); assert(state.IsValid()); return true; diff --git a/src/main.h b/src/main.h index 1ee4b7257..74f55b699 100644 --- a/src/main.h +++ b/src/main.h @@ -471,6 +471,10 @@ bool CheckBlock(const CBlock& block, CValidationState& state, const Consensus::P bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationState& state, const Consensus::Params& consensusParams, CBlockIndex *pindexPrev); bool ContextualCheckBlock(const CBlock& block, CValidationState& state, CBlockIndex *pindexPrev); +/** Proof-of-stake checks */ +bool CheckStake(CBlock* pblock, CWallet& wallet, const CChainParams& chainparams); +bool SignBlock(CBlock& block, CWallet& wallet, int64_t& nFees); + /** Check a block is completely valid from start to finish (only works on top of our current best block, with cs_main held) */ bool TestBlockValidity(CValidationState& state, const CChainParams& chainparams, const CBlock& block, CBlockIndex* pindexPrev, bool fCheckPOW = true, bool fCheckMerkleRoot = true, bool fCheckSig = true); diff --git a/src/miner.cpp b/src/miner.cpp index 528c6342a..2d834d11b 100644 --- a/src/miner.cpp +++ b/src/miner.cpp @@ -106,12 +106,11 @@ CBlockTemplate* CreateNewBlock(const CChainParams& chainparams, const CScript& s txNew.vin[0].prevout.SetNull(); txNew.vout.resize(1); int nHeight = chainActive.Tip()->nHeight + 1; - if (!fProofOfStake) - { + + if (!fProofOfStake) { txNew.vout[0].scriptPubKey = scriptPubKeyIn; } - else - { + else { txNew.vin[0].scriptSig = (CScript() << nHeight) + COINBASE_FLAGS; txNew.vout[0].SetEmpty(); } @@ -352,67 +351,6 @@ void IncrementExtraNonce(CBlock* pblock, const CBlockIndex* pindexPrev, unsigned pblock->hashMerkleRoot = BlockMerkleRoot(*pblock); } -#ifdef ENABLE_WALLET -// novacoin: attempt to generate suitable proof-of-stake -bool SignBlock(CBlock& block, CWallet& wallet, int64_t& nFees) -{ - // if we are trying to sign - // something except proof-of-stake block template - if (!block.vtx[0].vout[0].IsEmpty()){ - LogPrintf("something except proof-of-stake block\n"); - return false; - } - - // if we are trying to sign - // a complete proof-of-stake block - if (block.IsProofOfStake()){ - LogPrintf("trying to sign a complete proof-of-stake block\n"); - return true; - } - - static int64_t nLastCoinStakeSearchTime = GetAdjustedTime(); // startup timestamp - - CKey key; - CMutableTransaction txCoinBase(block.vtx[0]); - CMutableTransaction txCoinStake; - txCoinStake.nTime = GetAdjustedTime(); - txCoinStake.nTime &= ~Params().GetConsensus().nStakeTimestampMask; - - int64_t nSearchTime = txCoinStake.nTime; // search to current time - - - if (nSearchTime > nLastCoinStakeSearchTime) - { - if (wallet.CreateCoinStake(wallet, block.nBits, 1, nFees, txCoinStake, key)) - { - if (txCoinStake.nTime >= pindexBestHeader->GetPastTimeLimit()+1) - { - // make sure coinstake would meet timestamp protocol - // as it would be the same as the block timestamp - txCoinBase.nTime = block.nTime = txCoinStake.nTime; - block.vtx[0] = txCoinBase; - - // we have to make sure that we have no future timestamps in - // our transactions set - for (vector::iterator it = block.vtx.begin(); it != block.vtx.end();) - if (it->nTime > block.nTime) { it = block.vtx.erase(it); } else { ++it; } - - block.vtx.insert(block.vtx.begin() + 1, txCoinStake); - - block.hashMerkleRoot = BlockMerkleRoot(block); - - // append a signature to our block - return key.Sign(block.GetHash(), block.vchBlockSig); - } - } - nLastCoinStakeSearchInterval = nSearchTime - nLastCoinStakeSearchTime; - nLastCoinStakeSearchTime = nSearchTime; - } - - return false; -} -#endif - void ThreadStakeMiner(CWallet *pwallet, const CChainParams& chainparams) { SetThreadPriority(THREAD_PRIORITY_LOWEST); @@ -481,39 +419,3 @@ void ThreadStakeMiner(CWallet *pwallet, const CChainParams& chainparams) MilliSleep(nMinerSleep); } } - -bool CheckStake(CBlock* pblock, CWallet& wallet, const CChainParams& chainparams) -{ - uint256 hashBlock = pblock->GetHash(); - - if(!pblock->IsProofOfStake()) - return error("CheckStake() : %s is not a proof-of-stake block", hashBlock.GetHex()); - - CValidationState state; - // verify hash target and signature of coinstake tx - if (!CheckProofOfStake(mapBlockIndex[pblock->hashPrevBlock], pblock->vtx[1], pblock->nBits, state)) - return error("CheckStake() : proof-of-stake checking failed"); - - //// debug print - LogPrintf("%s\n", pblock->ToString()); - LogPrintf("out %s\n", FormatMoney(pblock->vtx[1].GetValueOut())); - - // Found a solution - { - LOCK(cs_main); - if (pblock->hashPrevBlock != chainActive.Tip()->GetBlockHash()) - return error("CheckStake() : generated block is stale"); - - // Track how many getdata requests this block gets - { - LOCK(wallet.cs_wallet); - wallet.mapRequestCount[hashBlock] = 0; - } - - // Process this block the same as if we had received it from another node - if (!ProcessBlockFound(pblock, chainparams)) - return error("CheckStake() : ProcessBlock, block not accepted"); - } - - return true; -} diff --git a/src/miner.h b/src/miner.h index 0a8cdaea4..ffa2a90b8 100644 --- a/src/miner.h +++ b/src/miner.h @@ -27,15 +27,13 @@ struct CBlockTemplate std::vector vTxSigOps; }; -/** Run the miner threads */ -void ThreadStakeMiner(CWallet *pwallet, const CChainParams& chainparams); -/** Sign a block */ -bool SignBlock(CBlock& block, CWallet& wallet, int64_t& nFees); +CAmount GetProofOfWorkReward(); /** Generate a new block, without valid proof-of-work */ CBlockTemplate* CreateNewBlock(const CChainParams& chainparams, const CScript& scriptPubKeyIn, int64_t* nFees = 0, bool fProofOfStake = false); /** Modify the extranonce in a block */ void IncrementExtraNonce(CBlock* pblock, const CBlockIndex* pindexPrev, unsigned int& nExtraNonce); int64_t UpdateTime(CBlock* pblock, const Consensus::Params& consensusParams, const CBlockIndex* pindexPrev); -bool CheckStake(CBlock* pblock, CWallet& wallet, const CChainParams& chainparams); -CAmount GetProofOfWorkReward(); +/** Run the miner threads */ +void ThreadStakeMiner(CWallet *pwallet, const CChainParams& chainparams); + #endif // BITCOIN_MINER_H diff --git a/src/pow.cpp b/src/pow.cpp index 97c9a3592..d7ce65793 100644 --- a/src/pow.cpp +++ b/src/pow.cpp @@ -30,22 +30,21 @@ static arith_uint256 GetTargetLimit(int64_t nTime, const Consensus::Params& para unsigned int GetNextTargetRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params& params, bool fProofOfStake) { + unsigned int nTargetLimit = GetTargetLimit(pindexLast->GetBlockTime(), params, fProofOfStake).GetCompact(); + // Genesis block if (pindexLast == NULL) return UintToArith256(params.powLimit).GetCompact(); - else { - unsigned int nTargetLimit = GetTargetLimit(pindexLast->GetBlockTime(), params, fProofOfStake).GetCompact(); - const CBlockIndex* pindexPrev = GetLastBlockIndex(pindexLast, fProofOfStake); + const CBlockIndex* pindexPrev = GetLastBlockIndex(pindexLast, fProofOfStake); - if (pindexPrev->pprev == NULL) - return nTargetLimit; // first block - const CBlockIndex* pindexPrevPrev = GetLastBlockIndex(pindexPrev->pprev, fProofOfStake); - if (pindexPrevPrev->pprev == NULL) - return nTargetLimit; // second block + if (pindexPrev->pprev == NULL) + return nTargetLimit; // first block + const CBlockIndex* pindexPrevPrev = GetLastBlockIndex(pindexPrev->pprev, fProofOfStake); + if (pindexPrevPrev->pprev == NULL) + return nTargetLimit; // second block - return CalculateNextTargetRequired(pindexPrev, pindexPrevPrev->GetBlockTime(), params, fProofOfStake); - } + return CalculateNextTargetRequired(pindexPrev, pindexPrevPrev->GetBlockTime(), params, fProofOfStake); } unsigned int CalculateNextTargetRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime, const Consensus::Params& params, bool fProofOfStake) diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp index 2b8195311..18c44ad79 100644 --- a/src/rpc/mining.cpp +++ b/src/rpc/mining.cpp @@ -124,7 +124,7 @@ UniValue generateBlocks(std::shared_ptr coinbaseScript, int nGen LOCK(cs_main); IncrementExtraNonce(pblock, chainActive.Tip(), nExtraNonce); } - while (nMaxTries > 0 && pblock->nNonce < nInnerLoopCount && !CheckProofOfWork(pblock->GetHash(), pblock->nBits, Params().GetConsensus())) { + while (nMaxTries > 0 && pblock->nNonce < nInnerLoopCount && !CheckProofOfWork(pblock->GetPoWHash(), pblock->nBits, Params().GetConsensus())) { ++pblock->nNonce; --nMaxTries; }