int64_t nTransactionFee = MIN_TX_FEE;
int64_t nMinimumInputValue = MIN_TX_FEE;
+// Ping and address broadcast intervals
+int64_t nPingInterval = 30 * 60;
+int64_t nBroadcastInterval = 24 * 60 * 60;
+
extern enum Checkpoints::CPMode CheckpointsMode;
//////////////////////////////////////////////////////////////////////////////
}
// miner's coin stake reward based on nBits and coin age spent (coin-days)
-int64_t GetProofOfStakeReward(int64_t nCoinAge, unsigned int nBits, unsigned int nTime, bool bCoinYearOnly)
+int64_t GetProofOfStakeReward(int64_t nCoinAge, unsigned int nBits, int64_t nTime, bool bCoinYearOnly)
{
int64_t nRewardCoinYear, nSubsidy, nSubsidyLimit = 10 * COIN;
// These are checks that are independent of context
// that can be verified before saving an orphan block.
+ set<uint256> uniqueTx; // tx hashes
+ unsigned int nSigOps = 0; // total sigops
+
// Size limits
if (vtx.empty() || vtx.size() > MAX_BLOCK_SIZE || ::GetSerializeSize(*this, SER_NETWORK, PROTOCOL_VERSION) > MAX_BLOCK_SIZE)
return DoS(100, error("CheckBlock() : size limits failed"));
- // Check proof of work matches claimed amount
- if (fCheckPOW && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
- return DoS(50, error("CheckBlock() : proof of work failed"));
-
- // Check timestamp
- if (GetBlockTime() > FutureDrift(GetAdjustedTime()))
- return error("CheckBlock() : block timestamp too far in the future");
+ bool fProofOfStake = IsProofOfStake();
// First transaction must be coinbase, the rest must not be
- if (vtx.empty() || !vtx[0].IsCoinBase())
+ if (!vtx[0].IsCoinBase())
return DoS(100, error("CheckBlock() : first tx is not coinbase"));
- // Check coinbase timestamp
- if (GetBlockTime() < PastDrift((int64_t)vtx[0].nTime))
- return DoS(50, error("CheckBlock() : coinbase timestamp is too late"));
+ if (!vtx[0].CheckTransaction())
+ return DoS(vtx[0].nDoS, error("CheckBlock() : CheckTransaction failed on coinbase"));
- for (unsigned int i = 1; i < vtx.size(); i++)
- {
- if (vtx[i].IsCoinBase())
- return DoS(100, error("CheckBlock() : more than one coinbase"));
+ uniqueTx.insert(vtx[0].GetHash());
+ nSigOps += vtx[0].GetLegacySigOpCount();
- // Check transaction timestamp
- if (GetBlockTime() < (int64_t)vtx[i].nTime)
- return DoS(50, error("CheckBlock() : block timestamp earlier than transaction timestamp"));
- }
-
- if (IsProofOfStake())
+ if (fProofOfStake)
{
+ // Proof-of-STake related checkings. Note that we know here that 1st transactions is coinstake. We don't need
+ // check the type of 1st transaction because it's performed earlier by IsProofOfStake()
+
+ // nNonce must be zero for proof-of-stake blocks
if (nNonce != 0)
return DoS(100, error("CheckBlock() : non-zero nonce in proof-of-stake block"));
if (vtx[0].vout.size() != 1 || !vtx[0].vout[0].IsEmpty())
return DoS(100, error("CheckBlock() : coinbase output not empty for proof-of-stake block"));
- // Second transaction must be coinstake, the rest must not be
- if (vtx.empty() || !vtx[1].IsCoinStake())
- return DoS(100, error("CheckBlock() : second tx is not coinstake"));
- for (unsigned int i = 2; i < vtx.size(); i++)
- if (vtx[i].IsCoinStake())
- return DoS(100, error("CheckBlock() : more than one coinstake"));
-
// Check coinstake timestamp
if (GetBlockTime() != (int64_t)vtx[1].nTime)
return DoS(50, error("CheckBlock() : coinstake timestamp violation nTimeBlock=%" PRId64 " nTimeTx=%u", GetBlockTime(), vtx[1].nTime));
// NovaCoin: check proof-of-stake block signature
if (fCheckSig && !CheckBlockSignature())
return DoS(100, error("CheckBlock() : bad proof-of-stake block signature"));
+
+ if (!vtx[1].CheckTransaction())
+ return DoS(vtx[1].nDoS, error("CheckBlock() : CheckTransaction failed on coinstake"));
+
+ uniqueTx.insert(vtx[1].GetHash());
+ nSigOps += vtx[1].GetLegacySigOpCount();
+ }
+ else
+ {
+ // Check proof of work matches claimed amount
+ if (fCheckPOW && !CheckProofOfWork(GetHash(), nBits))
+ return DoS(50, error("CheckBlock() : proof of work failed"));
+
+ // Check timestamp
+ if (GetBlockTime() > FutureDrift(GetAdjustedTime()))
+ return error("CheckBlock() : block timestamp too far in the future");
+
+ // Check coinbase timestamp
+ if (GetBlockTime() < PastDrift((int64_t)vtx[0].nTime))
+ return DoS(50, error("CheckBlock() : coinbase timestamp is too late"));
}
- // Check transactions
- BOOST_FOREACH(const CTransaction& tx, vtx)
+ // Iterate all transactions starting from second for proof-of-stake block
+ // or first for proof-of-work block
+ for (unsigned int i = fProofOfStake ? 2 : 1; i < vtx.size(); i++)
{
+ const CTransaction& tx = vtx[i];
+
+ // Reject coinbase transactions at non-zero index
+ if (tx.IsCoinBase())
+ return DoS(100, error("CheckBlock() : coinbase at wrong index"));
+
+ // Reject coinstake transactions at index != 1
+ if (tx.IsCoinStake())
+ return DoS(100, error("CheckBlock() : coinstake at wrong index"));
+
+ // Check transaction timestamp
+ if (GetBlockTime() < (int64_t)tx.nTime)
+ return DoS(50, error("CheckBlock() : block timestamp earlier than transaction timestamp"));
+
+ // Check transaction consistency
if (!tx.CheckTransaction())
return DoS(tx.nDoS, error("CheckBlock() : CheckTransaction failed"));
+
+ // Add transaction hash into list of unique transaction IDs
+ uniqueTx.insert(tx.GetHash());
+
+ // Calculate sigops count
+ nSigOps += tx.GetLegacySigOpCount();
}
// Check for duplicate txids. This is caught by ConnectInputs(),
// but catching it earlier avoids a potential DoS attack:
- set<uint256> uniqueTx;
- BOOST_FOREACH(const CTransaction& tx, vtx)
- {
- uniqueTx.insert(tx.GetHash());
- }
if (uniqueTx.size() != vtx.size())
return DoS(100, error("CheckBlock() : duplicate transaction"));
- unsigned int nSigOps = 0;
- BOOST_FOREACH(const CTransaction& tx, vtx)
- {
- nSigOps += tx.GetLegacySigOpCount();
- }
+ // Reject block if validation would consume too much resources.
if (nSigOps > MAX_BLOCK_SIGOPS)
return DoS(100, error("CheckBlock() : out-of-bounds SigOpCount"));
if (fCheckMerkleRoot && hashMerkleRoot != BuildMerkleTree())
return DoS(100, error("CheckBlock() : hashMerkleRoot mismatch"));
-
return true;
}
return error("ProcessBlock() : duplicate proof-of-stake (%s, %d) for block %s", pblock->GetProofOfStake().first.ToString().c_str(), pblock->GetProofOfStake().second, hash.ToString().c_str());
// Preliminary checks
- if (!pblock->CheckBlock())
+ if (!pblock->CheckBlock(true, true, (pblock->nTime > Checkpoints::GetLastCheckpointTime())))
return error("ProcessBlock() : CheckBlock FAILED");
// ppcoin: verify hash target and signature of coinstake tx
if (IsProofOfStake())
return true;
- static int64_t nLastCoinStakeSearchTime = GetAdjustedTime(); // startup timestamp
+ static uint32_t nLastCoinStakeSearchTime = GetAdjustedTime(); // startup timestamp
CKey key;
CTransaction txCoinStake;
- int64_t nSearchTime = txCoinStake.nTime; // search to current time
+ uint32_t nSearchTime = txCoinStake.nTime; // search to current time
if (nSearchTime > nLastCoinStakeSearchTime)
{
// Keep-alive ping. We send a nonce of zero because we don't use it anywhere
// right now.
- if (pto->nLastSend && GetTime() - pto->nLastSend > 30 * 60 && pto->vSend.empty()) {
+ if (pto->nLastSend && GetTime() - pto->nLastSend > nPingInterval && pto->vSend.empty()) {
uint64_t nonce = 0;
if (pto->nVersion > BIP0031_VERSION)
pto->PushMessage("ping", nonce);
// Address refresh broadcast
static int64_t nLastRebroadcast;
- if (!IsInitialBlockDownload() && (GetTime() - nLastRebroadcast > 24 * 60 * 60))
+ if (!IsInitialBlockDownload() && (GetTime() - nLastRebroadcast > nBroadcastInterval))
{
{
LOCK(cs_vNodes);