aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--src/Makefile.am1
-rw-r--r--src/chainparams.cpp51
-rw-r--r--src/chainparams.h35
-rw-r--r--src/consensus/params.h32
-rw-r--r--src/main.cpp6
-rw-r--r--src/main.h1
-rw-r--r--src/miner.cpp4
-rw-r--r--src/pow.cpp39
-rw-r--r--src/pow.h8
-rw-r--r--src/rpcmining.cpp2
-rw-r--r--src/test/pow_tests.cpp13
-rw-r--r--src/txdb.cpp4
12 files changed, 112 insertions, 84 deletions
diff --git a/src/Makefile.am b/src/Makefile.am
index 1b3e0d9d5b..37184b6286 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -87,6 +87,7 @@ BITCOIN_CORE_H = \
coins.h \
compat.h \
compressor.h \
+ consensus/params.h \
core_io.h \
wallet/db.h \
eccryptoverify.h \
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index 2bc8976510..3e20d9f8f2 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -101,6 +101,14 @@ class CMainParams : public CChainParams {
public:
CMainParams() {
strNetworkID = "main";
+ consensus.nSubsidyHalvingInterval = 210000;
+ consensus.nMajorityEnforceBlockUpgrade = 750;
+ consensus.nMajorityRejectBlockOutdated = 950;
+ consensus.nMajorityWindow = 1000;
+ consensus.powLimit = ~arith_uint256(0) >> 32;
+ consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
+ consensus.nPowTargetSpacing = 10 * 60;
+ consensus.fPowAllowMinDifficultyBlocks = false;
/**
* The message start string is designed to be unlikely to occur in normal data.
* The characters are rarely used upper ASCII, not valid as UTF-8, and produce
@@ -112,14 +120,7 @@ public:
pchMessageStart[3] = 0xd9;
vAlertPubKey = ParseHex("04fc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284");
nDefaultPort = 8333;
- bnProofOfWorkLimit = ~arith_uint256(0) >> 32;
- nSubsidyHalvingInterval = 210000;
- nEnforceBlockUpgradeMajority = 750;
- nRejectBlockOutdatedMajority = 950;
- nToCheckBlockUpgradeMajority = 1000;
nMinerThreads = 0;
- nTargetTimespan = 14 * 24 * 60 * 60; // two weeks
- nTargetSpacing = 10 * 60;
/**
* Build the genesis block. Note that the output of the genesis coinbase cannot
@@ -146,8 +147,8 @@ public:
genesis.nBits = 0x1d00ffff;
genesis.nNonce = 2083236893;
- hashGenesisBlock = genesis.GetHash();
- assert(hashGenesisBlock == uint256S("0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"));
+ consensus.hashGenesisBlock = genesis.GetHash();
+ assert(consensus.hashGenesisBlock == uint256S("0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"));
assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
vSeeds.push_back(CDNSSeedData("bitcoin.sipa.be", "seed.bitcoin.sipa.be"));
@@ -167,7 +168,6 @@ public:
fRequireRPCPassword = true;
fMiningRequiresPeers = true;
fDefaultCheckMemPool = false;
- fAllowMinDifficultyBlocks = false;
fRequireStandard = true;
fMineBlocksOnDemand = false;
fTestnetToBeDeprecatedFieldRPC = false;
@@ -187,24 +187,23 @@ class CTestNetParams : public CMainParams {
public:
CTestNetParams() {
strNetworkID = "test";
+ consensus.nMajorityEnforceBlockUpgrade = 51;
+ consensus.nMajorityRejectBlockOutdated = 75;
+ consensus.nMajorityWindow = 100;
+ consensus.fPowAllowMinDifficultyBlocks = true;
pchMessageStart[0] = 0x0b;
pchMessageStart[1] = 0x11;
pchMessageStart[2] = 0x09;
pchMessageStart[3] = 0x07;
vAlertPubKey = ParseHex("04302390343f91cc401d56d68b123028bf52e5fca1939df127f63c6467cdf9c8e2c14b61104cf817d0b780da337893ecc4aaff1309e536162dabbdb45200ca2b0a");
nDefaultPort = 18333;
- nEnforceBlockUpgradeMajority = 51;
- nRejectBlockOutdatedMajority = 75;
- nToCheckBlockUpgradeMajority = 100;
nMinerThreads = 0;
- nTargetTimespan = 14 * 24 * 60 * 60; //! two weeks
- nTargetSpacing = 10 * 60;
//! Modify the testnet genesis block so the timestamp is valid for a later start.
genesis.nTime = 1296688602;
genesis.nNonce = 414098458;
- hashGenesisBlock = genesis.GetHash();
- assert(hashGenesisBlock == uint256S("0x000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"));
+ consensus.hashGenesisBlock = genesis.GetHash();
+ assert(consensus.hashGenesisBlock == uint256S("0x000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"));
vFixedSeeds.clear();
vSeeds.clear();
@@ -224,7 +223,6 @@ public:
fRequireRPCPassword = true;
fMiningRequiresPeers = true;
fDefaultCheckMemPool = false;
- fAllowMinDifficultyBlocks = true;
fRequireStandard = false;
fMineBlocksOnDemand = false;
fTestnetToBeDeprecatedFieldRPC = true;
@@ -243,24 +241,22 @@ class CRegTestParams : public CTestNetParams {
public:
CRegTestParams() {
strNetworkID = "regtest";
+ consensus.nSubsidyHalvingInterval = 150;
+ consensus.nMajorityEnforceBlockUpgrade = 750;
+ consensus.nMajorityRejectBlockOutdated = 950;
+ consensus.nMajorityWindow = 1000;
+ consensus.powLimit = ~arith_uint256(0) >> 1;
pchMessageStart[0] = 0xfa;
pchMessageStart[1] = 0xbf;
pchMessageStart[2] = 0xb5;
pchMessageStart[3] = 0xda;
- nSubsidyHalvingInterval = 150;
- nEnforceBlockUpgradeMajority = 750;
- nRejectBlockOutdatedMajority = 950;
- nToCheckBlockUpgradeMajority = 1000;
nMinerThreads = 1;
- nTargetTimespan = 14 * 24 * 60 * 60; //! two weeks
- nTargetSpacing = 10 * 60;
- bnProofOfWorkLimit = ~arith_uint256(0) >> 1;
genesis.nTime = 1296688602;
genesis.nBits = 0x207fffff;
genesis.nNonce = 2;
- hashGenesisBlock = genesis.GetHash();
+ consensus.hashGenesisBlock = genesis.GetHash();
nDefaultPort = 18444;
- assert(hashGenesisBlock == uint256S("0x0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"));
+ assert(consensus.hashGenesisBlock == uint256S("0x0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"));
vFixedSeeds.clear(); //! Regtest mode doesn't have any fixed seeds.
vSeeds.clear(); //! Regtest mode doesn't have any DNS seeds.
@@ -268,7 +264,6 @@ public:
fRequireRPCPassword = false;
fMiningRequiresPeers = false;
fDefaultCheckMemPool = true;
- fAllowMinDifficultyBlocks = true;
fRequireStandard = false;
fMineBlocksOnDemand = true;
fTestnetToBeDeprecatedFieldRPC = false;
diff --git a/src/chainparams.h b/src/chainparams.h
index 134dcd6558..aa2ec1e301 100644
--- a/src/chainparams.h
+++ b/src/chainparams.h
@@ -6,11 +6,12 @@
#ifndef BITCOIN_CHAINPARAMS_H
#define BITCOIN_CHAINPARAMS_H
+#include "arith_uint256.h"
#include "chainparamsbase.h"
#include "checkpoints.h"
+#include "consensus/params.h"
#include "primitives/block.h"
#include "protocol.h"
-#include "arith_uint256.h"
#include <vector>
@@ -39,16 +40,16 @@ public:
MAX_BASE58_TYPES
};
- const uint256& HashGenesisBlock() const { return hashGenesisBlock; }
+ const Consensus::Params& GetConsensus() const { return consensus; }
+ const uint256& HashGenesisBlock() const { return consensus.hashGenesisBlock; }
const CMessageHeader::MessageStartChars& MessageStart() const { return pchMessageStart; }
const std::vector<unsigned char>& AlertKey() const { return vAlertPubKey; }
int GetDefaultPort() const { return nDefaultPort; }
- const arith_uint256& ProofOfWorkLimit() const { return bnProofOfWorkLimit; }
- int SubsidyHalvingInterval() const { return nSubsidyHalvingInterval; }
- /** Used to check majorities for block version upgrade */
- int EnforceBlockUpgradeMajority() const { return nEnforceBlockUpgradeMajority; }
- int RejectBlockOutdatedMajority() const { return nRejectBlockOutdatedMajority; }
- int ToCheckBlockUpgradeMajority() const { return nToCheckBlockUpgradeMajority; }
+ const arith_uint256& ProofOfWorkLimit() const { return consensus.powLimit; }
+ int SubsidyHalvingInterval() const { return consensus.nSubsidyHalvingInterval; }
+ int EnforceBlockUpgradeMajority() const { return consensus.nMajorityEnforceBlockUpgrade; }
+ int RejectBlockOutdatedMajority() const { return consensus.nMajorityRejectBlockOutdated; }
+ int ToCheckBlockUpgradeMajority() const { return consensus.nMajorityWindow; }
/** Used if GenerateBitcoins is called with a negative number of threads */
int DefaultMinerThreads() const { return nMinerThreads; }
@@ -59,12 +60,12 @@ public:
/** Default value for -checkmempool argument */
bool DefaultCheckMemPool() const { return fDefaultCheckMemPool; }
/** Allow mining of a min-difficulty block */
- bool AllowMinDifficultyBlocks() const { return fAllowMinDifficultyBlocks; }
+ bool AllowMinDifficultyBlocks() const { return consensus.fPowAllowMinDifficultyBlocks; }
/** Make standard checks */
bool RequireStandard() const { return fRequireStandard; }
- int64_t TargetTimespan() const { return nTargetTimespan; }
- int64_t TargetSpacing() const { return nTargetSpacing; }
- int64_t DifficultyAdjustmentInterval() const { return nTargetTimespan / nTargetSpacing; }
+ int64_t TargetTimespan() const { return consensus.nPowTargetTimespan; }
+ int64_t TargetSpacing() const { return consensus.nPowTargetSpacing; }
+ int64_t DifficultyAdjustmentInterval() const { return consensus.nPowTargetTimespan / consensus.nPowTargetSpacing; }
/** Make miner stop after a block is found. In RPC, don't return until nGenProcLimit blocks are generated */
bool MineBlocksOnDemand() const { return fMineBlocksOnDemand; }
/** In the future use NetworkIDString() for RPC fields */
@@ -78,18 +79,11 @@ public:
protected:
CChainParams() {}
- uint256 hashGenesisBlock;
+ Consensus::Params consensus;
CMessageHeader::MessageStartChars pchMessageStart;
//! Raw pub key bytes for the broadcast alert signing key.
std::vector<unsigned char> vAlertPubKey;
int nDefaultPort;
- arith_uint256 bnProofOfWorkLimit;
- int nSubsidyHalvingInterval;
- int nEnforceBlockUpgradeMajority;
- int nRejectBlockOutdatedMajority;
- int nToCheckBlockUpgradeMajority;
- int64_t nTargetTimespan;
- int64_t nTargetSpacing;
int nMinerThreads;
std::vector<CDNSSeedData> vSeeds;
std::vector<unsigned char> base58Prefixes[MAX_BASE58_TYPES];
@@ -99,7 +93,6 @@ protected:
bool fRequireRPCPassword;
bool fMiningRequiresPeers;
bool fDefaultCheckMemPool;
- bool fAllowMinDifficultyBlocks;
bool fRequireStandard;
bool fMineBlocksOnDemand;
bool fTestnetToBeDeprecatedFieldRPC;
diff --git a/src/consensus/params.h b/src/consensus/params.h
new file mode 100644
index 0000000000..c4cfa48c7e
--- /dev/null
+++ b/src/consensus/params.h
@@ -0,0 +1,32 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2014 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_CONSENSUS_CONSENSUS_PARAMS_H
+#define BITCOIN_CONSENSUS_CONSENSUS_PARAMS_H
+
+#include "arith_uint256.h"
+#include "uint256.h"
+
+namespace Consensus {
+/**
+ * Parameters that influence chain consensus.
+ */
+struct Params {
+ uint256 hashGenesisBlock;
+ int nSubsidyHalvingInterval;
+ /** Used to check majorities for block version upgrade */
+ int nMajorityEnforceBlockUpgrade;
+ int nMajorityRejectBlockOutdated;
+ int nMajorityWindow;
+ /** Proof of work parameters */
+ arith_uint256 powLimit;
+ bool fPowAllowMinDifficultyBlocks;
+ int64_t nPowTargetSpacing;
+ int64_t nPowTargetTimespan;
+ int64_t DifficultyAdjustmentInterval() const { return nPowTargetTimespan / nPowTargetSpacing; }
+};
+} // namespace Consensus
+
+#endif // BITCOIN_CONSENSUS_CONSENSUS_PARAMS_H
diff --git a/src/main.cpp b/src/main.cpp
index 0ffacc338e..1d78eedc1a 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1158,7 +1158,7 @@ bool ReadBlockFromDisk(CBlock& block, const CDiskBlockPos& pos)
}
// Check the header
- if (!CheckProofOfWork(block.GetHash(), block.nBits))
+ if (!CheckProofOfWork(block.GetHash(), block.nBits, Params().GetConsensus()))
return error("ReadBlockFromDisk: Errors in block header at %s", pos.ToString());
return true;
@@ -2462,7 +2462,7 @@ bool FindUndoPos(CValidationState &state, int nFile, CDiskBlockPos &pos, unsigne
bool CheckBlockHeader(const CBlockHeader& block, CValidationState& state, bool fCheckPOW)
{
// Check proof of work matches claimed amount
- if (fCheckPOW && !CheckProofOfWork(block.GetHash(), block.nBits))
+ if (fCheckPOW && !CheckProofOfWork(block.GetHash(), block.nBits, Params().GetConsensus()))
return state.DoS(50, error("CheckBlockHeader(): proof of work failed"),
REJECT_INVALID, "high-hash");
@@ -2545,7 +2545,7 @@ bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationState& sta
int nHeight = pindexPrev->nHeight+1;
// Check proof of work
- if ((block.nBits != GetNextWorkRequired(pindexPrev, &block)))
+ if (block.nBits != GetNextWorkRequired(pindexPrev, &block, Params().GetConsensus()))
return state.DoS(100, error("%s: incorrect proof of work", __func__),
REJECT_INVALID, "bad-diffbits");
diff --git a/src/main.h b/src/main.h
index b0bab6f7bf..09ffc4d28b 100644
--- a/src/main.h
+++ b/src/main.h
@@ -17,7 +17,6 @@
#include "primitives/block.h"
#include "primitives/transaction.h"
#include "net.h"
-#include "pow.h"
#include "script/script.h"
#include "script/sigcache.h"
#include "script/standard.h"
diff --git a/src/miner.cpp b/src/miner.cpp
index 01212b19c4..cf08b78229 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -84,7 +84,7 @@ void UpdateTime(CBlockHeader* pblock, const CBlockIndex* pindexPrev)
// Updating time can change work required on testnet:
if (Params().AllowMinDifficultyBlocks())
- pblock->nBits = GetNextWorkRequired(pindexPrev, pblock);
+ pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, Params().GetConsensus());
}
CBlockTemplate* CreateNewBlock(const CScript& scriptPubKeyIn)
@@ -326,7 +326,7 @@ CBlockTemplate* CreateNewBlock(const CScript& scriptPubKeyIn)
// Fill in header
pblock->hashPrevBlock = pindexPrev->GetBlockHash();
UpdateTime(pblock, pindexPrev);
- pblock->nBits = GetNextWorkRequired(pindexPrev, pblock);
+ pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, Params().GetConsensus());
pblock->nNonce = 0;
pblocktemplate->vTxSigOps[0] = GetLegacySigOpCount(pblock->vtx[0]);
diff --git a/src/pow.cpp b/src/pow.cpp
index eb899ffc94..3c5a8d9d96 100644
--- a/src/pow.cpp
+++ b/src/pow.cpp
@@ -7,34 +7,33 @@
#include "arith_uint256.h"
#include "chain.h"
-#include "chainparams.h"
#include "primitives/block.h"
#include "uint256.h"
#include "util.h"
-unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock)
+unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params& params)
{
- unsigned int nProofOfWorkLimit = Params().ProofOfWorkLimit().GetCompact();
+ unsigned int nProofOfWorkLimit = params.powLimit.GetCompact();
// Genesis block
if (pindexLast == NULL)
return nProofOfWorkLimit;
// Only change once per difficulty adjustment interval
- if ((pindexLast->nHeight+1) % Params().DifficultyAdjustmentInterval() != 0)
+ if ((pindexLast->nHeight+1) % params.DifficultyAdjustmentInterval() != 0)
{
- if (Params().AllowMinDifficultyBlocks())
+ if (params.fPowAllowMinDifficultyBlocks)
{
// Special difficulty rule for testnet:
// If the new block's timestamp is more than 2* 10 minutes
// then allow mining of a min-difficulty block.
- if (pblock->GetBlockTime() > pindexLast->GetBlockTime() + Params().TargetSpacing()*2)
+ if (pblock->GetBlockTime() > pindexLast->GetBlockTime() + params.nPowTargetSpacing*2)
return nProofOfWorkLimit;
else
{
// Return the last non-special-min-difficulty-rules-block
const CBlockIndex* pindex = pindexLast;
- while (pindex->pprev && pindex->nHeight % Params().DifficultyAdjustmentInterval() != 0 && pindex->nBits == nProofOfWorkLimit)
+ while (pindex->pprev && pindex->nHeight % params.DifficultyAdjustmentInterval() != 0 && pindex->nBits == nProofOfWorkLimit)
pindex = pindex->pprev;
return pindex->nBits;
}
@@ -44,22 +43,22 @@ unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHead
// Go back by what we want to be 14 days worth of blocks
const CBlockIndex* pindexFirst = pindexLast;
- for (int i = 0; pindexFirst && i < Params().DifficultyAdjustmentInterval()-1; i++)
+ for (int i = 0; pindexFirst && i < params.DifficultyAdjustmentInterval()-1; i++)
pindexFirst = pindexFirst->pprev;
assert(pindexFirst);
- return CalculateNextWorkRequired(pindexLast, pindexFirst->GetBlockTime());
+ return CalculateNextWorkRequired(pindexLast, pindexFirst->GetBlockTime(), params);
}
-unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime)
+unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime, const Consensus::Params& params)
{
// Limit adjustment step
int64_t nActualTimespan = pindexLast->GetBlockTime() - nFirstBlockTime;
LogPrintf(" nActualTimespan = %d before bounds\n", nActualTimespan);
- if (nActualTimespan < Params().TargetTimespan()/4)
- nActualTimespan = Params().TargetTimespan()/4;
- if (nActualTimespan > Params().TargetTimespan()*4)
- nActualTimespan = Params().TargetTimespan()*4;
+ if (nActualTimespan < params.nPowTargetTimespan/4)
+ nActualTimespan = params.nPowTargetTimespan/4;
+ if (nActualTimespan > params.nPowTargetTimespan*4)
+ nActualTimespan = params.nPowTargetTimespan*4;
// Retarget
arith_uint256 bnNew;
@@ -67,21 +66,21 @@ unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nF
bnNew.SetCompact(pindexLast->nBits);
bnOld = bnNew;
bnNew *= nActualTimespan;
- bnNew /= Params().TargetTimespan();
+ bnNew /= params.nPowTargetTimespan;
- if (bnNew > Params().ProofOfWorkLimit())
- bnNew = Params().ProofOfWorkLimit();
+ if (bnNew > params.powLimit)
+ bnNew = params.powLimit;
/// debug print
LogPrintf("GetNextWorkRequired RETARGET\n");
- LogPrintf("Params().TargetTimespan() = %d nActualTimespan = %d\n", Params().TargetTimespan(), nActualTimespan);
+ LogPrintf("params.nPowTargetTimespan = %d nActualTimespan = %d\n", params.nPowTargetTimespan, nActualTimespan);
LogPrintf("Before: %08x %s\n", pindexLast->nBits, bnOld.ToString());
LogPrintf("After: %08x %s\n", bnNew.GetCompact(), bnNew.ToString());
return bnNew.GetCompact();
}
-bool CheckProofOfWork(uint256 hash, unsigned int nBits)
+bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params& params)
{
bool fNegative;
bool fOverflow;
@@ -90,7 +89,7 @@ bool CheckProofOfWork(uint256 hash, unsigned int nBits)
bnTarget.SetCompact(nBits, &fNegative, &fOverflow);
// Check range
- if (fNegative || bnTarget == 0 || fOverflow || bnTarget > Params().ProofOfWorkLimit())
+ if (fNegative || bnTarget == 0 || fOverflow || bnTarget > params.powLimit)
return error("CheckProofOfWork(): nBits below minimum work");
// Check proof of work matches claimed amount
diff --git a/src/pow.h b/src/pow.h
index a5fbba6236..a5d32db178 100644
--- a/src/pow.h
+++ b/src/pow.h
@@ -6,6 +6,8 @@
#ifndef BITCOIN_POW_H
#define BITCOIN_POW_H
+#include "consensus/params.h"
+
#include <stdint.h>
class CBlockHeader;
@@ -13,11 +15,11 @@ class CBlockIndex;
class uint256;
class arith_uint256;
-unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock);
-unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime);
+unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params&);
+unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime, const Consensus::Params&);
/** Check whether a block hash satisfies the proof-of-work requirement specified by nBits */
-bool CheckProofOfWork(uint256 hash, unsigned int nBits);
+bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params&);
arith_uint256 GetBlockProof(const CBlockIndex& block);
#endif // BITCOIN_POW_H
diff --git a/src/rpcmining.cpp b/src/rpcmining.cpp
index 17db221cb4..fcba7e222d 100644
--- a/src/rpcmining.cpp
+++ b/src/rpcmining.cpp
@@ -181,7 +181,7 @@ Value setgenerate(const Array& params, bool fHelp)
LOCK(cs_main);
IncrementExtraNonce(pblock, chainActive.Tip(), nExtraNonce);
}
- while (!CheckProofOfWork(pblock->GetHash(), pblock->nBits)) {
+ while (!CheckProofOfWork(pblock->GetHash(), pblock->nBits, Params().GetConsensus())) {
// Yes, there is a chance every nonce could fail to satisfy the -regtest
// target -- 1 in 2^(2^32). That ain't gonna happen.
++pblock->nNonce;
diff --git a/src/test/pow_tests.cpp b/src/test/pow_tests.cpp
index 7b197c527d..4ce1591c35 100644
--- a/src/test/pow_tests.cpp
+++ b/src/test/pow_tests.cpp
@@ -17,51 +17,56 @@ BOOST_FIXTURE_TEST_SUITE(pow_tests, BasicTestingSetup)
BOOST_AUTO_TEST_CASE(get_next_work)
{
SelectParams(CBaseChainParams::MAIN);
+ const Consensus::Params& params = Params().GetConsensus();
int64_t nLastRetargetTime = 1261130161; // Block #30240
CBlockIndex pindexLast;
pindexLast.nHeight = 32255;
pindexLast.nTime = 1262152739; // Block #32255
pindexLast.nBits = 0x1d00ffff;
- BOOST_CHECK_EQUAL(CalculateNextWorkRequired(&pindexLast, nLastRetargetTime), 0x1d00d86a);
+ BOOST_CHECK_EQUAL(CalculateNextWorkRequired(&pindexLast, nLastRetargetTime, params), 0x1d00d86a);
}
/* Test the constraint on the upper bound for next work */
BOOST_AUTO_TEST_CASE(get_next_work_pow_limit)
{
SelectParams(CBaseChainParams::MAIN);
+ const Consensus::Params& params = Params().GetConsensus();
int64_t nLastRetargetTime = 1231006505; // Block #0
CBlockIndex pindexLast;
pindexLast.nHeight = 2015;
pindexLast.nTime = 1233061996; // Block #2015
pindexLast.nBits = 0x1d00ffff;
- BOOST_CHECK_EQUAL(CalculateNextWorkRequired(&pindexLast, nLastRetargetTime), 0x1d00ffff);
+ BOOST_CHECK_EQUAL(CalculateNextWorkRequired(&pindexLast, nLastRetargetTime, params), 0x1d00ffff);
}
/* Test the constraint on the lower bound for actual time taken */
BOOST_AUTO_TEST_CASE(get_next_work_lower_limit_actual)
{
SelectParams(CBaseChainParams::MAIN);
+ const Consensus::Params& params = Params().GetConsensus();
int64_t nLastRetargetTime = 1279008237; // Block #66528
CBlockIndex pindexLast;
pindexLast.nHeight = 68543;
pindexLast.nTime = 1279297671; // Block #68543
pindexLast.nBits = 0x1c05a3f4;
- BOOST_CHECK_EQUAL(CalculateNextWorkRequired(&pindexLast, nLastRetargetTime), 0x1c0168fd);
+ BOOST_CHECK_EQUAL(CalculateNextWorkRequired(&pindexLast, nLastRetargetTime, params), 0x1c0168fd);
}
/* Test the constraint on the upper bound for actual time taken */
BOOST_AUTO_TEST_CASE(get_next_work_upper_limit_actual)
{
SelectParams(CBaseChainParams::MAIN);
+ const Consensus::Params& params = Params().GetConsensus();
+
int64_t nLastRetargetTime = 1263163443; // NOTE: Not an actual block time
CBlockIndex pindexLast;
pindexLast.nHeight = 46367;
pindexLast.nTime = 1269211443; // Block #46367
pindexLast.nBits = 0x1c387f6f;
- BOOST_CHECK_EQUAL(CalculateNextWorkRequired(&pindexLast, nLastRetargetTime), 0x1d00e1fd);
+ BOOST_CHECK_EQUAL(CalculateNextWorkRequired(&pindexLast, nLastRetargetTime, params), 0x1d00e1fd);
}
BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/txdb.cpp b/src/txdb.cpp
index f328150289..df9ff8d8c9 100644
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -5,6 +5,8 @@
#include "txdb.h"
+#include "chainparams.h"
+#include "hash.h"
#include "main.h"
#include "pow.h"
#include "uint256.h"
@@ -223,7 +225,7 @@ bool CBlockTreeDB::LoadBlockIndexGuts()
pindexNew->nStatus = diskindex.nStatus;
pindexNew->nTx = diskindex.nTx;
- if (!CheckProofOfWork(pindexNew->GetBlockHash(), pindexNew->nBits))
+ if (!CheckProofOfWork(pindexNew->GetBlockHash(), pindexNew->nBits, Params().GetConsensus()))
return error("LoadBlockIndex(): CheckProofOfWork failed: %s", pindexNew->ToString());
pcursor->Next();