#include "alert.h"
#include "checkpoints.h"
#include "db.h"
-#include "txdb.h"
+#include "txdb-leveldb.h"
#include "init.h"
-#include "ui_interface.h"
+#include "interface.h"
#include "checkqueue.h"
#include "kernel.h"
#include <boost/algorithm/string/replace.hpp>
// Ping and address broadcast intervals
int64_t nPingInterval = 30 * 60;
-int64_t nBroadcastInterval = nOneDay;
extern enum Checkpoints::CPMode CheckpointsMode;
return false;
}
-// get the wallet transaction with the given hash (if it exists)
-bool static GetTransaction(const uint256& hashTx, CWalletTx& wtx)
-{
- BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
- if (pwallet->GetTransaction(hashTx,wtx))
- return true;
- return false;
-}
-
// erases transaction with the given hash from all wallets
void static EraseFromWallets(uint256 hash)
{
{
CBlock blockTmp;
+ if (pblock == NULL)
+ {
+ // Load the block this tx is in
+ CTxIndex txindex;
+ if (!CTxDB("r").ReadTxIndex(GetHash(), txindex))
+ return 0;
+ if (!blockTmp.ReadFromDisk(txindex.pos.nFile, txindex.pos.nBlockPos))
+ return 0;
+ pblock = &blockTmp;
+ }
+
// Update the tx's hashBlock
hashBlock = pblock->GetHash();
if (tx.nTime >= CHECKLOCKTIMEVERIFY_SWITCH_TIME) {
nFlags |= SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY;
- // OP_CHECKSEQUENCEVERIFY is senseless without BIP68, so we're going disable it for now.
- // nFlags |= SCRIPT_VERIFY_CHECKSEQUENCEVERIFY;
+ }
+
+ if (tx.nTime >= CHECKSEQUENCEVERIFY_SWITCH_TIME) {
+ nFlags |= SCRIPT_VERIFY_CHECKSEQUENCEVERIFY;
}
std::vector<CScriptCheck> vChecks;
}
// Connect further blocks
- BOOST_REVERSE_FOREACH(CBlockIndex *pindex, vpindexSecondary)
+ for (std::vector<CBlockIndex*>::reverse_iterator rit = vpindexSecondary.rbegin(); rit != vpindexSecondary.rend(); ++rit)
{
CBlock block;
- if (!block.ReadFromDisk(pindex))
+ if (!block.ReadFromDisk(*rit))
{
printf("SetBestChain() : ReadFromDisk failed\n");
break;
break;
}
// errors now are not fatal, we still did a reorganisation to a new chain in a valid way
- if (!block.SetBestChainInner(txdb, pindex))
+ if (!block.SetBestChainInner(txdb, *rit))
break;
}
}
if (!pblock->CheckBlock(true, true, (pblock->nTime > Checkpoints::GetLastCheckpointTime())))
return error("ProcessBlock() : CheckBlock FAILED");
- // ppcoin: verify hash target and signature of coinstake tx
- if (pblock->IsProofOfStake())
- {
- uint256 hashProofOfStake = 0, targetProofOfStake = 0;
- if (!CheckProofOfStake(pblock->vtx[1], pblock->nBits, hashProofOfStake, targetProofOfStake))
- {
- printf("WARNING: ProcessBlock(): check proof-of-stake failed for block %s\n", hash.ToString().c_str());
- return false; // do not error here as we expect this during initial block download
- }
- if (!mapProofOfStake.count(hash)) // add to mapProofOfStake
- mapProofOfStake.insert(make_pair(hash, hashProofOfStake));
- }
-
CBlockIndex* pcheckpoint = Checkpoints::GetLastSyncCheckpoint();
if (pcheckpoint && pblock->hashPrevBlock != hashBestChain && !Checkpoints::WantedByPendingSyncCheckpoint(hash))
{
}
}
+
// ppcoin: ask for pending sync-checkpoint if any
if (!IsInitialBlockDownload())
Checkpoints::AskForPendingSyncCheckpoint(pfrom);
return true;
}
+ // ppcoin: verify hash target and signature of coinstake tx
+ if (pblock->IsProofOfStake())
+ {
+ uint256 hashProofOfStake = 0, targetProofOfStake = 0;
+ if (!CheckProofOfStake(pblock->vtx[1], pblock->nBits, hashProofOfStake, targetProofOfStake))
+ {
+ // Having prev block in index should be enough for validation
+ if (mapBlockIndex.count(pblock->hashPrevBlock))
+ return error("ProcessBlock(): check proof-of-stake (%s, %d) failed for block %s\n", pblock->GetProofOfStake().first.ToString().c_str(), pblock->GetProofOfStake().second, hash.ToString().c_str());
+
+ // Orphan blocks should be validated later once all parents successfully added to local chain
+ printf("ProcessBlock(): delaying proof-of-stake validation for orphan block %s\n", hash.ToString().c_str());
+ return false; // do not error here as we expect this to happen here
+ }
+
+ // Needed for AcceptBlock()
+ if (!mapProofOfStake.count(hash))
+ mapProofOfStake.insert(make_pair(hash, hashProofOfStake));
+ }
+
// Store to disk
if (!pblock->AcceptBlock())
return error("ProcessBlock() : AcceptBlock FAILED");
- // Recursively process any orphan blocks that depended on this one
+ // Process any orphan blocks that depended on this one
vector<uint256> vWorkQueue;
vWorkQueue.push_back(hash);
for (unsigned int i = 0; i < vWorkQueue.size(); i++)
++mi)
{
CBlock* pblockOrphan = (*mi).second;
- if (pblockOrphan->AcceptBlock())
- vWorkQueue.push_back(pblockOrphan->GetHash());
- mapOrphanBlocks.erase(pblockOrphan->GetHash());
- setStakeSeenOrphan.erase(pblockOrphan->GetProofOfStake());
+ uint256 hashOrphanBlock = pblockOrphan->GetHash();
+
+ if (pblockOrphan->IsProofOfStake()) {
+ // Check proof-of-stake and do other contextual
+ // preparations before running AcceptBlock()
+ uint256 hashOrphanProofOfStake = 0;
+ uint256 targetOrphanProofOfStake = 0;
+
+ if (CheckProofOfStake(pblockOrphan->vtx[1], pblockOrphan->nBits, hashOrphanProofOfStake, targetOrphanProofOfStake))
+ {
+ // Needed for AcceptBlock()
+ if (!mapProofOfStake.count(hashOrphanBlock))
+ mapProofOfStake.insert(make_pair(hashOrphanBlock, hashOrphanProofOfStake));
+
+ // Finally, we're ready to run AcceptBlock()
+ if (pblockOrphan->AcceptBlock())
+ vWorkQueue.push_back(hashOrphanBlock);
+ setStakeSeenOrphan.erase(pblockOrphan->GetProofOfStake());
+ }
+ } else {
+ // proof-of-work verification
+ // is notoriously simpler
+ if (pblockOrphan->AcceptBlock())
+ vWorkQueue.push_back(hashOrphanBlock);
+ }
+
+ mapOrphanBlocks.erase(hashOrphanBlock);
delete pblockOrphan;
}
+
mapOrphanBlocksByPrev.erase(hashPrev);
}
bool CheckDiskSpace(uint64_t nAdditionalBytes)
{
- uint64_t nFreeBytesAvailable = filesystem::space(GetDataDir()).available;
+ uint64_t nFreeBytesAvailable = boost::filesystem::space(GetDataDir()).available;
// Check for nMinDiskSpace bytes (currently 50MB)
if (nFreeBytesAvailable < nMinDiskSpace + nAdditionalBytes)
return true;
}
-static filesystem::path BlockFilePath(unsigned int nFile)
+static boost::filesystem::path BlockFilePath(unsigned int nFile)
{
string strBlockFn = strprintf("blk%04u.dat", nFile);
return GetDataDir() / strBlockFn;
// CTxOut(empty)
// vMerkleTree: 4cb33b3b6a
- const char* pszTimestamp = "https://bitcointalk.org/index.php?topic=134179.msg1502196#msg1502196";
+ const string strTimestamp = "https://bitcointalk.org/index.php?topic=134179.msg1502196#msg1502196";
CTransaction txNew;
txNew.nTime = 1360105017;
txNew.vin.resize(1);
txNew.vout.resize(1);
- txNew.vin[0].scriptSig = CScript() << 486604799 << CBigNum(9999) << vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
+ txNew.vin[0].scriptSig = CScript() << 486604799 << CBigNum(9999) << vector<unsigned char>(strTimestamp.begin(), strTimestamp.end());
txNew.vout[0].SetEmpty();
CBlock block;
block.vtx.push_back(txNew);
if (!txdb.WriteModifierUpgradeTime(nModifierUpgradeTime))
return error("LoadBlockIndex() : failed to write upgrade info");
}
-
-#ifndef USE_LEVELDB
- txdb.Close();
-#endif
}
return true;
if (!hdr.IsValid())
{
printf("\n\nPROCESSMESSAGE: ERRORS IN HEADER %s\n\n\n", hdr.GetCommand().c_str());
- continue;
+ return false;
}
string strCommand = hdr.GetCommand();
{
printf("ProcessMessages(%s, %u bytes) : CHECKSUM ERROR nChecksum=%08x hdr.nChecksum=%08x\n",
strCommand.c_str(), nMessageSize, nChecksum, hdr.nChecksum);
- continue;
+ return false;
}
// Copy message to its own buffer
PrintExceptionContinue(NULL, "ProcessMessages()");
}
- if (!fRet)
+ if (!fRet) {
printf("ProcessMessage(%s, %u bytes) FAILED\n", strCommand.c_str(), nMessageSize);
+ return false;
+ }
}
vRecv.Compact();
}
-bool SendMessages(CNode* pto, bool fSendTrickle)
+bool SendMessages(CNode* pto)
{
TRY_LOCK(cs_main, lockMain);
if (lockMain) {
+ // Current time in microseconds
+ int64_t nNow = GetTimeMicros();
+
// Don't send anything until we get their version message
if (pto->nVersion == 0)
return true;
ResendWalletTransactions();
// Address refresh broadcast
- static int64_t nLastRebroadcast;
- if (!IsInitialBlockDownload() && (GetTime() - nLastRebroadcast > nBroadcastInterval))
- {
- {
- LOCK(cs_vNodes);
- BOOST_FOREACH(CNode* pnode, vNodes)
- {
- // Periodically clear setAddrKnown to allow refresh broadcasts
- if (nLastRebroadcast)
- pnode->setAddrKnown.clear();
-
- // Rebroadcast our address
- if (!fNoListen)
- {
- CAddress addr = GetLocalAddress(&pnode->addr);
- if (addr.IsRoutable())
- pnode->PushAddress(addr);
- }
- }
- }
- nLastRebroadcast = GetTime();
+ if (!IsInitialBlockDownload() && pto->nNextLocalAddrSend < nNow) {
+ AdvertiseLocal(pto);
+ pto->nNextLocalAddrSend = PoissonNextSend(nNow, nOneDay);
}
//
// Message: addr
//
- if (fSendTrickle)
- {
+ if (pto->nNextAddrSend < nNow) {
+ pto->nNextAddrSend = PoissonNextSend(nNow, 30);
vector<CAddress> vAddr;
vAddr.reserve(pto->vAddrToSend.size());
BOOST_FOREACH(const CAddress& addr, pto->vAddrToSend)
{
- // returns true if wasn't already contained in the set
if (pto->setAddrKnown.insert(addr).second)
{
vAddr.push_back(addr);
pto->PushMessage("addr", vAddr);
}
-
//
// Message: inventory
//
vector<CInv> vInv;
vector<CInv> vInvWait;
{
+ bool fSendTrickle = false;
+ if (pto->nNextInvSend < nNow) {
+ fSendTrickle = true;
+ pto->nNextInvSend = PoissonNextSend(nNow, 5);
+ }
LOCK(pto->cs_inventory);
vInv.reserve(pto->vInventoryToSend.size());
vInvWait.reserve(pto->vInventoryToSend.size());
hashRand = Hash(BEGIN(hashRand), END(hashRand));
bool fTrickleWait = ((hashRand & 3) != 0);
- // always trickle our own transactions
- if (!fTrickleWait)
- {
- CWalletTx wtx;
- if (GetTransaction(inv.hash, wtx))
- if (wtx.fFromMe)
- fTrickleWait = true;
- }
-
if (fTrickleWait)
{
vInvWait.push_back(inv);
// Message: getdata
//
vector<CInv> vGetData;
- int64_t nNow = GetTime() * 1000000;
CTxDB txdb("r");
while (!pto->mapAskFor.empty() && (*pto->mapAskFor.begin()).first <= nNow)
{