// Settings
int64_t nTransactionFee = MIN_TX_FEE;
-int64_t nMinimumInputValue = MIN_TX_FEE;
+int64_t nMinimumInputValue = MIN_TXOUT_AMOUNT;
+
+// Ping and address broadcast intervals
+int64_t nPingInterval = 30 * 60;
+int64_t nBroadcastInterval = 24 * 60 * 60;
extern enum Checkpoints::CPMode CheckpointsMode;
{
if (!fConnect)
{
- // ppcoin: wallets need to refund inputs when disconnecting coinstake
+ // wallets need to refund inputs when disconnecting coinstake
if (tx.IsCoinStake())
{
BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
pwallet->AddToWalletIfInvolvingMe(tx, pblock, fUpdate);
- // Preloaded coins cache invalidation
- fCoinsDataActual = false;
}
// notify wallets about a new best chain
txnouttype whichType;
BOOST_FOREACH(const CTxIn& txin, vin)
{
- // Biggest 'standard' txin is a 3-signature 3-of-3 CHECKMULTISIG
- // pay-to-script-hash, which is 3 ~80-byte signatures, 3
- // ~65-byte public keys, plus a few script ops.
- if (txin.scriptSig.size() > 500)
+ // Biggest 'standard' txin is a 15-of-15 P2SH multisig with compressed
+ // keys. (remember the 520 byte limit on redeemScript size) That works
+ // out to a (15*(33+1))+3=513 byte redeemScript, 513+1+15*(73+1)=1624
+ // bytes of scriptSig, which we round off to 1650 bytes for some minor
+ // future-proofing. That's also enough to spend a 20-of-20
+ // CHECKMULTISIG scriptPubKey, though such a scriptPubKey is not
+ // considered standard)
+ if (txin.scriptSig.size() > 1650)
{
strReason = "scriptsig-size";
return false;
CTransaction::GetLegacySigOpCount() const
{
unsigned int nSigOps = 0;
- BOOST_FOREACH(const CTxIn& txin, vin)
+ if (!IsCoinBase() || nTime < COINBASE_SIGOPS_SWITCH_TIME)
{
- nSigOps += txin.scriptSig.GetSigOpCount(false);
+ // Coinbase scriptsigs are never executed, so there is
+ // no sense in calculation of sigops.
+ BOOST_FOREACH(const CTxIn& txin, vin)
+ {
+ nSigOps += txin.scriptSig.GetSigOpCount(false);
+ }
}
BOOST_FOREACH(const CTxOut& txout, vout)
{
int64_t CTransaction::GetMinFee(unsigned int nBlockSize, bool fAllowFree, enum GetMinFee_mode mode, unsigned int nBytes) const
{
- // Use new fees approach if we are on test network or
- // switch date has been reached
- bool fNewApproach = fTestNet || nTime > FEE_SWITCH_TIME;
-
int64_t nMinTxFee = MIN_TX_FEE, nMinRelayTxFee = MIN_RELAY_TX_FEE;
- if(!fNewApproach || IsCoinStake())
+ if(IsCoinStake())
{
- // Enforce 0.01 as minimum fee for old approach or coinstake
+ // Enforce 0.01 as minimum fee for coinstake
nMinTxFee = CENT;
nMinRelayTxFee = CENT;
}
unsigned int nNewBlockSize = nBlockSize + nBytes;
int64_t nMinFee = (1 + (int64_t)nBytes / 1000) * nBaseFee;
- if (fNewApproach)
+ if (fAllowFree)
{
- if (fAllowFree)
+ if (nBlockSize == 1)
{
- if (nBlockSize == 1)
- {
- // Transactions under 1K are free
- if (nBytes < 1000)
- nMinFee = 0;
- }
- else
- {
- // Free transaction area
- if (nNewBlockSize < 27000)
- nMinFee = 0;
- }
+ // Transactions under 1K are free
+ if (nBytes < 1000)
+ nMinFee = 0;
+ }
+ else
+ {
+ // Free transaction area
+ if (nNewBlockSize < 27000)
+ nMinFee = 0;
}
-
- // To limit dust spam, require additional MIN_TX_FEE/MIN_RELAY_TX_FEE for
- // each non empty output which is less than 0.01
- //
- // It's safe to ignore empty outputs here, because these inputs are allowed
- // only for coinbase and coinstake transactions.
- BOOST_FOREACH(const CTxOut& txout, vout)
- if (txout.nValue < CENT && !txout.IsEmpty())
- nMinFee += nBaseFee;
- }
- else if (nMinFee < nBaseFee)
- {
- // To limit dust spam, require MIN_TX_FEE/MIN_RELAY_TX_FEE if
- // any output is less than 0.01
- BOOST_FOREACH(const CTxOut& txout, vout)
- if (txout.nValue < CENT)
- nMinFee = nBaseFee;
}
+ // To limit dust spam, require additional MIN_TX_FEE/MIN_RELAY_TX_FEE for
+ // each non empty output which is less than 0.01
+ //
+ // It's safe to ignore empty outputs here, because these inputs are allowed
+ // only for coinbase and coinstake transactions.
+ BOOST_FOREACH(const CTxOut& txout, vout)
+ if (txout.nValue < CENT && !txout.IsEmpty())
+ nMinFee += nBaseFee;
+
// Raise the price as the block approaches full
if (nBlockSize != 1 && nNewBlockSize >= MAX_BLOCK_SIZE_GEN/2)
{
// Check against previous transactions
// This is done last to help prevent CPU exhaustion denial-of-service attacks.
- if (!tx.ConnectInputs(txdb, mapInputs, mapUnused, CDiskTxPos(1,1,1), pindexBest, false, false, true, SIG_SWITCH_TIME < tx.nTime ? STRICT_FLAGS : SOFT_FLAGS))
+ if (!tx.ConnectInputs(txdb, mapInputs, mapUnused, CDiskTxPos(1,1,1), pindexBest, false, false, true, STRICT_FLAGS))
{
return error("CTxMemPool::accept() : ConnectInputs failed %s", hash.ToString().substr(0,10).c_str());
}
// Human readable form:
//
// nSubsidy = 100 / (diff ^ 1/6)
+ //
+ // Please note that we're using bisection to find an approximate solutuion
CBigNum bnLowerBound = CENT;
CBigNum bnUpperBound = bnSubsidyLimit;
while (bnLowerBound + CENT <= bnUpperBound)
{
CBigNum bnMidValue = (bnLowerBound + bnUpperBound) / 2;
- if (fDebug && GetBoolArg("-printcreation"))
- printf("GetProofOfWorkReward() : lower=%" PRId64 " upper=%" PRId64 " mid=%" PRId64 "\n", bnLowerBound.getuint64(), bnUpperBound.getuint64(), bnMidValue.getuint64());
if (bnMidValue * bnMidValue * bnMidValue * bnMidValue * bnMidValue * bnMidValue * bnTargetLimit > bnSubsidyLimit * bnSubsidyLimit * bnSubsidyLimit * bnSubsidyLimit * bnSubsidyLimit * bnSubsidyLimit * bnTarget)
bnUpperBound = bnMidValue;
else
}
// 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;
- if(fTestNet || nTime > STAKE_SWITCH_TIME)
- {
- // Stage 2 of emission process is PoS-based. It will be active on mainNet since 20 Jun 2013.
+ // Stage 2 of emission process is mostly PoS-based.
- CBigNum bnRewardCoinYearLimit = MAX_MINT_PROOF_OF_STAKE; // Base stake mint rate, 100% year interest
- CBigNum bnTarget;
- bnTarget.SetCompact(nBits);
- CBigNum bnTargetLimit = GetProofOfStakeLimit(0, nTime);
- bnTargetLimit.SetCompact(bnTargetLimit.GetCompact());
+ CBigNum bnRewardCoinYearLimit = MAX_MINT_PROOF_OF_STAKE; // Base stake mint rate, 100% year interest
+ CBigNum bnTarget;
+ bnTarget.SetCompact(nBits);
+ CBigNum bnTargetLimit = GetProofOfStakeLimit(0, nTime);
+ bnTargetLimit.SetCompact(bnTargetLimit.GetCompact());
- // NovaCoin: A reasonably continuous curve is used to avoid shock to market
+ // A reasonably continuous curve is used to avoid shock to market
- CBigNum bnLowerBound = 1 * CENT, // Lower interest bound is 1% per year
- bnUpperBound = bnRewardCoinYearLimit, // Upper interest bound is 100% per year
- bnMidPart, bnRewardPart;
+ CBigNum bnLowerBound = 1 * CENT, // Lower interest bound is 1% per year
+ bnUpperBound = bnRewardCoinYearLimit, // Upper interest bound is 100% per year
+ bnMidPart, bnRewardPart;
- while (bnLowerBound + CENT <= bnUpperBound)
- {
- CBigNum bnMidValue = (bnLowerBound + bnUpperBound) / 2;
- if (fDebug && GetBoolArg("-printcreation"))
- printf("GetProofOfStakeReward() : lower=%" PRId64 " upper=%" PRId64 " mid=%" PRId64 "\n", bnLowerBound.getuint64(), bnUpperBound.getuint64(), bnMidValue.getuint64());
+ while (bnLowerBound + CENT <= bnUpperBound)
+ {
+ CBigNum bnMidValue = (bnLowerBound + bnUpperBound) / 2;
- if(!fTestNet && nTime < STAKECURVE_SWITCH_TIME)
- {
- //
- // Until 20 Oct 2013: reward for coin-year is cut in half every 64x multiply of PoS difficulty
- //
- // (nRewardCoinYearLimit / nRewardCoinYear) ** 6 == bnProofOfStakeLimit / bnTarget
- //
- // Human readable form: nRewardCoinYear = 1 / (posdiff ^ 1/6)
- //
-
- bnMidPart = bnMidValue * bnMidValue * bnMidValue * bnMidValue * bnMidValue * bnMidValue;
- bnRewardPart = bnRewardCoinYearLimit * bnRewardCoinYearLimit * bnRewardCoinYearLimit * bnRewardCoinYearLimit * bnRewardCoinYearLimit * bnRewardCoinYearLimit;
- }
- else
- {
- //
- // Since 20 Oct 2013: reward for coin-year is cut in half every 8x multiply of PoS difficulty
- //
- // (nRewardCoinYearLimit / nRewardCoinYear) ** 3 == bnProofOfStakeLimit / bnTarget
- //
- // Human readable form: nRewardCoinYear = 1 / (posdiff ^ 1/3)
- //
-
- bnMidPart = bnMidValue * bnMidValue * bnMidValue;
- bnRewardPart = bnRewardCoinYearLimit * bnRewardCoinYearLimit * bnRewardCoinYearLimit;
- }
+ //
+ // Reward for coin-year is cut in half every 8x multiply of PoS difficulty
+ //
+ // (nRewardCoinYearLimit / nRewardCoinYear) ** 3 == bnProofOfStakeLimit / bnTarget
+ //
+ // Human readable form: nRewardCoinYear = 1 / (posdiff ^ 1/3)
+ //
- if (bnMidPart * bnTargetLimit > bnRewardPart * bnTarget)
- bnUpperBound = bnMidValue;
- else
- bnLowerBound = bnMidValue;
- }
+ bnMidPart = bnMidValue * bnMidValue * bnMidValue;
+ bnRewardPart = bnRewardCoinYearLimit * bnRewardCoinYearLimit * bnRewardCoinYearLimit;
- nRewardCoinYear = bnUpperBound.getuint64();
- nRewardCoinYear = min((nRewardCoinYear / CENT) * CENT, MAX_MINT_PROOF_OF_STAKE);
- }
- else
- {
- // Old creation amount per coin-year, 5% fixed stake mint rate
- nRewardCoinYear = 5 * CENT;
+ if (bnMidPart * bnTargetLimit > bnRewardPart * bnTarget)
+ bnUpperBound = bnMidValue;
+ else
+ bnLowerBound = bnMidValue;
}
+ nRewardCoinYear = bnUpperBound.getuint64();
+ nRewardCoinYear = min((nRewardCoinYear / CENT) * CENT, MAX_MINT_PROOF_OF_STAKE);
+
if(bCoinYearOnly)
return nRewardCoinYear;
nSubsidy = nCoinAge * nRewardCoinYear * 33 / (365 * 33 + 8);
- // Set reasonable reward limit for large inputs since 20 Oct 2013
+ // Set reasonable reward limit for large inputs
//
// This will stimulate large holders to use smaller inputs, that's good for the network protection
- if(fTestNet || STAKECURVE_SWITCH_TIME < nTime)
- {
- if (fDebug && GetBoolArg("-printcreation") && nSubsidyLimit < nSubsidy)
- printf("GetProofOfStakeReward(): %s is greater than %s, coinstake reward will be truncated\n", FormatMoney(nSubsidy).c_str(), FormatMoney(nSubsidyLimit).c_str());
- nSubsidy = min(nSubsidy, nSubsidyLimit);
- }
+ if (fDebug && GetBoolArg("-printcreation") && nSubsidyLimit < nSubsidy)
+ printf("GetProofOfStakeReward(): %s is greater than %s, coinstake reward will be truncated\n", FormatMoney(nSubsidy).c_str(), FormatMoney(nSubsidyLimit).c_str());
+
+ nSubsidy = min(nSubsidy, nSubsidyLimit);
if (fDebug && GetBoolArg("-printcreation"))
printf("GetProofOfStakeReward(): create=%s nCoinAge=%" PRId64 " nBits=%d\n", FormatMoney(nSubsidy).c_str(), nCoinAge, nBits);
+
return nSubsidy;
}
return true;
static int64_t nLastUpdate;
static CBlockIndex* pindexLastBest;
+ int64_t nCurrentTime = GetTime();
if (pindexBest != pindexLastBest)
{
pindexLastBest = pindexBest;
- nLastUpdate = GetTime();
+ nLastUpdate = nCurrentTime;
}
- return (GetTime() - nLastUpdate < 10 &&
- pindexBest->GetBlockTime() < GetTime() - 24 * 60 * 60);
+ return (nCurrentTime - nLastUpdate < 10 &&
+ pindexBest->GetBlockTime() < nCurrentTime - 24 * 60 * 60);
}
void static InvalidChainFound(CBlockIndex* pindexNew)
if (IsCoinStake())
{
- // ppcoin: coin stake tx earns reward instead of paying fee
- uint64_t nCoinAge;
- if (!GetCoinAge(txdb, nCoinAge))
- return error("ConnectInputs() : %s unable to get coin age for coinstake", GetHash().ToString().substr(0,10).c_str());
+ if (nTime > Checkpoints::GetLastCheckpointTime())
+ {
+ unsigned int nTxSize = GetSerializeSize(SER_NETWORK, PROTOCOL_VERSION);
- unsigned int nTxSize = (nTime > VALIDATION_SWITCH_TIME || fTestNet) ? GetSerializeSize(SER_NETWORK, PROTOCOL_VERSION) : 0;
+ // coin stake tx earns reward instead of paying fee
+ uint64_t nCoinAge;
+ if (!GetCoinAge(txdb, nCoinAge))
+ return error("ConnectInputs() : %s unable to get coin age for coinstake", GetHash().ToString().substr(0,10).c_str());
- int64_t nReward = GetValueOut() - nValueIn;
- int64_t nCalculatedReward = GetProofOfStakeReward(nCoinAge, pindexBlock->nBits, nTime) - GetMinFee(1, false, GMF_BLOCK, nTxSize) + CENT;
+ int64_t nReward = GetValueOut() - nValueIn;
+ int64_t nCalculatedReward = GetProofOfStakeReward(nCoinAge, pindexBlock->nBits, nTime) - GetMinFee(1, false, GMF_BLOCK, nTxSize) + CENT;
- if (nReward > nCalculatedReward)
- return DoS(100, error("ConnectInputs() : coinstake pays too much(actual=%" PRId64 " vs calculated=%" PRId64 ")", nReward, nCalculatedReward));
+ if (nReward > nCalculatedReward)
+ return DoS(100, error("ConnectInputs() : coinstake pays too much(actual=%" PRId64 " vs calculated=%" PRId64 ")", nReward, nCalculatedReward));
+ }
}
else
{
pindexNew->nChainTrust = (pindexNew->pprev ? pindexNew->pprev->nChainTrust : 0) + pindexNew->GetBlockTrust();
// ppcoin: compute stake entropy bit for stake modifier
- if (!pindexNew->SetStakeEntropyBit(GetStakeEntropyBit(pindexNew->nTime)))
+ if (!pindexNew->SetStakeEntropyBit(GetStakeEntropyBit(pindexNew->nHeight)))
return error("AddToBlockIndex() : SetStakeEntropyBit() failed");
// ppcoin: record proof-of-stake hash value
hashPrevBestCoinBase = vtx[0].GetHash();
}
- uiInterface.NotifyBlocksChanged();
+ static int8_t counter = 0;
+ if( (++counter & 0x0F) == 0 || !IsInitialBlockDownload()) // repaint every 16 blocks if not in initial block download
+ uiInterface.NotifyBlocksChanged();
return true;
}
// 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(true))
+ 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
{
- // Should we check proof-of-work block signature or not?
- //
- // * Always skip on TestNet
- // * Perform checking for the first 9689 blocks
- // * Perform checking since last checkpoint until 20 Sep 2013 (will be removed after)
+ // Check proof of work matches claimed amount
+ if (fCheckPOW && !CheckProofOfWork(GetHash(), nBits))
+ return DoS(50, error("CheckBlock() : proof of work failed"));
- if(!fTestNet && fCheckSig)
- {
- bool checkEntropySig = (GetBlockTime() < ENTROPY_SWITCH_TIME);
+ // Check timestamp
+ if (GetBlockTime() > FutureDrift(GetAdjustedTime()))
+ return error("CheckBlock() : block timestamp too far in the future");
- // NovaCoin: check proof-of-work block signature
- if (checkEntropySig && !CheckBlockSignature(false))
- return DoS(100, error("CheckBlock() : bad proof-of-work block signature"));
- }
+ // 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;
}
// Write block to history file
if (!CheckDiskSpace(::GetSerializeSize(*this, SER_DISK, CLIENT_VERSION)))
return error("AcceptBlock() : out of disk space");
- unsigned int nFile = -1;
+ unsigned int nFile = std::numeric_limits<unsigned int>::max();
unsigned int nBlockPos = 0;
if (!WriteToDisk(nFile, nBlockPos))
return error("AcceptBlock() : WriteToDisk failed");
if (bnTarget <= 0)
return 0;
- /* Old protocol */
- if (!fTestNet && GetBlockTime() < CHAINCHECKS_SWITCH_TIME)
- return (IsProofOfStake()? ((CBigNum(1)<<256) / (bnTarget+1)).getuint256() : 1);
-
- /* New protocol */
-
- // Calculate work amount for block
- uint256 nPoWTrust = (CBigNum(nPoWBase) / (bnTarget+1)).getuint256();
-
- // Set nPowTrust to 1 if we are checking PoS block or PoW difficulty is too low
- nPoWTrust = (IsProofOfStake() || nPoWTrust < 1) ? 1 : nPoWTrust;
-
- // Return nPoWTrust for the first 12 blocks
+ // Return 1 for the first 12 blocks
if (pprev == NULL || pprev->nHeight < 12)
- return nPoWTrust;
+ return 1;
const CBlockIndex* currentIndex = pprev;
}
else
{
+ // Calculate work amount for block
+ CBigNum bnPoWTrust = CBigNum(nPoWBase) / (bnTarget+1);
+
+ // Set nPowTrust to 1 if PoW difficulty is too low
+ if (bnPoWTrust < 1)
+ bnPoWTrust = 1;
+
CBigNum bnLastBlockTrust = CBigNum(pprev->nChainTrust - pprev->pprev->nChainTrust);
// Return nPoWTrust + 2/3 of previous block score if two parent blocks are not PoS blocks
if (!(pprev->IsProofOfStake() && pprev->pprev->IsProofOfStake()))
- return nPoWTrust + (2 * bnLastBlockTrust / 3).getuint256();
+ return (bnPoWTrust + 2 * bnLastBlockTrust / 3).getuint256();
int nPoSCount = 0;
// Return nPoWTrust + 2/3 of previous block score if less than 7 PoS blocks found
if (nPoSCount < 7)
- return nPoWTrust + (2 * bnLastBlockTrust / 3).getuint256();
+ return (bnPoWTrust + 2 * bnLastBlockTrust / 3).getuint256();
bnTarget.SetCompact(pprev->nBits);
CBigNum bnNewTrust = (CBigNum(1)<<256) / (bnTarget+1);
// Return nPoWTrust + full trust score for previous block nBits
- return nPoWTrust + bnNewTrust.getuint256();
+ return (bnPoWTrust + bnNewTrust).getuint256();
}
}
return (nFound >= nRequired);
}
+bool static ReserealizeBlockSignature(CBlock* pblock)
+{
+ if (pblock->IsProofOfWork())
+ {
+ pblock->vchBlockSig.clear();
+ return true;
+ }
+
+ return CKey::ReserealizeSignature(pblock->vchBlockSig);
+}
+
+bool static IsCanonicalBlockSignature(CBlock* pblock)
+{
+ if (pblock->IsProofOfWork())
+ return pblock->vchBlockSig.empty();
+
+ return IsDERSignature(pblock->vchBlockSig);
+}
+
bool ProcessBlock(CNode* pfrom, CBlock* pblock)
{
// Check for duplicate
if (mapOrphanBlocks.count(hash))
return error("ProcessBlock() : already have block (orphan) %s", hash.ToString().substr(0,20).c_str());
- // ppcoin: check proof-of-stake
+ // Check proof-of-stake
// Limited duplicity on stake: prevents block flood attack
// Duplicate stake allowed only when there is orphan child block
if (pblock->IsProofOfStake() && setStakeSeen.count(pblock->GetProofOfStake()) && !mapOrphanBlocksByPrev.count(hash) && !Checkpoints::WantedByPendingSyncCheckpoint(hash))
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());
+ // Strip the garbage from newly received blocks, if we found some
+ if (!IsCanonicalBlockSignature(pblock)) {
+ if (!ReserealizeBlockSignature(pblock))
+ printf("WARNING: ProcessBlock() : ReserealizeBlockSignature FAILED\n");
+ }
+
// 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 (!mapBlockIndex.count(pblock->hashPrevBlock))
{
printf("ProcessBlock: ORPHAN BLOCK, prev=%s\n", pblock->hashPrevBlock.ToString().substr(0,20).c_str());
- CBlock* pblock2 = new CBlock(*pblock);
// ppcoin: check proof-of-stake
- if (pblock2->IsProofOfStake())
+ if (pblock->IsProofOfStake())
{
// Limited duplicity on stake: prevents block flood attack
// Duplicate stake allowed only when there is orphan child block
- if (setStakeSeenOrphan.count(pblock2->GetProofOfStake()) && !mapOrphanBlocksByPrev.count(hash) && !Checkpoints::WantedByPendingSyncCheckpoint(hash))
- return error("ProcessBlock() : duplicate proof-of-stake (%s, %d) for orphan block %s", pblock2->GetProofOfStake().first.ToString().c_str(), pblock2->GetProofOfStake().second, hash.ToString().c_str());
+ if (setStakeSeenOrphan.count(pblock->GetProofOfStake()) && !mapOrphanBlocksByPrev.count(hash) && !Checkpoints::WantedByPendingSyncCheckpoint(hash))
+ return error("ProcessBlock() : duplicate proof-of-stake (%s, %d) for orphan block %s", pblock->GetProofOfStake().first.ToString().c_str(), pblock->GetProofOfStake().second, hash.ToString().c_str());
else
- setStakeSeenOrphan.insert(pblock2->GetProofOfStake());
+ setStakeSeenOrphan.insert(pblock->GetProofOfStake());
}
+ CBlock* pblock2 = new CBlock(*pblock);
mapOrphanBlocks.insert(make_pair(hash, pblock2));
mapOrphanBlocksByPrev.insert(make_pair(pblock2->hashPrevBlock, pblock2));
return true;
}
-// novacoin: attempt to generate suitable proof-of-stake
-bool CBlock::SignBlock(CWallet& wallet)
-{
- // if we are trying to sign
- // something except proof-of-stake block template
- if (!vtx[0].vout[0].IsEmpty())
- return false;
-
- // if we are trying to sign
- // a complete proof-of-stake block
- if (IsProofOfStake())
- return true;
-
- static int64_t nLastCoinStakeSearchTime = GetAdjustedTime(); // startup timestamp
-
- CKey key;
- CTransaction txCoinStake;
- int64_t nSearchTime = txCoinStake.nTime; // search to current time
-
- if (nSearchTime > nLastCoinStakeSearchTime)
- {
- if (wallet.CreateCoinStake(wallet, nBits, nSearchTime-nLastCoinStakeSearchTime, txCoinStake, key))
- {
- if (txCoinStake.nTime >= max(pindexBest->GetMedianTimePast()+1, PastDrift(pindexBest->GetBlockTime())))
- {
- // make sure coinstake would meet timestamp protocol
- // as it would be the same as the block timestamp
- vtx[0].nTime = nTime = txCoinStake.nTime;
- nTime = max(pindexBest->GetMedianTimePast()+1, GetMaxTransactionTime());
- nTime = max(GetBlockTime(), PastDrift(pindexBest->GetBlockTime()));
-
- // we have to make sure that we have no future timestamps in
- // our transactions set
- for (vector<CTransaction>::iterator it = vtx.begin(); it != vtx.end();)
- if (it->nTime > nTime) { it = vtx.erase(it); } else { ++it; }
-
- vtx.insert(vtx.begin() + 1, txCoinStake);
- hashMerkleRoot = BuildMerkleTree();
-
- // append a signature to our block
- return key.Sign(GetHash(), vchBlockSig);
- }
- }
- nLastCoinStakeSearchInterval = nSearchTime - nLastCoinStakeSearchTime;
- nLastCoinStakeSearchTime = nSearchTime;
- }
-
- return false;
-}
-
// ppcoin: check block signature
-bool CBlock::CheckBlockSignature(bool fProofOfStake) const
+bool CBlock::CheckBlockSignature() const
{
- if (GetHash() == (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet))
- return vchBlockSig.empty();
+ if (vchBlockSig.empty())
+ return false;
- vector<valtype> vSolutions;
txnouttype whichType;
+ vector<valtype> vSolutions;
+ if (!Solver(vtx[1].vout[1].scriptPubKey, whichType, vSolutions))
+ return false;
- if(fProofOfStake)
+ if (whichType == TX_PUBKEY)
{
- const CTxOut& txout = vtx[1].vout[1];
-
- if (!Solver(txout.scriptPubKey, whichType, vSolutions))
+ valtype& vchPubKey = vSolutions[0];
+ CKey key;
+ if (!key.SetPubKey(vchPubKey))
return false;
- if (whichType == TX_PUBKEY)
- {
- valtype& vchPubKey = vSolutions[0];
- CKey key;
- if (!key.SetPubKey(vchPubKey))
- return false;
- if (vchBlockSig.empty())
- return false;
- return key.Verify(GetHash(), vchBlockSig);
- }
+ return key.Verify(GetHash(), vchBlockSig);
}
- else
- {
- for(unsigned int i = 0; i < vtx[0].vout.size(); i++)
- {
- const CTxOut& txout = vtx[0].vout[i];
- if (!Solver(txout.scriptPubKey, whichType, vSolutions))
- return false;
-
- if (whichType == TX_PUBKEY)
- {
- // Verify
- valtype& vchPubKey = vSolutions[0];
- CKey key;
- if (!key.SetPubKey(vchPubKey))
- continue;
- if (vchBlockSig.empty())
- continue;
- if(!key.Verify(GetHash(), vchBlockSig))
- continue;
-
- return true;
- }
- }
- }
return false;
}
}
}
+void UnloadBlockIndex()
+{
+ mapBlockIndex.clear();
+ setStakeSeen.clear();
+ pindexGenesisBlock = NULL;
+ nBestHeight = 0;
+ nBestChainTrust = 0;
+ nBestInvalidTrust = 0;
+ hashBestChain = 0;
+ pindexBest = NULL;
+}
+
bool LoadBlockIndex(bool fAllowNew)
{
if (fTestNet)
}
}
}
- catch (std::exception &e) {
+ catch (const std::exception&) {
printf("%s() : Deserialize or I/O error caught during load\n",
BOOST_CURRENT_FUNCTION);
}
// 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);
}
return true;
}
+
+
+class CMainCleanup
+{
+public:
+ CMainCleanup() {}
+ ~CMainCleanup() {
+ // block headers
+ std::map<uint256, CBlockIndex*>::iterator it1 = mapBlockIndex.begin();
+ for (; it1 != mapBlockIndex.end(); it1++)
+ delete (*it1).second;
+ mapBlockIndex.clear();
+
+ // orphan blocks
+ std::map<uint256, CBlock*>::iterator it2 = mapOrphanBlocks.begin();
+ for (; it2 != mapOrphanBlocks.end(); it2++)
+ delete (*it2).second;
+ mapOrphanBlocks.clear();
+
+ // orphan transactions
+ }
+} instance_of_cmaincleanup;
\ No newline at end of file