src/main.cpp

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2014 The Bitcoin Core developers
   3 // Distributed under the MIT software license, see the accompanying
   4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5
   6 #include "main.h"
   7
   8 #include "sodium.h"
   9
  10 #include "addrman.h"
  11 #include "alert.h"
  12 #include "arith_uint256.h"
  13 #include "chainparams.h"
  14 #include "checkpoints.h"
  15 #include "checkqueue.h"
  16 #include "consensus/validation.h"
  17 #include "init.h"
  18 #include "merkleblock.h"
  19 #include "metrics.h"
  20 #include "net.h"
  21 #include "pow.h"
  22 #include "txdb.h"
  23 #include "txmempool.h"
  24 #include "ui_interface.h"
  25 #include "undo.h"
  26 #include "util.h"
  27 #include "utilmoneystr.h"
  28 #include "validationinterface.h"
  29
  30 #include <sstream>
  31
  32 #include <boost/algorithm/string/replace.hpp>
  33 #include <boost/filesystem.hpp>
  34 #include <boost/filesystem/fstream.hpp>
  35 #include <boost/math/distributions/poisson.hpp>
  36 #include <boost/thread.hpp>
  37 #include <boost/static_assert.hpp>
  38
  39 using namespace std;
  40
  41 #if defined(NDEBUG)
  42 # error "Zcash cannot be compiled without assertions."
  43 #endif
  44
  45
  46 /**
  47  * Global state
  48  */
  49
  50 CCriticalSection cs_main;
  51
  52 BlockMap mapBlockIndex;
  53 CChain chainActive;
  54 CBlockIndex *pindexBestHeader = NULL;
  55 int64_t nTimeBestReceived = 0;
  56 CWaitableCriticalSection csBestBlock;
  57 CConditionVariable cvBlockChange;
  58 int nScriptCheckThreads = 0;
  59 bool fImporting = false;
  60 bool fReindex = false;
  61 bool fTxIndex = false;
  62 bool fHavePruned = false;
  63 bool fPruneMode = false;
  64 bool fIsBareMultisigStd = true;
  65 bool fCheckBlockIndex = false;
  66 bool fCheckpointsEnabled = true;
  67 bool fCoinbaseEnforcedProtectionEnabled = true;
  68 size_t nCoinCacheUsage = 5000 * 300;
  69 uint64_t nPruneTarget = 0;
  70 bool fAlerts = DEFAULT_ALERTS;
  71
  72 /** Fees smaller than this (in satoshi) are considered zero fee (for relaying and mining) */
  73 CFeeRate minRelayTxFee = CFeeRate(5000);
  74
  75 CTxMemPool mempool(::minRelayTxFee);
  76
  77 struct COrphanTx {
  78     CTransaction tx;
  79     NodeId fromPeer;
  80 };
  81 map<uint256, COrphanTx> mapOrphanTransactions;
  82 map<uint256, set<uint256> > mapOrphanTransactionsByPrev;
  83 void EraseOrphansFor(NodeId peer);
  84
  85 /**
  86  * Returns true if there are nRequired or more blocks of minVersion or above
  87  * in the last Consensus::Params::nMajorityWindow blocks, starting at pstart and going backwards.
  88  */
  89 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart, unsigned nRequired, const Consensus::Params& consensusParams);
  90 static void CheckBlockIndex();
  91
  92 /** Constant stuff for coinbase transactions we create: */
  93 CScript COINBASE_FLAGS;
  94
  95 const string strMessageMagic = "Komodo Signed Message:\n";
  96
  97 // Internal stuff
  98 namespace {
  99
 100     struct CBlockIndexWorkComparator
 101     {
 102         bool operator()(CBlockIndex *pa, CBlockIndex *pb) const {
 103             // First sort by most total work, ...
 104             if (pa->nChainWork > pb->nChainWork) return false;
 105             if (pa->nChainWork < pb->nChainWork) return true;
 106
 107             // ... then by earliest time received, ...
 108             if (pa->nSequenceId < pb->nSequenceId) return false;
 109             if (pa->nSequenceId > pb->nSequenceId) return true;
 110
 111             // Use pointer address as tie breaker (should only happen with blocks
 112             // loaded from disk, as those all have id 0).
 113             if (pa < pb) return false;
 114             if (pa > pb) return true;
 115
 116             // Identical blocks.
 117             return false;
 118         }
 119     };
 120
 121     CBlockIndex *pindexBestInvalid;
 122
 123     /**
 124      * The set of all CBlockIndex entries with BLOCK_VALID_TRANSACTIONS (for itself and all ancestors) and
 125      * as good as our current tip or better. Entries may be failed, though, and pruning nodes may be
 126      * missing the data for the block.
 127      */
 128     set<CBlockIndex*, CBlockIndexWorkComparator> setBlockIndexCandidates;
 129     /** Number of nodes with fSyncStarted. */
 130     int nSyncStarted = 0;
 131     /** All pairs A->B, where A (or one if its ancestors) misses transactions, but B has transactions.
 132       * Pruned nodes may have entries where B is missing data.
 133       */
 134     multimap<CBlockIndex*, CBlockIndex*> mapBlocksUnlinked;
 135
 136     CCriticalSection cs_LastBlockFile;
 137     std::vector<CBlockFileInfo> vinfoBlockFile;
 138     int nLastBlockFile = 0;
 139     /** Global flag to indicate we should check to see if there are
 140      *  block/undo files that should be deleted.  Set on startup
 141      *  or if we allocate more file space when we're in prune mode
 142      */
 143     bool fCheckForPruning = false;
 144
 145     /**
 146      * Every received block is assigned a unique and increasing identifier, so we
 147      * know which one to give priority in case of a fork.
 148      */
 149     CCriticalSection cs_nBlockSequenceId;
 150     /** Blocks loaded from disk are assigned id 0, so start the counter at 1. */
 151     uint32_t nBlockSequenceId = 1;
 152
 153     /**
 154      * Sources of received blocks, saved to be able to send them reject
 155      * messages or ban them when processing happens afterwards. Protected by
 156      * cs_main.
 157      */
 158     map<uint256, NodeId> mapBlockSource;
 159
 160     /**
 161      * Filter for transactions that were recently rejected by
 162      * AcceptToMemoryPool. These are not rerequested until the chain tip
 163      * changes, at which point the entire filter is reset. Protected by
 164      * cs_main.
 165      *
 166      * Without this filter we'd be re-requesting txs from each of our peers,
 167      * increasing bandwidth consumption considerably. For instance, with 100
 168      * peers, half of which relay a tx we don't accept, that might be a 50x
 169      * bandwidth increase. A flooding attacker attempting to roll-over the
 170      * filter using minimum-sized, 60byte, transactions might manage to send
 171      * 1000/sec if we have fast peers, so we pick 120,000 to give our peers a
 172      * two minute window to send invs to us.
 173      *
 174      * Decreasing the false positive rate is fairly cheap, so we pick one in a
 175      * million to make it highly unlikely for users to have issues with this
 176      * filter.
 177      *
 178      * Memory used: 1.7MB
 179      */
 180     boost::scoped_ptr<CRollingBloomFilter> recentRejects;
 181     uint256 hashRecentRejectsChainTip;
 182
 183     /** Blocks that are in flight, and that are in the queue to be downloaded. Protected by cs_main. */
 184     struct QueuedBlock {
 185         uint256 hash;
 186         CBlockIndex *pindex;  //! Optional.
 187         int64_t nTime;  //! Time of "getdata" request in microseconds.
 188         bool fValidatedHeaders;  //! Whether this block has validated headers at the time of request.
 189         int64_t nTimeDisconnect; //! The timeout for this block request (for disconnecting a slow peer)
 190     };
 191     map<uint256, pair<NodeId, list<QueuedBlock>::iterator> > mapBlocksInFlight;
 192
 193     /** Number of blocks in flight with validated headers. */
 194     int nQueuedValidatedHeaders = 0;
 195
 196     /** Number of preferable block download peers. */
 197     int nPreferredDownload = 0;
 198
 199     /** Dirty block index entries. */
 200     set<CBlockIndex*> setDirtyBlockIndex;
 201
 202     /** Dirty block file entries. */
 203     set<int> setDirtyFileInfo;
 204 } // anon namespace
 205
 206 //////////////////////////////////////////////////////////////////////////////
 207 //
 208 // Registration of network node signals.
 209 //
 210
 211 namespace {
 212
 213 struct CBlockReject {
 214     unsigned char chRejectCode;
 215     string strRejectReason;
 216     uint256 hashBlock;
 217 };
 218
 219 /**
 220  * Maintain validation-specific state about nodes, protected by cs_main, instead
 221  * by CNode's own locks. This simplifies asynchronous operation, where
 222  * processing of incoming data is done after the ProcessMessage call returns,
 223  * and we're no longer holding the node's locks.
 224  */
 225 struct CNodeState {
 226     //! The peer's address
 227     CService address;
 228     //! Whether we have a fully established connection.
 229     bool fCurrentlyConnected;
 230     //! Accumulated misbehaviour score for this peer.
 231     int nMisbehavior;
 232     //! Whether this peer should be disconnected and banned (unless whitelisted).
 233     bool fShouldBan;
 234     //! String name of this peer (debugging/logging purposes).
 235     std::string name;
 236     //! List of asynchronously-determined block rejections to notify this peer about.
 237     std::vector<CBlockReject> rejects;
 238     //! The best known block we know this peer has announced.
 239     CBlockIndex *pindexBestKnownBlock;
 240     //! The hash of the last unknown block this peer has announced.
 241     uint256 hashLastUnknownBlock;
 242     //! The last full block we both have.
 243     CBlockIndex *pindexLastCommonBlock;
 244     //! Whether we've started headers synchronization with this peer.
 245     bool fSyncStarted;
 246     //! Since when we're stalling block download progress (in microseconds), or 0.
 247     int64_t nStallingSince;
 248     list<QueuedBlock> vBlocksInFlight;
 249     int nBlocksInFlight;
 250     int nBlocksInFlightValidHeaders;
 251     //! Whether we consider this a preferred download peer.
 252     bool fPreferredDownload;
 253
 254     CNodeState() {
 255         fCurrentlyConnected = false;
 256         nMisbehavior = 0;
 257         fShouldBan = false;
 258         pindexBestKnownBlock = NULL;
 259         hashLastUnknownBlock.SetNull();
 260         pindexLastCommonBlock = NULL;
 261         fSyncStarted = false;
 262         nStallingSince = 0;
 263         nBlocksInFlight = 0;
 264         nBlocksInFlightValidHeaders = 0;
 265         fPreferredDownload = false;
 266     }
 267 };
 268
 269 /** Map maintaining per-node state. Requires cs_main. */
 270 map<NodeId, CNodeState> mapNodeState;
 271
 272 // Requires cs_main.
 273 CNodeState *State(NodeId pnode) {
 274     map<NodeId, CNodeState>::iterator it = mapNodeState.find(pnode);
 275     if (it == mapNodeState.end())
 276         return NULL;
 277     return &it->second;
 278 }
 279
 280 int GetHeight()
 281 {
 282     LOCK(cs_main);
 283     return chainActive.Height();
 284 }
 285
 286 void UpdatePreferredDownload(CNode* node, CNodeState* state)
 287 {
 288     nPreferredDownload -= state->fPreferredDownload;
 289
 290     // Whether this node should be marked as a preferred download node.
 291     state->fPreferredDownload = (!node->fInbound || node->fWhitelisted) && !node->fOneShot && !node->fClient;
 292
 293     nPreferredDownload += state->fPreferredDownload;
 294 }
 295
 296 // Returns time at which to timeout block request (nTime in microseconds)
 297 int64_t GetBlockTimeout(int64_t nTime, int nValidatedQueuedBefore, const Consensus::Params &consensusParams)
 298 {
 299     return nTime + 500000 * consensusParams.nPowTargetSpacing * (4 + nValidatedQueuedBefore);
 300 }
 301
 302 void InitializeNode(NodeId nodeid, const CNode *pnode) {
 303     LOCK(cs_main);
 304     CNodeState &state = mapNodeState.insert(std::make_pair(nodeid, CNodeState())).first->second;
 305     state.name = pnode->addrName;
 306     state.address = pnode->addr;
 307 }
 308
 309 void FinalizeNode(NodeId nodeid) {
 310     LOCK(cs_main);
 311     CNodeState *state = State(nodeid);
 312
 313     if (state->fSyncStarted)
 314         nSyncStarted--;
 315
 316     if (state->nMisbehavior == 0 && state->fCurrentlyConnected) {
 317         AddressCurrentlyConnected(state->address);
 318     }
 319
 320     BOOST_FOREACH(const QueuedBlock& entry, state->vBlocksInFlight)
 321         mapBlocksInFlight.erase(entry.hash);
 322     EraseOrphansFor(nodeid);
 323     nPreferredDownload -= state->fPreferredDownload;
 324
 325     mapNodeState.erase(nodeid);
 326 }
 327
 328 // Requires cs_main.
 329 // Returns a bool indicating whether we requested this block.
 330 bool MarkBlockAsReceived(const uint256& hash) {
 331     map<uint256, pair<NodeId, list<QueuedBlock>::iterator> >::iterator itInFlight = mapBlocksInFlight.find(hash);
 332     if (itInFlight != mapBlocksInFlight.end()) {
 333         CNodeState *state = State(itInFlight->second.first);
 334         nQueuedValidatedHeaders -= itInFlight->second.second->fValidatedHeaders;
 335         state->nBlocksInFlightValidHeaders -= itInFlight->second.second->fValidatedHeaders;
 336         state->vBlocksInFlight.erase(itInFlight->second.second);
 337         state->nBlocksInFlight--;
 338         state->nStallingSince = 0;
 339         mapBlocksInFlight.erase(itInFlight);
 340         return true;
 341     }
 342     return false;
 343 }
 344
 345 // Requires cs_main.
 346 void MarkBlockAsInFlight(NodeId nodeid, const uint256& hash, const Consensus::Params& consensusParams, CBlockIndex *pindex = NULL) {
 347     CNodeState *state = State(nodeid);
 348     assert(state != NULL);
 349
 350     // Make sure it's not listed somewhere already.
 351     MarkBlockAsReceived(hash);
 352
 353     int64_t nNow = GetTimeMicros();
 354     QueuedBlock newentry = {hash, pindex, nNow, pindex != NULL, GetBlockTimeout(nNow, nQueuedValidatedHeaders, consensusParams)};
 355     nQueuedValidatedHeaders += newentry.fValidatedHeaders;
 356     list<QueuedBlock>::iterator it = state->vBlocksInFlight.insert(state->vBlocksInFlight.end(), newentry);
 357     state->nBlocksInFlight++;
 358     state->nBlocksInFlightValidHeaders += newentry.fValidatedHeaders;
 359     mapBlocksInFlight[hash] = std::make_pair(nodeid, it);
 360 }
 361
 362 /** Check whether the last unknown block a peer advertized is not yet known. */
 363 void ProcessBlockAvailability(NodeId nodeid) {
 364     CNodeState *state = State(nodeid);
 365     assert(state != NULL);
 366
 367     if (!state->hashLastUnknownBlock.IsNull()) {
 368         BlockMap::iterator itOld = mapBlockIndex.find(state->hashLastUnknownBlock);
 369         if (itOld != mapBlockIndex.end() && itOld->second->nChainWork > 0) {
 370             if (state->pindexBestKnownBlock == NULL || itOld->second->nChainWork >= state->pindexBestKnownBlock->nChainWork)
 371                 state->pindexBestKnownBlock = itOld->second;
 372             state->hashLastUnknownBlock.SetNull();
 373         }
 374     }
 375 }
 376
 377 /** Update tracking information about which blocks a peer is assumed to have. */
 378 void UpdateBlockAvailability(NodeId nodeid, const uint256 &hash) {
 379     CNodeState *state = State(nodeid);
 380     assert(state != NULL);
 381
 382     ProcessBlockAvailability(nodeid);
 383
 384     BlockMap::iterator it = mapBlockIndex.find(hash);
 385     if (it != mapBlockIndex.end() && it->second->nChainWork > 0) {
 386         // An actually better block was announced.
 387         if (state->pindexBestKnownBlock == NULL || it->second->nChainWork >= state->pindexBestKnownBlock->nChainWork)
 388             state->pindexBestKnownBlock = it->second;
 389     } else {
 390         // An unknown block was announced; just assume that the latest one is the best one.
 391         state->hashLastUnknownBlock = hash;
 392     }
 393 }
 394
 395 /** Find the last common ancestor two blocks have.
 396  *  Both pa and pb must be non-NULL. */
 397 CBlockIndex* LastCommonAncestor(CBlockIndex* pa, CBlockIndex* pb) {
 398     if (pa->nHeight > pb->nHeight) {
 399         pa = pa->GetAncestor(pb->nHeight);
 400     } else if (pb->nHeight > pa->nHeight) {
 401         pb = pb->GetAncestor(pa->nHeight);
 402     }
 403
 404     while (pa != pb && pa && pb) {
 405         pa = pa->pprev;
 406         pb = pb->pprev;
 407     }
 408
 409     // Eventually all chain branches meet at the genesis block.
 410     assert(pa == pb);
 411     return pa;
 412 }
 413
 414 /** Update pindexLastCommonBlock and add not-in-flight missing successors to vBlocks, until it has
 415  *  at most count entries. */
 416 void FindNextBlocksToDownload(NodeId nodeid, unsigned int count, std::vector<CBlockIndex*>& vBlocks, NodeId& nodeStaller) {
 417     if (count == 0)
 418         return;
 419
 420     vBlocks.reserve(vBlocks.size() + count);
 421     CNodeState *state = State(nodeid);
 422     assert(state != NULL);
 423
 424     // Make sure pindexBestKnownBlock is up to date, we'll need it.
 425     ProcessBlockAvailability(nodeid);
 426
 427     if (state->pindexBestKnownBlock == NULL || state->pindexBestKnownBlock->nChainWork < chainActive.Tip()->nChainWork) {
 428         // This peer has nothing interesting.
 429         return;
 430     }
 431
 432     if (state->pindexLastCommonBlock == NULL) {
 433         // Bootstrap quickly by guessing a parent of our best tip is the forking point.
 434         // Guessing wrong in either direction is not a problem.
 435         state->pindexLastCommonBlock = chainActive[std::min(state->pindexBestKnownBlock->nHeight, chainActive.Height())];
 436     }
 437
 438     // If the peer reorganized, our previous pindexLastCommonBlock may not be an ancestor
 439     // of its current tip anymore. Go back enough to fix that.
 440     state->pindexLastCommonBlock = LastCommonAncestor(state->pindexLastCommonBlock, state->pindexBestKnownBlock);
 441     if (state->pindexLastCommonBlock == state->pindexBestKnownBlock)
 442         return;
 443
 444     std::vector<CBlockIndex*> vToFetch;
 445     CBlockIndex *pindexWalk = state->pindexLastCommonBlock;
 446     // Never fetch further than the best block we know the peer has, or more than BLOCK_DOWNLOAD_WINDOW + 1 beyond the last
 447     // linked block we have in common with this peer. The +1 is so we can detect stalling, namely if we would be able to
 448     // download that next block if the window were 1 larger.
 449     int nWindowEnd = state->pindexLastCommonBlock->nHeight + BLOCK_DOWNLOAD_WINDOW;
 450     int nMaxHeight = std::min<int>(state->pindexBestKnownBlock->nHeight, nWindowEnd + 1);
 451     NodeId waitingfor = -1;
 452     while (pindexWalk->nHeight < nMaxHeight) {
 453         // Read up to 128 (or more, if more blocks than that are needed) successors of pindexWalk (towards
 454         // pindexBestKnownBlock) into vToFetch. We fetch 128, because CBlockIndex::GetAncestor may be as expensive
 455         // as iterating over ~100 CBlockIndex* entries anyway.
 456         int nToFetch = std::min(nMaxHeight - pindexWalk->nHeight, std::max<int>(count - vBlocks.size(), 128));
 457         vToFetch.resize(nToFetch);
 458         pindexWalk = state->pindexBestKnownBlock->GetAncestor(pindexWalk->nHeight + nToFetch);
 459         vToFetch[nToFetch - 1] = pindexWalk;
 460         for (unsigned int i = nToFetch - 1; i > 0; i--) {
 461             vToFetch[i - 1] = vToFetch[i]->pprev;
 462         }
 463
 464         // Iterate over those blocks in vToFetch (in forward direction), adding the ones that
 465         // are not yet downloaded and not in flight to vBlocks. In the mean time, update
 466         // pindexLastCommonBlock as long as all ancestors are already downloaded, or if it's
 467         // already part of our chain (and therefore don't need it even if pruned).
 468         BOOST_FOREACH(CBlockIndex* pindex, vToFetch) {
 469             if (!pindex->IsValid(BLOCK_VALID_TREE)) {
 470                 // We consider the chain that this peer is on invalid.
 471                 return;
 472             }
 473             if (pindex->nStatus & BLOCK_HAVE_DATA || chainActive.Contains(pindex)) {
 474                 if (pindex->nChainTx)
 475                     state->pindexLastCommonBlock = pindex;
 476             } else if (mapBlocksInFlight.count(pindex->GetBlockHash()) == 0) {
 477                 // The block is not already downloaded, and not yet in flight.
 478                 if (pindex->nHeight > nWindowEnd) {
 479                     // We reached the end of the window.
 480                     if (vBlocks.size() == 0 && waitingfor != nodeid) {
 481                         // We aren't able to fetch anything, but we would be if the download window was one larger.
 482                         nodeStaller = waitingfor;
 483                     }
 484                     return;
 485                 }
 486                 vBlocks.push_back(pindex);
 487                 if (vBlocks.size() == count) {
 488                     return;
 489                 }
 490             } else if (waitingfor == -1) {
 491                 // This is the first already-in-flight block.
 492                 waitingfor = mapBlocksInFlight[pindex->GetBlockHash()].first;
 493             }
 494         }
 495     }
 496 }
 497
 498 } // anon namespace
 499
 500 bool GetNodeStateStats(NodeId nodeid, CNodeStateStats &stats) {
 501     LOCK(cs_main);
 502     CNodeState *state = State(nodeid);
 503     if (state == NULL)
 504         return false;
 505     stats.nMisbehavior = state->nMisbehavior;
 506     stats.nSyncHeight = state->pindexBestKnownBlock ? state->pindexBestKnownBlock->nHeight : -1;
 507     stats.nCommonHeight = state->pindexLastCommonBlock ? state->pindexLastCommonBlock->nHeight : -1;
 508     BOOST_FOREACH(const QueuedBlock& queue, state->vBlocksInFlight) {
 509         if (queue.pindex)
 510             stats.vHeightInFlight.push_back(queue.pindex->nHeight);
 511     }
 512     return true;
 513 }
 514
 515 void RegisterNodeSignals(CNodeSignals& nodeSignals)
 516 {
 517     nodeSignals.GetHeight.connect(&GetHeight);
 518     nodeSignals.ProcessMessages.connect(&ProcessMessages);
 519     nodeSignals.SendMessages.connect(&SendMessages);
 520     nodeSignals.InitializeNode.connect(&InitializeNode);
 521     nodeSignals.FinalizeNode.connect(&FinalizeNode);
 522 }
 523
 524 void UnregisterNodeSignals(CNodeSignals& nodeSignals)
 525 {
 526     nodeSignals.GetHeight.disconnect(&GetHeight);
 527     nodeSignals.ProcessMessages.disconnect(&ProcessMessages);
 528     nodeSignals.SendMessages.disconnect(&SendMessages);
 529     nodeSignals.InitializeNode.disconnect(&InitializeNode);
 530     nodeSignals.FinalizeNode.disconnect(&FinalizeNode);
 531 }
 532
 533 CBlockIndex* FindForkInGlobalIndex(const CChain& chain, const CBlockLocator& locator)
 534 {
 535     // Find the first block the caller has in the main chain
 536     BOOST_FOREACH(const uint256& hash, locator.vHave) {
 537         BlockMap::iterator mi = mapBlockIndex.find(hash);
 538         if (mi != mapBlockIndex.end())
 539         {
 540             CBlockIndex* pindex = (*mi).second;
 541             if (chain.Contains(pindex))
 542                 return pindex;
 543         }
 544     }
 545     return chain.Genesis();
 546 }
 547
 548 CCoinsViewCache *pcoinsTip = NULL;
 549 CBlockTreeDB *pblocktree = NULL;
 550
 551 // Komodo globals
 552 int32_t IS_KOMODO_NOTARY,USE_EXTERNAL_PUBKEY;
 553 std::string NOTARY_PUBKEY;
 554 uint8_t NOTARY_PUBKEY33[33];
 555
 556 #define KOMODO_TESTNET_EXPIRATION 60000
 557 //#define KOMODO_ENABLE_INTEREST enabling this is a hardfork
 558 #define KOMODO_SOURCE "KMD"
 559 #define KOMODO_PAX
 560 #define KOMODO_ZCASH
 561 #include "komodo.h"
 562
 563 //////////////////////////////////////////////////////////////////////////////
 564 //
 565 // mapOrphanTransactions
 566 //
 567
 568 bool AddOrphanTx(const CTransaction& tx, NodeId peer)
 569 {
 570     uint256 hash = tx.GetHash();
 571     if (mapOrphanTransactions.count(hash))
 572         return false;
 573
 574     // Ignore big transactions, to avoid a
 575     // send-big-orphans memory exhaustion attack. If a peer has a legitimate
 576     // large transaction with a missing parent then we assume
 577     // it will rebroadcast it later, after the parent transaction(s)
 578     // have been mined or received.
 579     // 10,000 orphans, each of which is at most 5,000 bytes big is
 580     // at most 500 megabytes of orphans:
 581     unsigned int sz = tx.GetSerializeSize(SER_NETWORK, tx.nVersion);
 582     if (sz > 5000)
 583     {
 584         LogPrint("mempool", "ignoring large orphan tx (size: %u, hash: %s)\n", sz, hash.ToString());
 585         return false;
 586     }
 587
 588     mapOrphanTransactions[hash].tx = tx;
 589     mapOrphanTransactions[hash].fromPeer = peer;
 590     BOOST_FOREACH(const CTxIn& txin, tx.vin)
 591         mapOrphanTransactionsByPrev[txin.prevout.hash].insert(hash);
 592
 593     LogPrint("mempool", "stored orphan tx %s (mapsz %u prevsz %u)\n", hash.ToString(),
 594              mapOrphanTransactions.size(), mapOrphanTransactionsByPrev.size());
 595     return true;
 596 }
 597
 598 void static EraseOrphanTx(uint256 hash)
 599 {
 600     map<uint256, COrphanTx>::iterator it = mapOrphanTransactions.find(hash);
 601     if (it == mapOrphanTransactions.end())
 602         return;
 603     BOOST_FOREACH(const CTxIn& txin, it->second.tx.vin)
 604     {
 605         map<uint256, set<uint256> >::iterator itPrev = mapOrphanTransactionsByPrev.find(txin.prevout.hash);
 606         if (itPrev == mapOrphanTransactionsByPrev.end())
 607             continue;
 608         itPrev->second.erase(hash);
 609         if (itPrev->second.empty())
 610             mapOrphanTransactionsByPrev.erase(itPrev);
 611     }
 612     mapOrphanTransactions.erase(it);
 613 }
 614
 615 void EraseOrphansFor(NodeId peer)
 616 {
 617     int nErased = 0;
 618     map<uint256, COrphanTx>::iterator iter = mapOrphanTransactions.begin();
 619     while (iter != mapOrphanTransactions.end())
 620     {
 621         map<uint256, COrphanTx>::iterator maybeErase = iter++; // increment to avoid iterator becoming invalid
 622         if (maybeErase->second.fromPeer == peer)
 623         {
 624             EraseOrphanTx(maybeErase->second.tx.GetHash());
 625             ++nErased;
 626         }
 627     }
 628     if (nErased > 0) LogPrint("mempool", "Erased %d orphan tx from peer %d\n", nErased, peer);
 629 }
 630
 631
 632 unsigned int LimitOrphanTxSize(unsigned int nMaxOrphans)
 633 {
 634     unsigned int nEvicted = 0;
 635     while (mapOrphanTransactions.size() > nMaxOrphans)
 636     {
 637         // Evict a random orphan:
 638         uint256 randomhash = GetRandHash();
 639         map<uint256, COrphanTx>::iterator it = mapOrphanTransactions.lower_bound(randomhash);
 640         if (it == mapOrphanTransactions.end())
 641             it = mapOrphanTransactions.begin();
 642         EraseOrphanTx(it->first);
 643         ++nEvicted;
 644     }
 645     return nEvicted;
 646 }
 647
 648
 649
 650
 651
 652
 653
 654 bool IsStandardTx(const CTransaction& tx, string& reason)
 655 {
 656     if (tx.nVersion > CTransaction::MAX_CURRENT_VERSION || tx.nVersion < CTransaction::MIN_CURRENT_VERSION) {
 657         reason = "version";
 658         return false;
 659     }
 660
 661     BOOST_FOREACH(const CTxIn& txin, tx.vin)
 662     {
 663         // Biggest 'standard' txin is a 15-of-15 P2SH multisig with compressed
 664         // keys. (remember the 520 byte limit on redeemScript size) That works
 665         // out to a (15*(33+1))+3=513 byte redeemScript, 513+1+15*(73+1)+3=1627
 666         // bytes of scriptSig, which we round off to 1650 bytes for some minor
 667         // future-proofing. That's also enough to spend a 20-of-20
 668         // CHECKMULTISIG scriptPubKey, though such a scriptPubKey is not
 669         // considered standard)
 670         if (txin.scriptSig.size() > 1650) {
 671             reason = "scriptsig-size";
 672             return false;
 673         }
 674         if (!txin.scriptSig.IsPushOnly()) {
 675             reason = "scriptsig-not-pushonly";
 676             return false;
 677         }
 678     }
 679
 680     unsigned int v=0,nDataOut = 0;
 681     txnouttype whichType;
 682     BOOST_FOREACH(const CTxOut& txout, tx.vout)
 683     {
 684         if (!::IsStandard(txout.scriptPubKey, whichType)) {
 685             reason = "scriptpubkey";
 686             fprintf(stderr,"vout.%d nDataout.%d\n",v,nDataOut);
 687             return false;
 688         }
 689
 690         if (whichType == TX_NULL_DATA)
 691             nDataOut++;
 692         else if ((whichType == TX_MULTISIG) && (!fIsBareMultisigStd)) {
 693             reason = "bare-multisig";
 694             return false;
 695         } else if (txout.IsDust(::minRelayTxFee)) {
 696             reason = "dust";
 697             return false;
 698         }
 699         v++;
 700     }
 701
 702     // only one OP_RETURN txout is permitted
 703     if (nDataOut > 1) {
 704         reason = "multi-op-return";
 705         return false;
 706     }
 707
 708     return true;
 709 }
 710
 711 bool IsFinalTx(const CTransaction &tx, int nBlockHeight, int64_t nBlockTime)
 712 {
 713     if (tx.nLockTime == 0)
 714         return true;
 715     if ((int64_t)tx.nLockTime < ((int64_t)tx.nLockTime < LOCKTIME_THRESHOLD ? (int64_t)nBlockHeight : nBlockTime))
 716         return true;
 717     if ( (int64_t)tx.nLockTime >= LOCKTIME_THRESHOLD && (int64_t)tx.nLockTime < nBlockTime-3600 )
 718     {
 719         fprintf(stderr,"IsFinalTx reject locktime %u vs nBlockTime %u\n",tx.nLockTime,(uint32_t)nBlockTime);
 720         return(false); // need to prevent pastdating tx
 721     }
 722     BOOST_FOREACH(const CTxIn& txin, tx.vin)
 723     {
 724         if ( txin.nSequence == 0xfffffffe && (((int64_t)tx.nLockTime >= LOCKTIME_THRESHOLD && (int64_t)tx.nLockTime > nBlockTime) || ((int64_t)tx.nLockTime < LOCKTIME_THRESHOLD && (int64_t)tx.nLockTime > nBlockHeight)) )
 725         {
 726
 727         }
 728         else if (!txin.IsFinal())
 729         {
 730             printf("non-final txin seq.%x locktime.%u vs nTime.%u\n",txin.nSequence,(uint32_t)tx.nLockTime,(uint32_t)nBlockTime);
 731             return false;
 732         }
 733     }
 734     return true;
 735 }
 736
 737 bool CheckFinalTx(const CTransaction &tx, int flags)
 738 {
 739     AssertLockHeld(cs_main);
 740
 741     // By convention a negative value for flags indicates that the
 742     // current network-enforced consensus rules should be used. In
 743     // a future soft-fork scenario that would mean checking which
 744     // rules would be enforced for the next block and setting the
 745     // appropriate flags. At the present time no soft-forks are
 746     // scheduled, so no flags are set.
 747     flags = std::max(flags, 0);
 748
 749     // CheckFinalTx() uses chainActive.Height()+1 to evaluate
 750     // nLockTime because when IsFinalTx() is called within
 751     // CBlock::AcceptBlock(), the height of the block *being*
 752     // evaluated is what is used. Thus if we want to know if a
 753     // transaction can be part of the *next* block, we need to call
 754     // IsFinalTx() with one more than chainActive.Height().
 755     const int nBlockHeight = chainActive.Height() + 1;
 756
 757     // Timestamps on the other hand don't get any special treatment,
 758     // because we can't know what timestamp the next block will have,
 759     // and there aren't timestamp applications where it matters.
 760     // However this changes once median past time-locks are enforced:
 761     const int64_t nBlockTime = (flags & LOCKTIME_MEDIAN_TIME_PAST)
 762                              ? chainActive.Tip()->GetMedianTimePast()
 763                              : GetAdjustedTime();
 764
 765     return IsFinalTx(tx, nBlockHeight, nBlockTime);
 766 }
 767
 768 /**
 769  * Check transaction inputs to mitigate two
 770  * potential denial-of-service attacks:
 771  *
 772  * 1. scriptSigs with extra data stuffed into them,
 773  *    not consumed by scriptPubKey (or P2SH script)
 774  * 2. P2SH scripts with a crazy number of expensive
 775  *    CHECKSIG/CHECKMULTISIG operations
 776  */
 777 bool AreInputsStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs)
 778 {
 779     if (tx.IsCoinBase())
 780         return true; // Coinbases don't use vin normally
 781
 782     for (unsigned int i = 0; i < tx.vin.size(); i++)
 783     {
 784         const CTxOut& prev = mapInputs.GetOutputFor(tx.vin[i]);
 785
 786         vector<vector<unsigned char> > vSolutions;
 787         txnouttype whichType;
 788         // get the scriptPubKey corresponding to this input:
 789         const CScript& prevScript = prev.scriptPubKey;
 790         if (!Solver(prevScript, whichType, vSolutions))
 791             return false;
 792         int nArgsExpected = ScriptSigArgsExpected(whichType, vSolutions);
 793         if (nArgsExpected < 0)
 794             return false;
 795
 796         // Transactions with extra stuff in their scriptSigs are
 797         // non-standard. Note that this EvalScript() call will
 798         // be quick, because if there are any operations
 799         // beside "push data" in the scriptSig
 800         // IsStandardTx() will have already returned false
 801         // and this method isn't called.
 802         vector<vector<unsigned char> > stack;
 803         if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker()))
 804             return false;
 805
 806         if (whichType == TX_SCRIPTHASH)
 807         {
 808             if (stack.empty())
 809                 return false;
 810             CScript subscript(stack.back().begin(), stack.back().end());
 811             vector<vector<unsigned char> > vSolutions2;
 812             txnouttype whichType2;
 813             if (Solver(subscript, whichType2, vSolutions2))
 814             {
 815                 int tmpExpected = ScriptSigArgsExpected(whichType2, vSolutions2);
 816                 if (tmpExpected < 0)
 817                     return false;
 818                 nArgsExpected += tmpExpected;
 819             }
 820             else
 821             {
 822                 // Any other Script with less than 15 sigops OK:
 823                 unsigned int sigops = subscript.GetSigOpCount(true);
 824                 // ... extra data left on the stack after execution is OK, too:
 825                 return (sigops <= MAX_P2SH_SIGOPS);
 826             }
 827         }
 828
 829         if (stack.size() != (unsigned int)nArgsExpected)
 830             return false;
 831     }
 832
 833     return true;
 834 }
 835
 836 unsigned int GetLegacySigOpCount(const CTransaction& tx)
 837 {
 838     unsigned int nSigOps = 0;
 839     BOOST_FOREACH(const CTxIn& txin, tx.vin)
 840     {
 841         nSigOps += txin.scriptSig.GetSigOpCount(false);
 842     }
 843     BOOST_FOREACH(const CTxOut& txout, tx.vout)
 844     {
 845         nSigOps += txout.scriptPubKey.GetSigOpCount(false);
 846     }
 847     return nSigOps;
 848 }
 849
 850 unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewCache& inputs)
 851 {
 852     if (tx.IsCoinBase())
 853         return 0;
 854
 855     unsigned int nSigOps = 0;
 856     for (unsigned int i = 0; i < tx.vin.size(); i++)
 857     {
 858         const CTxOut &prevout = inputs.GetOutputFor(tx.vin[i]);
 859         if (prevout.scriptPubKey.IsPayToScriptHash())
 860             nSigOps += prevout.scriptPubKey.GetSigOpCount(tx.vin[i].scriptSig);
 861     }
 862     return nSigOps;
 863 }
 864
 865 bool CheckTransaction(const CTransaction& tx, CValidationState &state)
 866 {
 867     // Don't count coinbase transactions because mining skews the count
 868     if (!tx.IsCoinBase()) {
 869         transactionsValidated.increment();
 870     }
 871
 872     if (!CheckTransactionWithoutProofVerification(tx, state)) {
 873         return false;
 874     } else {
 875         // Ensure that zk-SNARKs verify
 876         BOOST_FOREACH(const JSDescription &joinsplit, tx.vjoinsplit) {
 877             if (!joinsplit.Verify(*pzcashParams, tx.joinSplitPubKey)) {
 878                 return state.DoS(100, error("CheckTransaction(): joinsplit does not verify"),
 879                                     REJECT_INVALID, "bad-txns-joinsplit-verification-failed");
 880             }
 881         }
 882         return true;
 883     }
 884 }
 885
 886 bool CheckTransactionWithoutProofVerification(const CTransaction& tx, CValidationState &state)
 887 {
 888     // Basic checks that don't depend on any context
 889
 890     // Check transaction version
 891     if (tx.nVersion < MIN_TX_VERSION) {
 892         return state.DoS(100, error("CheckTransaction(): version too low"),
 893                          REJECT_INVALID, "bad-txns-version-too-low");
 894     }
 895
 896     // Transactions can contain empty `vin` and `vout` so long as
 897     // `vjoinsplit` is non-empty.
 898     if (tx.vin.empty() && tx.vjoinsplit.empty())
 899         return state.DoS(10, error("CheckTransaction(): vin empty"),
 900                          REJECT_INVALID, "bad-txns-vin-empty");
 901     if (tx.vout.empty() && tx.vjoinsplit.empty())
 902         return state.DoS(10, error("CheckTransaction(): vout empty"),
 903                          REJECT_INVALID, "bad-txns-vout-empty");
 904
 905     // Size limits
 906     BOOST_STATIC_ASSERT(MAX_BLOCK_SIZE > MAX_TX_SIZE); // sanity
 907     if (::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION) > MAX_TX_SIZE)
 908         return state.DoS(100, error("CheckTransaction(): size limits failed"),
 909                          REJECT_INVALID, "bad-txns-oversize");
 910
 911     // Check for negative or overflow output values
 912     CAmount nValueOut = 0;
 913     BOOST_FOREACH(const CTxOut& txout, tx.vout)
 914     {
 915         if (txout.nValue < 0)
 916             return state.DoS(100, error("CheckTransaction(): txout.nValue negative"),
 917                              REJECT_INVALID, "bad-txns-vout-negative");
 918         if (txout.nValue > MAX_MONEY)
 919             return state.DoS(100, error("CheckTransaction(): txout.nValue too high"),
 920                              REJECT_INVALID, "bad-txns-vout-toolarge");
 921         nValueOut += txout.nValue;
 922         if (!MoneyRange(nValueOut))
 923             return state.DoS(100, error("CheckTransaction(): txout total out of range"),
 924                              REJECT_INVALID, "bad-txns-txouttotal-toolarge");
 925     }
 926
 927     // Ensure that joinsplit values are well-formed
 928     BOOST_FOREACH(const JSDescription& joinsplit, tx.vjoinsplit)
 929     {
 930         if (joinsplit.vpub_old < 0) {
 931             return state.DoS(100, error("CheckTransaction(): joinsplit.vpub_old negative"),
 932                              REJECT_INVALID, "bad-txns-vpub_old-negative");
 933         }
 934
 935         if (joinsplit.vpub_new < 0) {
 936             return state.DoS(100, error("CheckTransaction(): joinsplit.vpub_new negative"),
 937                              REJECT_INVALID, "bad-txns-vpub_new-negative");
 938         }
 939
 940         if (joinsplit.vpub_old > MAX_MONEY) {
 941             return state.DoS(100, error("CheckTransaction(): joinsplit.vpub_old too high"),
 942                              REJECT_INVALID, "bad-txns-vpub_old-toolarge");
 943         }
 944
 945         if (joinsplit.vpub_new > MAX_MONEY) {
 946             return state.DoS(100, error("CheckTransaction(): joinsplit.vpub_new too high"),
 947                              REJECT_INVALID, "bad-txns-vpub_new-toolarge");
 948         }
 949
 950         if (joinsplit.vpub_new != 0 && joinsplit.vpub_old != 0) {
 951             return state.DoS(100, error("CheckTransaction(): joinsplit.vpub_new and joinsplit.vpub_old both nonzero"),
 952                              REJECT_INVALID, "bad-txns-vpubs-both-nonzero");
 953         }
 954
 955         nValueOut += joinsplit.vpub_old;
 956         if (!MoneyRange(nValueOut)) {
 957             return state.DoS(100, error("CheckTransaction(): txout total out of range"),
 958                              REJECT_INVALID, "bad-txns-txouttotal-toolarge");
 959         }
 960     }
 961
 962     // Ensure input values do not exceed MAX_MONEY
 963     // We have not resolved the txin values at this stage,
 964     // but we do know what the joinsplits claim to add
 965     // to the value pool.
 966     {
 967         CAmount nValueIn = 0;
 968         for (std::vector<JSDescription>::const_iterator it(tx.vjoinsplit.begin()); it != tx.vjoinsplit.end(); ++it)
 969         {
 970             nValueIn += it->vpub_new;
 971
 972             if (!MoneyRange(it->vpub_new) || !MoneyRange(nValueIn)) {
 973                 return state.DoS(100, error("CheckTransaction(): txin total out of range"),
 974                                  REJECT_INVALID, "bad-txns-txintotal-toolarge");
 975             }
 976         }
 977     }
 978
 979
 980     // Check for duplicate inputs
 981     set<COutPoint> vInOutPoints;
 982     BOOST_FOREACH(const CTxIn& txin, tx.vin)
 983     {
 984         if (vInOutPoints.count(txin.prevout))
 985             return state.DoS(100, error("CheckTransaction(): duplicate inputs"),
 986                              REJECT_INVALID, "bad-txns-inputs-duplicate");
 987         vInOutPoints.insert(txin.prevout);
 988     }
 989
 990     // Check for duplicate joinsplit nullifiers in this transaction
 991     set<uint256> vJoinSplitNullifiers;
 992     BOOST_FOREACH(const JSDescription& joinsplit, tx.vjoinsplit)
 993     {
 994         BOOST_FOREACH(const uint256& nf, joinsplit.nullifiers)
 995         {
 996             if (vJoinSplitNullifiers.count(nf))
 997                 return state.DoS(100, error("CheckTransaction(): duplicate nullifiers"),
 998                              REJECT_INVALID, "bad-joinsplits-nullifiers-duplicate");
 999
1000             vJoinSplitNullifiers.insert(nf);
1001         }
1002     }
1003
1004     if (tx.IsCoinBase())
1005     {
1006         // There should be no joinsplits in a coinbase transaction
1007         if (tx.vjoinsplit.size() > 0)
1008             return state.DoS(100, error("CheckTransaction(): coinbase has joinsplits"),
1009                              REJECT_INVALID, "bad-cb-has-joinsplits");
1010
1011         if (tx.vin[0].scriptSig.size() < 2 || tx.vin[0].scriptSig.size() > 100)
1012             return state.DoS(100, error("CheckTransaction(): coinbase script size"),
1013                              REJECT_INVALID, "bad-cb-length");
1014     }
1015     else
1016     {
1017         BOOST_FOREACH(const CTxIn& txin, tx.vin)
1018             if (txin.prevout.IsNull())
1019                 return state.DoS(10, error("CheckTransaction(): prevout is null"),
1020                                  REJECT_INVALID, "bad-txns-prevout-null");
1021
1022         if (tx.vjoinsplit.size() > 0) {
1023             // Empty output script.
1024             CScript scriptCode;
1025             uint256 dataToBeSigned;
1026             try {
1027                 dataToBeSigned = SignatureHash(scriptCode, tx, NOT_AN_INPUT, SIGHASH_ALL);
1028             } catch (std::logic_error ex) {
1029                 return state.DoS(100, error("CheckTransaction(): error computing signature hash"),
1030                                  REJECT_INVALID, "error-computing-signature-hash");
1031             }
1032
1033             BOOST_STATIC_ASSERT(crypto_sign_PUBLICKEYBYTES == 32);
1034
1035             // We rely on libsodium to check that the signature is canonical.
1036             // https://github.com/jedisct1/libsodium/commit/62911edb7ff2275cccd74bf1c8aefcc4d76924e0
1037             if (crypto_sign_verify_detached(&tx.joinSplitSig[0],
1038                                             dataToBeSigned.begin(), 32,
1039                                             tx.joinSplitPubKey.begin()
1040                                            ) != 0) {
1041                 return state.DoS(100, error("CheckTransaction(): invalid joinsplit signature"),
1042                                  REJECT_INVALID, "bad-txns-invalid-joinsplit-signature");
1043             }
1044         }
1045     }
1046
1047     return true;
1048 }
1049
1050 CAmount GetMinRelayFee(const CTransaction& tx, unsigned int nBytes, bool fAllowFree)
1051 {
1052     {
1053         LOCK(mempool.cs);
1054         uint256 hash = tx.GetHash();
1055         double dPriorityDelta = 0;
1056         CAmount nFeeDelta = 0;
1057         mempool.ApplyDeltas(hash, dPriorityDelta, nFeeDelta);
1058         if (dPriorityDelta > 0 || nFeeDelta > 0)
1059             return 0;
1060     }
1061
1062     CAmount nMinFee = ::minRelayTxFee.GetFee(nBytes);
1063
1064     if (fAllowFree)
1065     {
1066         // There is a free transaction area in blocks created by most miners,
1067         // * If we are relaying we allow transactions up to DEFAULT_BLOCK_PRIORITY_SIZE - 1000
1068         //   to be considered to fall into this category. We don't want to encourage sending
1069         //   multiple transactions instead of one big transaction to avoid fees.
1070         if (nBytes < (DEFAULT_BLOCK_PRIORITY_SIZE - 1000))
1071             nMinFee = 0;
1072     }
1073
1074     if (!MoneyRange(nMinFee))
1075         nMinFee = MAX_MONEY;
1076     return nMinFee;
1077 }
1078
1079
1080 bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransaction &tx, bool fLimitFree,bool* pfMissingInputs, bool fRejectAbsurdFee)
1081 {
1082     AssertLockHeld(cs_main);
1083     if (pfMissingInputs)
1084         *pfMissingInputs = false;
1085     if (!CheckTransaction(tx, state))
1086     {
1087         fprintf(stderr,"AcceptToMemoryPool CheckTransaction failed\n");
1088         return error("AcceptToMemoryPool: CheckTransaction failed");
1089     }
1090     // Coinbase is only valid in a block, not as a loose transaction
1091     if (tx.IsCoinBase())
1092     {
1093         fprintf(stderr,"AcceptToMemoryPool coinbase as individual tx\n");
1094         return state.DoS(100, error("AcceptToMemoryPool: coinbase as individual tx"),REJECT_INVALID, "coinbase");
1095     }
1096     // Rather not work on nonstandard transactions (unless -testnet/-regtest)
1097     string reason;
1098     if (Params().RequireStandard() && !IsStandardTx(tx, reason))
1099     {
1100         fprintf(stderr,"AcceptToMemoryPool nonstandard transaction: %s\n",reason.c_str());
1101         return state.DoS(0,error("AcceptToMemoryPool: nonstandard transaction: %s", reason),REJECT_NONSTANDARD, reason);
1102     }
1103     // Only accept nLockTime-using transactions that can be mined in the next
1104     // block; we don't want our mempool filled up with transactions that can't
1105     // be mined yet.
1106     if (!CheckFinalTx(tx, STANDARD_LOCKTIME_VERIFY_FLAGS))
1107     {
1108         fprintf(stderr,"AcceptToMemoryPool non-final\n");
1109         return state.DoS(0, false, REJECT_NONSTANDARD, "non-final");
1110     }
1111    // is it already in the memory pool?
1112     uint256 hash = tx.GetHash();
1113     if (pool.exists(hash))
1114     {
1115         fprintf(stderr,"already in mempool\n");
1116         return false;
1117     }
1118
1119     // Check for conflicts with in-memory transactions
1120     {
1121     LOCK(pool.cs); // protect pool.mapNextTx
1122     for (unsigned int i = 0; i < tx.vin.size(); i++)
1123     {
1124         COutPoint outpoint = tx.vin[i].prevout;
1125         if (pool.mapNextTx.count(outpoint))
1126         {
1127             // Disable replacement feature for now
1128             fprintf(stderr,"Disable replacement feature for now\n");
1129             return false;
1130         }
1131     }
1132     BOOST_FOREACH(const JSDescription &joinsplit, tx.vjoinsplit) {
1133         BOOST_FOREACH(const uint256 &nf, joinsplit.nullifiers) {
1134             if (pool.mapNullifiers.count(nf))
1135             {
1136                 fprintf(stderr,"pool.mapNullifiers.count\n");
1137                 return false;
1138             }
1139         }
1140     }
1141     }
1142
1143     {
1144         CCoinsView dummy;
1145         CCoinsViewCache view(&dummy);
1146         int64_t interest;
1147         CAmount nValueIn = 0;
1148         {
1149         LOCK(pool.cs);
1150         CCoinsViewMemPool viewMemPool(pcoinsTip, pool);
1151         view.SetBackend(viewMemPool);
1152
1153         // do we already have it?
1154         if (view.HaveCoins(hash))
1155         {
1156             fprintf(stderr,"view.HaveCoins(hash) error\n");
1157             return false;
1158         }
1159
1160         // do all inputs exist?
1161         // Note that this does not check for the presence of actual outputs (see the next check for that),
1162         // and only helps with filling in pfMissingInputs (to determine missing vs spent).
1163         BOOST_FOREACH(const CTxIn txin, tx.vin) {
1164             if (!view.HaveCoins(txin.prevout.hash)) {
1165                 if (pfMissingInputs)
1166                     *pfMissingInputs = true;
1167                 //fprintf(stderr,"missing inputs\n");
1168                 return false;
1169             }
1170         }
1171
1172         // are the actual inputs available?
1173         if (!view.HaveInputs(tx))
1174             return state.Invalid(error("AcceptToMemoryPool: inputs already spent"),
1175                                  REJECT_DUPLICATE, "bad-txns-inputs-spent");
1176
1177         // are the joinsplit's requirements met?
1178         if (!view.HaveJoinSplitRequirements(tx))
1179             return state.Invalid(error("AcceptToMemoryPool: joinsplit requirements not met"),
1180                                  REJECT_DUPLICATE, "bad-txns-joinsplit-requirements-not-met");
1181
1182         // Bring the best block into scope
1183         view.GetBestBlock();
1184
1185         nValueIn = view.GetValueIn(chainActive.Tip()->nHeight,&interest,tx,chainActive.Tip()->nTime);
1186
1187         // we have all inputs cached now, so switch back to dummy, so we don't need to keep lock on mempool
1188         view.SetBackend(dummy);
1189         }
1190
1191         // Check for non-standard pay-to-script-hash in inputs
1192         if (Params().RequireStandard() && !AreInputsStandard(tx, view))
1193             return error("AcceptToMemoryPool: nonstandard transaction input");
1194
1195         // Check that the transaction doesn't have an excessive number of
1196         // sigops, making it impossible to mine. Since the coinbase transaction
1197         // itself can contain sigops MAX_STANDARD_TX_SIGOPS is less than
1198         // MAX_BLOCK_SIGOPS; we still consider this an invalid rather than
1199         // merely non-standard transaction.
1200         unsigned int nSigOps = GetLegacySigOpCount(tx);
1201         nSigOps += GetP2SHSigOpCount(tx, view);
1202         if (nSigOps > MAX_STANDARD_TX_SIGOPS)
1203             return state.DoS(0, error("AcceptToMemoryPool: too many sigops %s, %d > %d",
1204                                    hash.ToString(), nSigOps, MAX_STANDARD_TX_SIGOPS),
1205                              REJECT_NONSTANDARD, "bad-txns-too-many-sigops");
1206
1207         CAmount nValueOut = tx.GetValueOut();
1208         CAmount nFees = nValueIn-nValueOut;
1209         double dPriority = view.GetPriority(tx, chainActive.Height());
1210
1211         CTxMemPoolEntry entry(tx, nFees, GetTime(), dPriority, chainActive.Height(), mempool.HasNoInputsOf(tx));
1212         unsigned int nSize = entry.GetTxSize();
1213
1214         // Don't accept it if it can't get into a block
1215         CAmount txMinFee = GetMinRelayFee(tx, nSize, true);
1216         if (fLimitFree && nFees < txMinFee)
1217             return state.DoS(0, error("AcceptToMemoryPool: not enough fees %s, %d < %d",
1218                                       hash.ToString(), nFees, txMinFee),
1219                              REJECT_INSUFFICIENTFEE, "insufficient fee");
1220
1221         // Require that free transactions have sufficient priority to be mined in the next block.
1222         if (GetBoolArg("-relaypriority", false) && nFees < ::minRelayTxFee.GetFee(nSize) && !AllowFree(view.GetPriority(tx, chainActive.Height() + 1))) {
1223             return state.DoS(0, false, REJECT_INSUFFICIENTFEE, "insufficient priority");
1224         }
1225
1226         // Continuously rate-limit free (really, very-low-fee) transactions
1227         // This mitigates 'penny-flooding' -- sending thousands of free transactions just to
1228         // be annoying or make others' transactions take longer to confirm.
1229         if (fLimitFree && nFees < ::minRelayTxFee.GetFee(nSize))
1230         {
1231             static CCriticalSection csFreeLimiter;
1232             static double dFreeCount;
1233             static int64_t nLastTime;
1234             int64_t nNow = GetTime();
1235
1236             LOCK(csFreeLimiter);
1237
1238             // Use an exponentially decaying ~10-minute window:
1239             dFreeCount *= pow(1.0 - 1.0/600.0, (double)(nNow - nLastTime));
1240             nLastTime = nNow;
1241             // -limitfreerelay unit is thousand-bytes-per-minute
1242             // At default rate it would take over a month to fill 1GB
1243             if (dFreeCount >= GetArg("-limitfreerelay", 15)*10*1000)
1244                 return state.DoS(0, error("AcceptToMemoryPool: free transaction rejected by rate limiter"), REJECT_INSUFFICIENTFEE, "rate limited free transaction");
1245             LogPrint("mempool", "Rate limit dFreeCount: %g => %g\n", dFreeCount, dFreeCount+nSize);
1246             dFreeCount += nSize;
1247         }
1248
1249         if (fRejectAbsurdFee && nFees > ::minRelayTxFee.GetFee(nSize) * 10000)
1250             return error("AcceptToMemoryPool: absurdly high fees %s, %d > %d",
1251                          hash.ToString(), nFees, ::minRelayTxFee.GetFee(nSize) * 10000);
1252
1253         // Check against previous transactions
1254         // This is done last to help prevent CPU exhaustion denial-of-service attacks.
1255         if (!ContextualCheckInputs(tx, state, view, true, STANDARD_SCRIPT_VERIFY_FLAGS, true, Params().GetConsensus()))
1256         {
1257             return error("AcceptToMemoryPool: ConnectInputs failed %s", hash.ToString());
1258         }
1259
1260         // Check again against just the consensus-critical mandatory script
1261         // verification flags, in case of bugs in the standard flags that cause
1262         // transactions to pass as valid when they're actually invalid. For
1263         // instance the STRICTENC flag was incorrectly allowing certain
1264         // CHECKSIG NOT scripts to pass, even though they were invalid.
1265         //
1266         // There is a similar check in CreateNewBlock() to prevent creating
1267         // invalid blocks, however allowing such transactions into the mempool
1268         // can be exploited as a DoS attack.
1269         if (!ContextualCheckInputs(tx, state, view, true, MANDATORY_SCRIPT_VERIFY_FLAGS, true, Params().GetConsensus()))
1270         {
1271             return error("AcceptToMemoryPool: BUG! PLEASE REPORT THIS! ConnectInputs failed against MANDATORY but not STANDARD flags %s", hash.ToString());
1272         }
1273
1274         // Store transaction in memory
1275         pool.addUnchecked(hash, entry, !IsInitialBlockDownload());
1276     }
1277
1278     SyncWithWallets(tx, NULL);
1279
1280     return true;
1281 }
1282
1283 /** Return transaction in tx, and if it was found inside a block, its hash is placed in hashBlock */
1284 bool GetTransaction(const uint256 &hash, CTransaction &txOut, uint256 &hashBlock, bool fAllowSlow)
1285 {
1286     CBlockIndex *pindexSlow = NULL;
1287
1288     LOCK(cs_main);
1289
1290     if (mempool.lookup(hash, txOut))
1291     {
1292         return true;
1293     }
1294
1295     if (fTxIndex) {
1296         CDiskTxPos postx;
1297         if (pblocktree->ReadTxIndex(hash, postx)) {
1298             CAutoFile file(OpenBlockFile(postx, true), SER_DISK, CLIENT_VERSION);
1299             if (file.IsNull())
1300                 return error("%s: OpenBlockFile failed", __func__);
1301             CBlockHeader header;
1302             try {
1303                 file >> header;
1304                 fseek(file.Get(), postx.nTxOffset, SEEK_CUR);
1305                 file >> txOut;
1306             } catch (const std::exception& e) {
1307                 return error("%s: Deserialize or I/O error - %s", __func__, e.what());
1308             }
1309             hashBlock = header.GetHash();
1310             if (txOut.GetHash() != hash)
1311                 return error("%s: txid mismatch", __func__);
1312             return true;
1313         }
1314     }
1315
1316     if (fAllowSlow) { // use coin database to locate block that contains transaction, and scan it
1317         int nHeight = -1;
1318         {
1319             CCoinsViewCache &view = *pcoinsTip;
1320             const CCoins* coins = view.AccessCoins(hash);
1321             if (coins)
1322                 nHeight = coins->nHeight;
1323         }
1324         if (nHeight > 0)
1325             pindexSlow = chainActive[nHeight];
1326     }
1327
1328     if (pindexSlow) {
1329         CBlock block;
1330         if (ReadBlockFromDisk(block, pindexSlow)) {
1331             BOOST_FOREACH(const CTransaction &tx, block.vtx) {
1332                 if (tx.GetHash() == hash) {
1333                     txOut = tx;
1334                     hashBlock = pindexSlow->GetBlockHash();
1335                     return true;
1336                 }
1337             }
1338         }
1339     }
1340
1341     return false;
1342 }
1343
1344 /*char *komodo_getspendscript(uint256 hash,int32_t n)
1345 {
1346     CTransaction tx; uint256 hashBlock;
1347     if ( !GetTransaction(hash,tx,hashBlock,true) )
1348     {
1349         printf("null GetTransaction\n");
1350         return(0);
1351     }
1352     if ( n >= 0 && n < tx.vout.size() )
1353         return((char *)tx.vout[n].scriptPubKey.ToString().c_str());
1354     else printf("getspendscript illegal n.%d\n",n);
1355     return(0);
1356 }*/
1357
1358
1359 //////////////////////////////////////////////////////////////////////////////
1360 //
1361 // CBlock and CBlockIndex
1362 //
1363
1364 bool WriteBlockToDisk(CBlock& block, CDiskBlockPos& pos, const CMessageHeader::MessageStartChars& messageStart)
1365 {
1366     // Open history file to append
1367     CAutoFile fileout(OpenBlockFile(pos), SER_DISK, CLIENT_VERSION);
1368     if (fileout.IsNull())
1369         return error("WriteBlockToDisk: OpenBlockFile failed");
1370
1371     // Write index header
1372     unsigned int nSize = fileout.GetSerializeSize(block);
1373     fileout << FLATDATA(messageStart) << nSize;
1374
1375     // Write block
1376     long fileOutPos = ftell(fileout.Get());
1377     if (fileOutPos < 0)
1378         return error("WriteBlockToDisk: ftell failed");
1379     pos.nPos = (unsigned int)fileOutPos;
1380     fileout << block;
1381
1382     return true;
1383 }
1384
1385 bool ReadBlockFromDisk(int32_t height,CBlock& block, const CDiskBlockPos& pos)
1386 {
1387     uint8_t pubkey33[33];
1388     block.SetNull();
1389
1390     // Open history file to read
1391     CAutoFile filein(OpenBlockFile(pos, true), SER_DISK, CLIENT_VERSION);
1392     if (filein.IsNull())
1393     {
1394         //fprintf(stderr,"readblockfromdisk err A\n");
1395         return false;//error("ReadBlockFromDisk: OpenBlockFile failed for %s", pos.ToString());
1396     }
1397
1398     // Read block
1399     try {
1400         filein >> block;
1401     }
1402     catch (const std::exception& e) {
1403         fprintf(stderr,"readblockfromdisk err B\n");
1404         return error("%s: Deserialize or I/O error - %s at %s", __func__, e.what(), pos.ToString());
1405     }
1406     // Check the header
1407     komodo_block2pubkey33(pubkey33,block);
1408     if (!(CheckEquihashSolution(&block, Params()) && CheckProofOfWork(height,pubkey33,block.GetHash(), block.nBits, Params().GetConsensus())))
1409         return error("ReadBlockFromDisk: Errors in block header at %s", pos.ToString());
1410     return true;
1411 }
1412
1413 bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex)
1414 {
1415     if (!ReadBlockFromDisk(pindex->nHeight,block, pindex->GetBlockPos()))
1416         return false;
1417     if (block.GetHash() != pindex->GetBlockHash())
1418         return error("ReadBlockFromDisk(CBlock&, CBlockIndex*): GetHash() doesn't match index for %s at %s",
1419                 pindex->ToString(), pindex->GetBlockPos().ToString());
1420     return true;
1421 }
1422
1423 uint64_t komodo_moneysupply(int32_t height);
1424
1425 CAmount GetBlockSubsidy(int nHeight, const Consensus::Params& consensusParams)
1426 {
1427     CAmount nSubsidy = 3 * COIN;
1428     if ( nHeight == 1 )
1429         return(100000000 * COIN); // ICO allocation
1430     else if ( komodo_moneysupply(nHeight) < MAX_MONEY )
1431         return(3 * COIN);
1432     else return(0);
1433 /*
1434     // Mining slow start
1435     // The subsidy is ramped up linearly, skipping the middle payout of
1436     // MAX_SUBSIDY/2 to keep the monetary curve consistent with no slow start.
1437     if (nHeight < consensusParams.nSubsidySlowStartInterval / 2) {
1438         nSubsidy /= consensusParams.nSubsidySlowStartInterval;
1439         nSubsidy *= nHeight;
1440         return nSubsidy;
1441     } else if (nHeight < consensusParams.nSubsidySlowStartInterval) {
1442         nSubsidy /= consensusParams.nSubsidySlowStartInterval;
1443         nSubsidy *= (nHeight+1);
1444         return nSubsidy;
1445     }
1446
1447     assert(nHeight > consensusParams.SubsidySlowStartShift());
1448     int halvings = (nHeight - consensusParams.SubsidySlowStartShift()) / consensusParams.nSubsidyHalvingInterval;*/
1449     // Force block reward to zero when right shift is undefined.
1450     //int halvings = nHeight / consensusParams.nSubsidyHalvingInterval;
1451     //if (halvings >= 64)
1452     //    return 0;
1453
1454     // Subsidy is cut in half every 840,000 blocks which will occur approximately every 4 years.
1455     //nSubsidy >>= halvings;
1456     return nSubsidy;
1457 }
1458
1459 bool IsInitialBlockDownload()
1460 {
1461     const CChainParams& chainParams = Params();
1462     LOCK(cs_main);
1463     if (fImporting || fReindex)
1464         return true;
1465     if (fCheckpointsEnabled && chainActive.Height() < Checkpoints::GetTotalBlocksEstimate(chainParams.Checkpoints()))
1466         return true;
1467     static bool lockIBDState = false;
1468     if (lockIBDState)
1469         return false;
1470     bool state = (chainActive.Height() < pindexBestHeader->nHeight - 24 * 6 ||
1471             pindexBestHeader->GetBlockTime() < GetTime() - chainParams.MaxTipAge());
1472     if (!state)
1473         lockIBDState = true;
1474     return state;
1475 }
1476
1477 bool fLargeWorkForkFound = false;
1478 bool fLargeWorkInvalidChainFound = false;
1479 CBlockIndex *pindexBestForkTip = NULL, *pindexBestForkBase = NULL;
1480
1481 void CheckForkWarningConditions()
1482 {
1483     AssertLockHeld(cs_main);
1484     // Before we get past initial download, we cannot reliably alert about forks
1485     // (we assume we don't get stuck on a fork before the last checkpoint)
1486     if (IsInitialBlockDownload())
1487         return;
1488
1489     // If our best fork is no longer within 288 blocks (+/- 12 hours if no one mines it)
1490     // of our head, drop it
1491     if (pindexBestForkTip && chainActive.Height() - pindexBestForkTip->nHeight >= 288)
1492         pindexBestForkTip = NULL;
1493
1494     if (pindexBestForkTip || (pindexBestInvalid && pindexBestInvalid->nChainWork > chainActive.Tip()->nChainWork + (GetBlockProof(*chainActive.Tip()) * 6)))
1495     {
1496         if (!fLargeWorkForkFound && pindexBestForkBase)
1497         {
1498             std::string warning = std::string("'Warning: Large-work fork detected, forking after block ") +
1499                 pindexBestForkBase->phashBlock->ToString() + std::string("'");
1500             CAlert::Notify(warning, true);
1501         }
1502         if (pindexBestForkTip && pindexBestForkBase)
1503         {
1504             LogPrintf("%s: Warning: Large valid fork found\n  forking the chain at height %d (%s)\n  lasting to height %d (%s).\nChain state database corruption likely.\n", __func__,
1505                    pindexBestForkBase->nHeight, pindexBestForkBase->phashBlock->ToString(),
1506                    pindexBestForkTip->nHeight, pindexBestForkTip->phashBlock->ToString());
1507             fLargeWorkForkFound = true;
1508         }
1509         else
1510         {
1511             std::string warning = std::string("Warning: Found invalid chain at least ~6 blocks longer than our best chain.\nChain state database corruption likely.");
1512             LogPrintf("%s: %s\n", warning.c_str(), __func__);
1513             CAlert::Notify(warning, true);
1514             fLargeWorkInvalidChainFound = true;
1515         }
1516     }
1517     else
1518     {
1519         fLargeWorkForkFound = false;
1520         fLargeWorkInvalidChainFound = false;
1521     }
1522 }
1523
1524 void CheckForkWarningConditionsOnNewFork(CBlockIndex* pindexNewForkTip)
1525 {
1526     AssertLockHeld(cs_main);
1527     // If we are on a fork that is sufficiently large, set a warning flag
1528     CBlockIndex* pfork = pindexNewForkTip;
1529     CBlockIndex* plonger = chainActive.Tip();
1530     while (pfork && pfork != plonger)
1531     {
1532         while (plonger && plonger->nHeight > pfork->nHeight)
1533             plonger = plonger->pprev;
1534         if (pfork == plonger)
1535             break;
1536         pfork = pfork->pprev;
1537     }
1538
1539     // We define a condition where we should warn the user about as a fork of at least 7 blocks
1540     // with a tip within 72 blocks (+/- 12 hours if no one mines it) of ours
1541     // We use 7 blocks rather arbitrarily as it represents just under 10% of sustained network
1542     // hash rate operating on the fork.
1543     // or a chain that is entirely longer than ours and invalid (note that this should be detected by both)
1544     // We define it this way because it allows us to only store the highest fork tip (+ base) which meets
1545     // the 7-block condition and from this always have the most-likely-to-cause-warning fork
1546     if (pfork && (!pindexBestForkTip || (pindexBestForkTip && pindexNewForkTip->nHeight > pindexBestForkTip->nHeight)) &&
1547             pindexNewForkTip->nChainWork - pfork->nChainWork > (GetBlockProof(*pfork) * 7) &&
1548             chainActive.Height() - pindexNewForkTip->nHeight < 72)
1549     {
1550         pindexBestForkTip = pindexNewForkTip;
1551         pindexBestForkBase = pfork;
1552     }
1553
1554     CheckForkWarningConditions();
1555 }
1556
1557 // Requires cs_main.
1558 void Misbehaving(NodeId pnode, int howmuch)
1559 {
1560     if (howmuch == 0)
1561         return;
1562
1563     CNodeState *state = State(pnode);
1564     if (state == NULL)
1565         return;
1566
1567     state->nMisbehavior += howmuch;
1568     int banscore = GetArg("-banscore", 100);
1569     if (state->nMisbehavior >= banscore && state->nMisbehavior - howmuch < banscore)
1570     {
1571         LogPrintf("%s: %s (%d -> %d) BAN THRESHOLD EXCEEDED\n", __func__, state->name, state->nMisbehavior-howmuch, state->nMisbehavior);
1572         state->fShouldBan = true;
1573     } else
1574         LogPrintf("%s: %s (%d -> %d)\n", __func__, state->name, state->nMisbehavior-howmuch, state->nMisbehavior);
1575 }
1576
1577 void static InvalidChainFound(CBlockIndex* pindexNew)
1578 {
1579     if (!pindexBestInvalid || pindexNew->nChainWork > pindexBestInvalid->nChainWork)
1580         pindexBestInvalid = pindexNew;
1581
1582     LogPrintf("%s: invalid block=%s  height=%d  log2_work=%.8g  date=%s\n", __func__,
1583       pindexNew->GetBlockHash().ToString(), pindexNew->nHeight,
1584       log(pindexNew->nChainWork.getdouble())/log(2.0), DateTimeStrFormat("%Y-%m-%d %H:%M:%S",
1585       pindexNew->GetBlockTime()));
1586     CBlockIndex *tip = chainActive.Tip();
1587     assert (tip);
1588     LogPrintf("%s:  current best=%s  height=%d  log2_work=%.8g  date=%s\n", __func__,
1589       tip->GetBlockHash().ToString(), chainActive.Height(), log(tip->nChainWork.getdouble())/log(2.0),
1590       DateTimeStrFormat("%Y-%m-%d %H:%M:%S", tip->GetBlockTime()));
1591     CheckForkWarningConditions();
1592 }
1593
1594 void static InvalidBlockFound(CBlockIndex *pindex, const CValidationState &state) {
1595     int nDoS = 0;
1596     if (state.IsInvalid(nDoS)) {
1597         std::map<uint256, NodeId>::iterator it = mapBlockSource.find(pindex->GetBlockHash());
1598         if (it != mapBlockSource.end() && State(it->second)) {
1599             CBlockReject reject = {state.GetRejectCode(), state.GetRejectReason().substr(0, MAX_REJECT_MESSAGE_LENGTH), pindex->GetBlockHash()};
1600             State(it->second)->rejects.push_back(reject);
1601             if (nDoS > 0)
1602                 Misbehaving(it->second, nDoS);
1603         }
1604     }
1605     if (!state.CorruptionPossible()) {
1606         pindex->nStatus |= BLOCK_FAILED_VALID;
1607         setDirtyBlockIndex.insert(pindex);
1608         setBlockIndexCandidates.erase(pindex);
1609         InvalidChainFound(pindex);
1610     }
1611 }
1612
1613 void UpdateCoins(const CTransaction& tx, CValidationState &state, CCoinsViewCache &inputs, CTxUndo &txundo, int nHeight)
1614 {
1615     // mark inputs spent
1616     if (!tx.IsCoinBase()) {
1617         txundo.vprevout.reserve(tx.vin.size());
1618         BOOST_FOREACH(const CTxIn &txin, tx.vin) {
1619             CCoinsModifier coins = inputs.ModifyCoins(txin.prevout.hash);
1620             unsigned nPos = txin.prevout.n;
1621
1622             if (nPos >= coins->vout.size() || coins->vout[nPos].IsNull())
1623                 assert(false);
1624             // mark an outpoint spent, and construct undo information
1625             txundo.vprevout.push_back(CTxInUndo(coins->vout[nPos]));
1626             coins->Spend(nPos);
1627             if (coins->vout.size() == 0) {
1628                 CTxInUndo& undo = txundo.vprevout.back();
1629                 undo.nHeight = coins->nHeight;
1630                 undo.fCoinBase = coins->fCoinBase;
1631                 undo.nVersion = coins->nVersion;
1632             }
1633         }
1634     }
1635
1636     // spend nullifiers
1637     BOOST_FOREACH(const JSDescription &joinsplit, tx.vjoinsplit) {
1638         BOOST_FOREACH(const uint256 &nf, joinsplit.nullifiers) {
1639             inputs.SetNullifier(nf, true);
1640         }
1641     }
1642
1643     // add outputs
1644     inputs.ModifyCoins(tx.GetHash())->FromTx(tx, nHeight);
1645 }
1646
1647 void UpdateCoins(const CTransaction& tx, CValidationState &state, CCoinsViewCache &inputs, int nHeight)
1648 {
1649     CTxUndo txundo;
1650     UpdateCoins(tx, state, inputs, txundo, nHeight);
1651 }
1652
1653 bool CScriptCheck::operator()() {
1654     const CScript &scriptSig = ptxTo->vin[nIn].scriptSig;
1655     if (!VerifyScript(scriptSig, scriptPubKey, nFlags, CachingTransactionSignatureChecker(ptxTo, nIn, cacheStore), &error)) {
1656         return ::error("CScriptCheck(): %s:%d VerifySignature failed: %s", ptxTo->GetHash().ToString(), nIn, ScriptErrorString(error));
1657     }
1658     return true;
1659 }
1660
1661 bool NonContextualCheckInputs(const CTransaction& tx, CValidationState &state, const CCoinsViewCache &inputs, bool fScriptChecks, unsigned int flags, bool cacheStore, const Consensus::Params& consensusParams, std::vector<CScriptCheck> *pvChecks)
1662 {
1663     if (!tx.IsCoinBase())
1664     {
1665         if (pvChecks)
1666             pvChecks->reserve(tx.vin.size());
1667
1668         // This doesn't trigger the DoS code on purpose; if it did, it would make it easier
1669         // for an attacker to attempt to split the network.
1670         if (!inputs.HaveInputs(tx))
1671             return state.Invalid(error("CheckInputs(): %s inputs unavailable", tx.GetHash().ToString()));
1672
1673         // are the JoinSplit's requirements met?
1674         if (!inputs.HaveJoinSplitRequirements(tx))
1675             return state.Invalid(error("CheckInputs(): %s JoinSplit requirements not met", tx.GetHash().ToString()));
1676
1677         CAmount nValueIn = 0;
1678         CAmount nFees = 0;
1679         for (unsigned int i = 0; i < tx.vin.size(); i++)
1680         {
1681             const COutPoint &prevout = tx.vin[i].prevout;
1682             const CCoins *coins = inputs.AccessCoins(prevout.hash);
1683             assert(coins);
1684
1685             if (coins->IsCoinBase()) {
1686                 // Ensure that coinbases cannot be spent to transparent outputs
1687                 // Disabled on regtest
1688                 if (fCoinbaseEnforcedProtectionEnabled &&
1689                     consensusParams.fCoinbaseMustBeProtected &&
1690                     !tx.vout.empty()) {
1691                     return state.Invalid(
1692                         error("CheckInputs(): tried to spend coinbase with transparent outputs"),
1693                         REJECT_INVALID, "bad-txns-coinbase-spend-has-transparent-outputs");
1694                 }
1695             }
1696
1697             // Check for negative or overflow input values
1698             nValueIn += coins->vout[prevout.n].nValue;
1699             if (!MoneyRange(coins->vout[prevout.n].nValue) || !MoneyRange(nValueIn))
1700                 return state.DoS(100, error("CheckInputs(): txin values out of range"),
1701                                  REJECT_INVALID, "bad-txns-inputvalues-outofrange");
1702
1703         }
1704
1705         nValueIn += tx.GetJoinSplitValueIn();
1706         if (!MoneyRange(nValueIn))
1707             return state.DoS(100, error("CheckInputs(): vpub_old values out of range"),
1708                              REJECT_INVALID, "bad-txns-inputvalues-outofrange");
1709
1710         if (nValueIn < tx.GetValueOut())
1711             return state.DoS(100, error("CheckInputs(): %s value in (%s) < value out (%s)",
1712                                         tx.GetHash().ToString(), FormatMoney(nValueIn), FormatMoney(tx.GetValueOut())),
1713                              REJECT_INVALID, "bad-txns-in-belowout");
1714
1715         // Tally transaction fees
1716         CAmount nTxFee = nValueIn - tx.GetValueOut();
1717         if (nTxFee < 0)
1718             return state.DoS(100, error("CheckInputs(): %s nTxFee < 0", tx.GetHash().ToString()),
1719                              REJECT_INVALID, "bad-txns-fee-negative");
1720         nFees += nTxFee;
1721         if (!MoneyRange(nFees))
1722             return state.DoS(100, error("CheckInputs(): nFees out of range"),
1723                              REJECT_INVALID, "bad-txns-fee-outofrange");
1724
1725         // The first loop above does all the inexpensive checks.
1726         // Only if ALL inputs pass do we perform expensive ECDSA signature checks.
1727         // Helps prevent CPU exhaustion attacks.
1728
1729         // Skip ECDSA signature verification when connecting blocks
1730         // before the last block chain checkpoint. This is safe because block merkle hashes are
1731         // still computed and checked, and any change will be caught at the next checkpoint.
1732         if (fScriptChecks) {
1733             for (unsigned int i = 0; i < tx.vin.size(); i++) {
1734                 const COutPoint &prevout = tx.vin[i].prevout;
1735                 const CCoins* coins = inputs.AccessCoins(prevout.hash);
1736                 assert(coins);
1737
1738                 // Verify signature
1739                 CScriptCheck check(*coins, tx, i, flags, cacheStore);
1740                 if (pvChecks) {
1741                     pvChecks->push_back(CScriptCheck());
1742                     check.swap(pvChecks->back());
1743                 } else if (!check()) {
1744                     if (flags & STANDARD_NOT_MANDATORY_VERIFY_FLAGS) {
1745                         // Check whether the failure was caused by a
1746                         // non-mandatory script verification check, such as
1747                         // non-standard DER encodings or non-null dummy
1748                         // arguments; if so, don't trigger DoS protection to
1749                         // avoid splitting the network between upgraded and
1750                         // non-upgraded nodes.
1751                         CScriptCheck check(*coins, tx, i,
1752                                 flags & ~STANDARD_NOT_MANDATORY_VERIFY_FLAGS, cacheStore);
1753                         if (check())
1754                             return state.Invalid(false, REJECT_NONSTANDARD, strprintf("non-mandatory-script-verify-flag (%s)", ScriptErrorString(check.GetScriptError())));
1755                     }
1756                     // Failures of other flags indicate a transaction that is
1757                     // invalid in new blocks, e.g. a invalid P2SH. We DoS ban
1758                     // such nodes as they are not following the protocol. That
1759                     // said during an upgrade careful thought should be taken
1760                     // as to the correct behavior - we may want to continue
1761                     // peering with non-upgraded nodes even after a soft-fork
1762                     // super-majority vote has passed.
1763                     return state.DoS(100,false, REJECT_INVALID, strprintf("mandatory-script-verify-flag-failed (%s)", ScriptErrorString(check.GetScriptError())));
1764                 }
1765             }
1766         }
1767     }
1768
1769     return true;
1770 }
1771
1772 bool ContextualCheckInputs(const CTransaction& tx, CValidationState &state, const CCoinsViewCache &inputs, bool fScriptChecks, unsigned int flags, bool cacheStore, const Consensus::Params& consensusParams, std::vector<CScriptCheck> *pvChecks)
1773 {
1774     if (!NonContextualCheckInputs(tx, state, inputs, fScriptChecks, flags, cacheStore, consensusParams, pvChecks)) {
1775         return false;
1776     }
1777
1778     if (!tx.IsCoinBase())
1779     {
1780         // While checking, GetBestBlock() refers to the parent block.
1781         // This is also true for mempool checks.
1782         CBlockIndex *pindexPrev = mapBlockIndex.find(inputs.GetBestBlock())->second;
1783         int nSpendHeight = pindexPrev->nHeight + 1;
1784         for (unsigned int i = 0; i < tx.vin.size(); i++)
1785         {
1786             const COutPoint &prevout = tx.vin[i].prevout;
1787             const CCoins *coins = inputs.AccessCoins(prevout.hash);
1788             // Assertion is okay because NonContextualCheckInputs ensures the inputs
1789             // are available.
1790             assert(coins);
1791
1792             // If prev is coinbase, check that it's matured
1793             if (coins->IsCoinBase()) {
1794                 if (nSpendHeight - coins->nHeight < COINBASE_MATURITY) {
1795                     return state.Invalid(
1796                         error("CheckInputs(): tried to spend coinbase at depth %d", nSpendHeight - coins->nHeight),
1797                         REJECT_INVALID, "bad-txns-premature-spend-of-coinbase");
1798                 }
1799             }
1800         }
1801     }
1802
1803     return true;
1804 }
1805
1806 namespace {
1807
1808 bool UndoWriteToDisk(const CBlockUndo& blockundo, CDiskBlockPos& pos, const uint256& hashBlock, const CMessageHeader::MessageStartChars& messageStart)
1809 {
1810     // Open history file to append
1811     CAutoFile fileout(OpenUndoFile(pos), SER_DISK, CLIENT_VERSION);
1812     if (fileout.IsNull())
1813         return error("%s: OpenUndoFile failed", __func__);
1814
1815     // Write index header
1816     unsigned int nSize = fileout.GetSerializeSize(blockundo);
1817     fileout << FLATDATA(messageStart) << nSize;
1818
1819     // Write undo data
1820     long fileOutPos = ftell(fileout.Get());
1821     if (fileOutPos < 0)
1822         return error("%s: ftell failed", __func__);
1823     pos.nPos = (unsigned int)fileOutPos;
1824     fileout << blockundo;
1825
1826     // calculate & write checksum
1827     CHashWriter hasher(SER_GETHASH, PROTOCOL_VERSION);
1828     hasher << hashBlock;
1829     hasher << blockundo;
1830     fileout << hasher.GetHash();
1831
1832     return true;
1833 }
1834
1835 bool UndoReadFromDisk(CBlockUndo& blockundo, const CDiskBlockPos& pos, const uint256& hashBlock)
1836 {
1837     // Open history file to read
1838     CAutoFile filein(OpenUndoFile(pos, true), SER_DISK, CLIENT_VERSION);
1839     if (filein.IsNull())
1840         return error("%s: OpenBlockFile failed", __func__);
1841
1842     // Read block
1843     uint256 hashChecksum;
1844     try {
1845         filein >> blockundo;
1846         filein >> hashChecksum;
1847     }
1848     catch (const std::exception& e) {
1849         return error("%s: Deserialize or I/O error - %s", __func__, e.what());
1850     }
1851
1852     // Verify checksum
1853     CHashWriter hasher(SER_GETHASH, PROTOCOL_VERSION);
1854     hasher << hashBlock;
1855     hasher << blockundo;
1856     if (hashChecksum != hasher.GetHash())
1857         return error("%s: Checksum mismatch", __func__);
1858
1859     return true;
1860 }
1861
1862 /** Abort with a message */
1863 bool AbortNode(const std::string& strMessage, const std::string& userMessage="")
1864 {
1865     strMiscWarning = strMessage;
1866     LogPrintf("*** %s\n", strMessage);
1867     uiInterface.ThreadSafeMessageBox(
1868         userMessage.empty() ? _("Error: A fatal internal error occurred, see debug.log for details") : userMessage,
1869         "", CClientUIInterface::MSG_ERROR);
1870     StartShutdown();
1871     return false;
1872 }
1873
1874 bool AbortNode(CValidationState& state, const std::string& strMessage, const std::string& userMessage="")
1875 {
1876     AbortNode(strMessage, userMessage);
1877     return state.Error(strMessage);
1878 }
1879
1880 } // anon namespace
1881
1882 /**
1883  * Apply the undo operation of a CTxInUndo to the given chain state.
1884  * @param undo The undo object.
1885  * @param view The coins view to which to apply the changes.
1886  * @param out The out point that corresponds to the tx input.
1887  * @return True on success.
1888  */
1889 static bool ApplyTxInUndo(const CTxInUndo& undo, CCoinsViewCache& view, const COutPoint& out)
1890 {
1891     bool fClean = true;
1892
1893     CCoinsModifier coins = view.ModifyCoins(out.hash);
1894     if (undo.nHeight != 0) {
1895         // undo data contains height: this is the last output of the prevout tx being spent
1896         if (!coins->IsPruned())
1897             fClean = fClean && error("%s: undo data overwriting existing transaction", __func__);
1898         coins->Clear();
1899         coins->fCoinBase = undo.fCoinBase;
1900         coins->nHeight = undo.nHeight;
1901         coins->nVersion = undo.nVersion;
1902     } else {
1903         if (coins->IsPruned())
1904             fClean = fClean && error("%s: undo data adding output to missing transaction", __func__);
1905     }
1906     if (coins->IsAvailable(out.n))
1907         fClean = fClean && error("%s: undo data overwriting existing output", __func__);
1908     if (coins->vout.size() < out.n+1)
1909         coins->vout.resize(out.n+1);
1910     coins->vout[out.n] = undo.txout;
1911
1912     return fClean;
1913 }
1914
1915 bool DisconnectBlock(CBlock& block, CValidationState& state, CBlockIndex* pindex, CCoinsViewCache& view, bool* pfClean)
1916 {
1917     assert(pindex->GetBlockHash() == view.GetBestBlock());
1918
1919     if (pfClean)
1920         *pfClean = false;
1921
1922     bool fClean = true;
1923     komodo_disconnect(pindex,block);
1924     CBlockUndo blockUndo;
1925     CDiskBlockPos pos = pindex->GetUndoPos();
1926     if (pos.IsNull())
1927         return error("DisconnectBlock(): no undo data available");
1928     if (!UndoReadFromDisk(blockUndo, pos, pindex->pprev->GetBlockHash()))
1929         return error("DisconnectBlock(): failure reading undo data");
1930
1931     if (blockUndo.vtxundo.size() + 1 != block.vtx.size())
1932         return error("DisconnectBlock(): block and undo data inconsistent");
1933
1934     // undo transactions in reverse order
1935     for (int i = block.vtx.size() - 1; i >= 0; i--) {
1936         const CTransaction &tx = block.vtx[i];
1937         uint256 hash = tx.GetHash();
1938
1939         // Check that all outputs are available and match the outputs in the block itself
1940         // exactly.
1941         {
1942         CCoinsModifier outs = view.ModifyCoins(hash);
1943         outs->ClearUnspendable();
1944
1945         CCoins outsBlock(tx, pindex->nHeight);
1946         // The CCoins serialization does not serialize negative numbers.
1947         // No network rules currently depend on the version here, so an inconsistency is harmless
1948         // but it must be corrected before txout nversion ever influences a network rule.
1949         if (outsBlock.nVersion < 0)
1950             outs->nVersion = outsBlock.nVersion;
1951         if (*outs != outsBlock)
1952             fClean = fClean && error("DisconnectBlock(): added transaction mismatch? database corrupted");
1953
1954         // remove outputs
1955         outs->Clear();
1956         }
1957
1958         // unspend nullifiers
1959         BOOST_FOREACH(const JSDescription &joinsplit, tx.vjoinsplit) {
1960             BOOST_FOREACH(const uint256 &nf, joinsplit.nullifiers) {
1961                 view.SetNullifier(nf, false);
1962             }
1963         }
1964
1965         // restore inputs
1966         if (i > 0) { // not coinbases
1967             const CTxUndo &txundo = blockUndo.vtxundo[i-1];
1968             if (txundo.vprevout.size() != tx.vin.size())
1969                 return error("DisconnectBlock(): transaction and undo data inconsistent");
1970             for (unsigned int j = tx.vin.size(); j-- > 0;) {
1971                 const COutPoint &out = tx.vin[j].prevout;
1972                 const CTxInUndo &undo = txundo.vprevout[j];
1973                 if (!ApplyTxInUndo(undo, view, out))
1974                     fClean = false;
1975             }
1976         }
1977     }
1978
1979     // set the old best anchor back
1980     view.PopAnchor(blockUndo.old_tree_root);
1981
1982     // move best block pointer to prevout block
1983     view.SetBestBlock(pindex->pprev->GetBlockHash());
1984
1985     if (pfClean) {
1986         *pfClean = fClean;
1987         return true;
1988     }
1989
1990     return fClean;
1991 }
1992
1993 void static FlushBlockFile(bool fFinalize = false)
1994 {
1995     LOCK(cs_LastBlockFile);
1996
1997     CDiskBlockPos posOld(nLastBlockFile, 0);
1998
1999     FILE *fileOld = OpenBlockFile(posOld);
2000     if (fileOld) {
2001         if (fFinalize)
2002             TruncateFile(fileOld, vinfoBlockFile[nLastBlockFile].nSize);
2003         FileCommit(fileOld);
2004         fclose(fileOld);
2005     }
2006
2007     fileOld = OpenUndoFile(posOld);
2008     if (fileOld) {
2009         if (fFinalize)
2010             TruncateFile(fileOld, vinfoBlockFile[nLastBlockFile].nUndoSize);
2011         FileCommit(fileOld);
2012         fclose(fileOld);
2013     }
2014 }
2015
2016 bool FindUndoPos(CValidationState &state, int nFile, CDiskBlockPos &pos, unsigned int nAddSize);
2017
2018 static CCheckQueue<CScriptCheck> scriptcheckqueue(128);
2019
2020 void ThreadScriptCheck() {
2021     RenameThread("zcash-scriptch");
2022     scriptcheckqueue.Thread();
2023 }
2024
2025 //
2026 // Called periodically asynchronously; alerts if it smells like
2027 // we're being fed a bad chain (blocks being generated much
2028 // too slowly or too quickly).
2029 //
2030 void PartitionCheck(bool (*initialDownloadCheck)(), CCriticalSection& cs, const CBlockIndex *const &bestHeader,
2031                     int64_t nPowTargetSpacing)
2032 {
2033     if (bestHeader == NULL || initialDownloadCheck()) return;
2034
2035     static int64_t lastAlertTime = 0;
2036     int64_t now = GetAdjustedTime();
2037     if (lastAlertTime > now-60*60*24) return; // Alert at most once per day
2038
2039     const int SPAN_HOURS=4;
2040     const int SPAN_SECONDS=SPAN_HOURS*60*60;
2041     int BLOCKS_EXPECTED = SPAN_SECONDS / nPowTargetSpacing;
2042
2043     boost::math::poisson_distribution<double> poisson(BLOCKS_EXPECTED);
2044
2045     std::string strWarning;
2046     int64_t startTime = GetAdjustedTime()-SPAN_SECONDS;
2047
2048     LOCK(cs);
2049     const CBlockIndex* i = bestHeader;
2050     int nBlocks = 0;
2051     while (i->GetBlockTime() >= startTime) {
2052         ++nBlocks;
2053         i = i->pprev;
2054         if (i == NULL) return; // Ran out of chain, we must not be fully sync'ed
2055     }
2056
2057     // How likely is it to find that many by chance?
2058     double p = boost::math::pdf(poisson, nBlocks);
2059
2060     LogPrint("partitioncheck", "%s : Found %d blocks in the last %d hours\n", __func__, nBlocks, SPAN_HOURS);
2061     LogPrint("partitioncheck", "%s : likelihood: %g\n", __func__, p);
2062
2063     // Aim for one false-positive about every fifty years of normal running:
2064     const int FIFTY_YEARS = 50*365*24*60*60;
2065     double alertThreshold = 1.0 / (FIFTY_YEARS / SPAN_SECONDS);
2066
2067     if (p <= alertThreshold && nBlocks < BLOCKS_EXPECTED)
2068     {
2069         // Many fewer blocks than expected: alert!
2070         strWarning = strprintf(_("WARNING: check your network connection, %d blocks received in the last %d hours (%d expected)"),
2071                                nBlocks, SPAN_HOURS, BLOCKS_EXPECTED);
2072     }
2073     else if (p <= alertThreshold && nBlocks > BLOCKS_EXPECTED)
2074     {
2075         // Many more blocks than expected: alert!
2076         strWarning = strprintf(_("WARNING: abnormally high number of blocks generated, %d blocks received in the last %d hours (%d expected)"),
2077                                nBlocks, SPAN_HOURS, BLOCKS_EXPECTED);
2078     }
2079     if (!strWarning.empty())
2080     {
2081         strMiscWarning = strWarning;
2082         CAlert::Notify(strWarning, true);
2083         lastAlertTime = now;
2084     }
2085 }
2086
2087 static int64_t nTimeVerify = 0;
2088 static int64_t nTimeConnect = 0;
2089 static int64_t nTimeIndex = 0;
2090 static int64_t nTimeCallbacks = 0;
2091 static int64_t nTimeTotal = 0;
2092
2093 bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pindex, CCoinsViewCache& view, bool fJustCheck)
2094 {
2095     const CChainParams& chainparams = Params();
2096     AssertLockHeld(cs_main);
2097     // Check it again in case a previous version let a bad block in
2098     if (!CheckBlock(pindex->nHeight,pindex,block, state, !fJustCheck, !fJustCheck))
2099         return false;
2100
2101     // verify that the view's current state corresponds to the previous block
2102     uint256 hashPrevBlock = pindex->pprev == NULL ? uint256() : pindex->pprev->GetBlockHash();
2103     assert(hashPrevBlock == view.GetBestBlock());
2104
2105     // Special case for the genesis block, skipping connection of its transactions
2106     // (its coinbase is unspendable)
2107     if (block.GetHash() == chainparams.GetConsensus().hashGenesisBlock) {
2108         if (!fJustCheck) {
2109             view.SetBestBlock(pindex->GetBlockHash());
2110             // Before the genesis block, there was an empty tree
2111             ZCIncrementalMerkleTree tree;
2112             pindex->hashAnchor = tree.root();
2113         }
2114         return true;
2115     }
2116
2117     bool fScriptChecks = (!fCheckpointsEnabled || pindex->nHeight >= Checkpoints::GetTotalBlocksEstimate(chainparams.Checkpoints()));
2118     if ( KOMODO_TESTNET_EXPIRATION != 0 && pindex->nHeight > KOMODO_TESTNET_EXPIRATION ) // "testnet"
2119         return(false);
2120     // Do not allow blocks that contain transactions which 'overwrite' older transactions,
2121     // unless those are already completely spent.
2122     BOOST_FOREACH(const CTransaction& tx, block.vtx) {
2123         const CCoins* coins = view.AccessCoins(tx.GetHash());
2124         if (coins && !coins->IsPruned())
2125             return state.DoS(100, error("ConnectBlock(): tried to overwrite transaction"),
2126                              REJECT_INVALID, "bad-txns-BIP30");
2127     }
2128
2129     unsigned int flags = SCRIPT_VERIFY_P2SH;
2130
2131     // Start enforcing the DERSIG (BIP66) rules, for block.nVersion=3 blocks,
2132     // when 75% of the network has upgraded:
2133     if (block.nVersion >= 3) {
2134         flags |= SCRIPT_VERIFY_DERSIG;
2135     }
2136
2137     // Start enforcing CHECKLOCKTIMEVERIFY, (BIP65) for block.nVersion=4
2138     // blocks, when 75% of the network has upgraded:
2139     if (block.nVersion >= 4) {
2140         flags |= SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY;
2141     }
2142
2143     CBlockUndo blockundo;
2144
2145     CCheckQueueControl<CScriptCheck> control(fScriptChecks && nScriptCheckThreads ? &scriptcheckqueue : NULL);
2146
2147     int64_t nTimeStart = GetTimeMicros();
2148     CAmount nFees = 0;
2149     int nInputs = 0;
2150     int64_t interest,sum = 0;
2151     unsigned int nSigOps = 0;
2152     CDiskTxPos pos(pindex->GetBlockPos(), GetSizeOfCompactSize(block.vtx.size()));
2153     std::vector<std::pair<uint256, CDiskTxPos> > vPos;
2154     vPos.reserve(block.vtx.size());
2155     blockundo.vtxundo.reserve(block.vtx.size() - 1);
2156
2157     // Construct the incremental merkle tree at the current
2158     // block position,
2159     auto old_tree_root = view.GetBestAnchor();
2160     // saving the top anchor in the block index as we go.
2161     if (!fJustCheck) {
2162         pindex->hashAnchor = old_tree_root;
2163     }
2164     ZCIncrementalMerkleTree tree;
2165     // This should never fail: we should always be able to get the root
2166     // that is on the tip of our chain
2167     assert(view.GetAnchorAt(old_tree_root, tree));
2168
2169     {
2170         // Consistency check: the root of the tree we're given should
2171         // match what we asked for.
2172         assert(tree.root() == old_tree_root);
2173     }
2174
2175     for (unsigned int i = 0; i < block.vtx.size(); i++)
2176     {
2177         const CTransaction &tx = block.vtx[i];
2178
2179         nInputs += tx.vin.size();
2180         nSigOps += GetLegacySigOpCount(tx);
2181         if (nSigOps > MAX_BLOCK_SIGOPS)
2182             return state.DoS(100, error("ConnectBlock(): too many sigops"),
2183                              REJECT_INVALID, "bad-blk-sigops");
2184 //fprintf(stderr,"ht.%d vout0 t%u\n",pindex->nHeight,tx.nLockTime);
2185         if (!tx.IsCoinBase())
2186         {
2187             if (!view.HaveInputs(tx))
2188                 return state.DoS(100, error("ConnectBlock(): inputs missing/spent"),
2189                                  REJECT_INVALID, "bad-txns-inputs-missingorspent");
2190
2191             // are the JoinSplit's requirements met?
2192             if (!view.HaveJoinSplitRequirements(tx))
2193                 return state.DoS(100, error("ConnectBlock(): JoinSplit requirements not met"),
2194                                  REJECT_INVALID, "bad-txns-joinsplit-requirements-not-met");
2195
2196             // Add in sigops done by pay-to-script-hash inputs;
2197             // this is to prevent a "rogue miner" from creating
2198             // an incredibly-expensive-to-validate block.
2199             nSigOps += GetP2SHSigOpCount(tx, view);
2200             if (nSigOps > MAX_BLOCK_SIGOPS)
2201                 return state.DoS(100, error("ConnectBlock(): too many sigops"),
2202                                  REJECT_INVALID, "bad-blk-sigops");
2203
2204             nFees += view.GetValueIn(chainActive.Tip()->nHeight,&interest,tx,chainActive.Tip()->nTime) - tx.GetValueOut();
2205             sum += interest;
2206             std::vector<CScriptCheck> vChecks;
2207             if (!ContextualCheckInputs(tx, state, view, fScriptChecks, flags, false, chainparams.GetConsensus(), nScriptCheckThreads ? &vChecks : NULL))
2208                 return false;
2209             control.Add(vChecks);
2210         }
2211         komodo_accrued_interest(pindex->nHeight,sum);
2212         CTxUndo undoDummy;
2213         if (i > 0) {
2214             blockundo.vtxundo.push_back(CTxUndo());
2215         }
2216         UpdateCoins(tx, state, view, i == 0 ? undoDummy : blockundo.vtxundo.back(), pindex->nHeight);
2217
2218         BOOST_FOREACH(const JSDescription &joinsplit, tx.vjoinsplit) {
2219             BOOST_FOREACH(const uint256 &note_commitment, joinsplit.commitments) {
2220                 // Insert the note commitments into our temporary tree.
2221
2222                 tree.append(note_commitment);
2223             }
2224         }
2225
2226         vPos.push_back(std::make_pair(tx.GetHash(), pos));
2227         pos.nTxOffset += ::GetSerializeSize(tx, SER_DISK, CLIENT_VERSION);
2228     }
2229
2230     view.PushAnchor(tree);
2231     blockundo.old_tree_root = old_tree_root;
2232
2233     int64_t nTime1 = GetTimeMicros(); nTimeConnect += nTime1 - nTimeStart;
2234     LogPrint("bench", "      - Connect %u transactions: %.2fms (%.3fms/tx, %.3fms/txin) [%.2fs]\n", (unsigned)block.vtx.size(), 0.001 * (nTime1 - nTimeStart), 0.001 * (nTime1 - nTimeStart) / block.vtx.size(), nInputs <= 1 ? 0 : 0.001 * (nTime1 - nTimeStart) / (nInputs-1), nTimeConnect * 0.000001);
2235
2236     CAmount blockReward = nFees + GetBlockSubsidy(pindex->nHeight, chainparams.GetConsensus());
2237     if (block.vtx[0].GetValueOut() > blockReward)
2238         return state.DoS(100,
2239                          error("ConnectBlock(): coinbase pays too much (actual=%d vs limit=%d)",
2240                                block.vtx[0].GetValueOut(), blockReward),
2241                                REJECT_INVALID, "bad-cb-amount");
2242
2243     if (!control.Wait())
2244         return state.DoS(100, false);
2245     int64_t nTime2 = GetTimeMicros(); nTimeVerify += nTime2 - nTimeStart;
2246     LogPrint("bench", "    - Verify %u txins: %.2fms (%.3fms/txin) [%.2fs]\n", nInputs - 1, 0.001 * (nTime2 - nTimeStart), nInputs <= 1 ? 0 : 0.001 * (nTime2 - nTimeStart) / (nInputs-1), nTimeVerify * 0.000001);
2247
2248     if (fJustCheck)
2249         return true;
2250
2251     // Write undo information to disk
2252     if (pindex->GetUndoPos().IsNull() || !pindex->IsValid(BLOCK_VALID_SCRIPTS))
2253     {
2254         if (pindex->GetUndoPos().IsNull()) {
2255             CDiskBlockPos pos;
2256             if (!FindUndoPos(state, pindex->nFile, pos, ::GetSerializeSize(blockundo, SER_DISK, CLIENT_VERSION) + 40))
2257                 return error("ConnectBlock(): FindUndoPos failed");
2258             if (!UndoWriteToDisk(blockundo, pos, pindex->pprev->GetBlockHash(), chainparams.MessageStart()))
2259                 return AbortNode(state, "Failed to write undo data");
2260
2261             // update nUndoPos in block index
2262             pindex->nUndoPos = pos.nPos;
2263             pindex->nStatus |= BLOCK_HAVE_UNDO;
2264         }
2265
2266         pindex->RaiseValidity(BLOCK_VALID_SCRIPTS);
2267         setDirtyBlockIndex.insert(pindex);
2268     }
2269
2270     if (fTxIndex)
2271         if (!pblocktree->WriteTxIndex(vPos))
2272             return AbortNode(state, "Failed to write transaction index");
2273
2274     // add this block to the view's block chain
2275     view.SetBestBlock(pindex->GetBlockHash());
2276
2277     int64_t nTime3 = GetTimeMicros(); nTimeIndex += nTime3 - nTime2;
2278     LogPrint("bench", "    - Index writing: %.2fms [%.2fs]\n", 0.001 * (nTime3 - nTime2), nTimeIndex * 0.000001);
2279
2280     // Watch for changes to the previous coinbase transaction.
2281     static uint256 hashPrevBestCoinBase;
2282     GetMainSignals().UpdatedTransaction(hashPrevBestCoinBase);
2283     hashPrevBestCoinBase = block.vtx[0].GetHash();
2284
2285     int64_t nTime4 = GetTimeMicros(); nTimeCallbacks += nTime4 - nTime3;
2286     LogPrint("bench", "    - Callbacks: %.2fms [%.2fs]\n", 0.001 * (nTime4 - nTime3), nTimeCallbacks * 0.000001);
2287
2288     //FlushStateToDisk();
2289     komodo_connectblock(pindex,*(CBlock *)&block);
2290
2291     return true;
2292 }
2293
2294 enum FlushStateMode {
2295     FLUSH_STATE_NONE,
2296     FLUSH_STATE_IF_NEEDED,
2297     FLUSH_STATE_PERIODIC,
2298     FLUSH_STATE_ALWAYS
2299 };
2300
2301 /**
2302  * Update the on-disk chain state.
2303  * The caches and indexes are flushed depending on the mode we're called with
2304  * if they're too large, if it's been a while since the last write,
2305  * or always and in all cases if we're in prune mode and are deleting files.
2306  */
2307 bool static FlushStateToDisk(CValidationState &state, FlushStateMode mode) {
2308     LOCK2(cs_main, cs_LastBlockFile);
2309     static int64_t nLastWrite = 0;
2310     static int64_t nLastFlush = 0;
2311     static int64_t nLastSetChain = 0;
2312     std::set<int> setFilesToPrune;
2313     bool fFlushForPrune = false;
2314     try {
2315     if (fPruneMode && fCheckForPruning && !fReindex) {
2316         FindFilesToPrune(setFilesToPrune);
2317         fCheckForPruning = false;
2318         if (!setFilesToPrune.empty()) {
2319             fFlushForPrune = true;
2320             if (!fHavePruned) {
2321                 pblocktree->WriteFlag("prunedblockfiles", true);
2322                 fHavePruned = true;
2323             }
2324         }
2325     }
2326     int64_t nNow = GetTimeMicros();
2327     // Avoid writing/flushing immediately after startup.
2328     if (nLastWrite == 0) {
2329         nLastWrite = nNow;
2330     }
2331     if (nLastFlush == 0) {
2332         nLastFlush = nNow;
2333     }
2334     if (nLastSetChain == 0) {
2335         nLastSetChain = nNow;
2336     }
2337     size_t cacheSize = pcoinsTip->DynamicMemoryUsage();
2338     // The cache is large and close to the limit, but we have time now (not in the middle of a block processing).
2339     bool fCacheLarge = mode == FLUSH_STATE_PERIODIC && cacheSize * (10.0/9) > nCoinCacheUsage;
2340     // The cache is over the limit, we have to write now.
2341     bool fCacheCritical = mode == FLUSH_STATE_IF_NEEDED && cacheSize > nCoinCacheUsage;
2342     // It's been a while since we wrote the block index to disk. Do this frequently, so we don't need to redownload after a crash.
2343     bool fPeriodicWrite = mode == FLUSH_STATE_PERIODIC && nNow > nLastWrite + (int64_t)DATABASE_WRITE_INTERVAL * 1000000;
2344     // It's been very long since we flushed the cache. Do this infrequently, to optimize cache usage.
2345     bool fPeriodicFlush = mode == FLUSH_STATE_PERIODIC && nNow > nLastFlush + (int64_t)DATABASE_FLUSH_INTERVAL * 1000000;
2346     // Combine all conditions that result in a full cache flush.
2347     bool fDoFullFlush = (mode == FLUSH_STATE_ALWAYS) || fCacheLarge || fCacheCritical || fPeriodicFlush || fFlushForPrune;
2348     // Write blocks and block index to disk.
2349     if (fDoFullFlush || fPeriodicWrite) {
2350         // Depend on nMinDiskSpace to ensure we can write block index
2351         if (!CheckDiskSpace(0))
2352             return state.Error("out of disk space");
2353         // First make sure all block and undo data is flushed to disk.
2354         FlushBlockFile();
2355         // Then update all block file information (which may refer to block and undo files).
2356         {
2357             std::vector<std::pair<int, const CBlockFileInfo*> > vFiles;
2358             vFiles.reserve(setDirtyFileInfo.size());
2359             for (set<int>::iterator it = setDirtyFileInfo.begin(); it != setDirtyFileInfo.end(); ) {
2360                 vFiles.push_back(make_pair(*it, &vinfoBlockFile[*it]));
2361                 setDirtyFileInfo.erase(it++);
2362             }
2363             std::vector<const CBlockIndex*> vBlocks;
2364             vBlocks.reserve(setDirtyBlockIndex.size());
2365             for (set<CBlockIndex*>::iterator it = setDirtyBlockIndex.begin(); it != setDirtyBlockIndex.end(); ) {
2366                 vBlocks.push_back(*it);
2367                 setDirtyBlockIndex.erase(it++);
2368             }
2369             if (!pblocktree->WriteBatchSync(vFiles, nLastBlockFile, vBlocks)) {
2370                 return AbortNode(state, "Files to write to block index database");
2371             }
2372         }
2373         // Finally remove any pruned files
2374         if (fFlushForPrune)
2375             UnlinkPrunedFiles(setFilesToPrune);
2376         nLastWrite = nNow;
2377     }
2378     // Flush best chain related state. This can only be done if the blocks / block index write was also done.
2379     if (fDoFullFlush) {
2380         // Typical CCoins structures on disk are around 128 bytes in size.
2381         // Pushing a new one to the database can cause it to be written
2382         // twice (once in the log, and once in the tables). This is already
2383         // an overestimation, as most will delete an existing entry or
2384         // overwrite one. Still, use a conservative safety factor of 2.
2385         if (!CheckDiskSpace(128 * 2 * 2 * pcoinsTip->GetCacheSize()))
2386             return state.Error("out of disk space");
2387         // Flush the chainstate (which may refer to block index entries).
2388         if (!pcoinsTip->Flush())
2389             return AbortNode(state, "Failed to write to coin database");
2390         nLastFlush = nNow;
2391     }
2392     if ((mode == FLUSH_STATE_ALWAYS || mode == FLUSH_STATE_PERIODIC) && nNow > nLastSetChain + (int64_t)DATABASE_WRITE_INTERVAL * 1000000) {
2393         // Update best block in wallet (so we can detect restored wallets).
2394         GetMainSignals().SetBestChain(chainActive.GetLocator());
2395         nLastSetChain = nNow;
2396     }
2397     } catch (const std::runtime_error& e) {
2398         return AbortNode(state, std::string("System error while flushing: ") + e.what());
2399     }
2400     return true;
2401 }
2402
2403 void FlushStateToDisk() {
2404     CValidationState state;
2405     FlushStateToDisk(state, FLUSH_STATE_ALWAYS);
2406 }
2407
2408 void PruneAndFlush() {
2409     CValidationState state;
2410     fCheckForPruning = true;
2411     FlushStateToDisk(state, FLUSH_STATE_NONE);
2412 }
2413
2414 /** Update chainActive and related internal data structures. */
2415 void static UpdateTip(CBlockIndex *pindexNew) {
2416     const CChainParams& chainParams = Params();
2417     chainActive.SetTip(pindexNew);
2418
2419     // New best block
2420     nTimeBestReceived = GetTime();
2421     mempool.AddTransactionsUpdated(1);
2422
2423     LogPrintf("%s: new best=%s  height=%d  log2_work=%.8g  tx=%lu  date=%s progress=%f  cache=%.1fMiB(%utx)\n", __func__,
2424       chainActive.Tip()->GetBlockHash().ToString(), chainActive.Height(), log(chainActive.Tip()->nChainWork.getdouble())/log(2.0), (unsigned long)chainActive.Tip()->nChainTx,
2425       DateTimeStrFormat("%Y-%m-%d %H:%M:%S", chainActive.Tip()->GetBlockTime()),
2426       Checkpoints::GuessVerificationProgress(chainParams.Checkpoints(), chainActive.Tip()), pcoinsTip->DynamicMemoryUsage() * (1.0 / (1<<20)), pcoinsTip->GetCacheSize());
2427
2428     cvBlockChange.notify_all();
2429
2430     // Check the version of the last 100 blocks to see if we need to upgrade:
2431     static bool fWarned = false;
2432     if (!IsInitialBlockDownload() && !fWarned)
2433     {
2434         int nUpgraded = 0;
2435         const CBlockIndex* pindex = chainActive.Tip();
2436         for (int i = 0; i < 100 && pindex != NULL; i++)
2437         {
2438             if (pindex->nVersion > CBlock::CURRENT_VERSION)
2439                 ++nUpgraded;
2440             pindex = pindex->pprev;
2441         }
2442         if (nUpgraded > 0)
2443             LogPrintf("%s: %d of last 100 blocks above version %d\n", __func__, nUpgraded, (int)CBlock::CURRENT_VERSION);
2444         if (nUpgraded > 100/2)
2445         {
2446             // strMiscWarning is read by GetWarnings(), called by Qt and the JSON-RPC code to warn the user:
2447             strMiscWarning = _("Warning: This version is obsolete; upgrade required!");
2448             CAlert::Notify(strMiscWarning, true);
2449             fWarned = true;
2450         }
2451     }
2452 }
2453
2454 /** Disconnect chainActive's tip. */
2455 bool static DisconnectTip(CValidationState &state) {
2456     CBlockIndex *pindexDelete = chainActive.Tip();
2457     assert(pindexDelete);
2458     mempool.check(pcoinsTip);
2459     // Read block from disk.
2460     CBlock block;
2461     if (!ReadBlockFromDisk(block, pindexDelete))
2462         return AbortNode(state, "Failed to read block");
2463     // Apply the block atomically to the chain state.
2464     uint256 anchorBeforeDisconnect = pcoinsTip->GetBestAnchor();
2465     int64_t nStart = GetTimeMicros();
2466     {
2467         CCoinsViewCache view(pcoinsTip);
2468         if (!DisconnectBlock(block, state, pindexDelete, view))
2469             return error("DisconnectTip(): DisconnectBlock %s failed", pindexDelete->GetBlockHash().ToString());
2470         assert(view.Flush());
2471     }
2472     LogPrint("bench", "- Disconnect block: %.2fms\n", (GetTimeMicros() - nStart) * 0.001);
2473     uint256 anchorAfterDisconnect = pcoinsTip->GetBestAnchor();
2474     // Write the chain state to disk, if necessary.
2475     if (!FlushStateToDisk(state, FLUSH_STATE_IF_NEEDED))
2476         return false;
2477     // Resurrect mempool transactions from the disconnected block.
2478     BOOST_FOREACH(const CTransaction &tx, block.vtx) {
2479         // ignore validation errors in resurrected transactions
2480         list<CTransaction> removed;
2481         CValidationState stateDummy;
2482         if (tx.IsCoinBase() || !AcceptToMemoryPool(mempool, stateDummy, tx, false, NULL))
2483             mempool.remove(tx, removed, true);
2484     }
2485     if (anchorBeforeDisconnect != anchorAfterDisconnect) {
2486         // The anchor may not change between block disconnects,
2487         // in which case we don't want to evict from the mempool yet!
2488         mempool.removeWithAnchor(anchorBeforeDisconnect);
2489     }
2490     mempool.removeCoinbaseSpends(pcoinsTip, pindexDelete->nHeight);
2491     mempool.check(pcoinsTip);
2492     // Update chainActive and related variables.
2493     UpdateTip(pindexDelete->pprev);
2494     // Get the current commitment tree
2495     ZCIncrementalMerkleTree newTree;
2496     assert(pcoinsTip->GetAnchorAt(pcoinsTip->GetBestAnchor(), newTree));
2497     // Let wallets know transactions went from 1-confirmed to
2498     // 0-confirmed or conflicted:
2499     BOOST_FOREACH(const CTransaction &tx, block.vtx) {
2500         SyncWithWallets(tx, NULL);
2501     }
2502     // Update cached incremental witnesses
2503     GetMainSignals().ChainTip(pindexDelete, &block, newTree, false);
2504     return true;
2505 }
2506
2507 static int64_t nTimeReadFromDisk = 0;
2508 static int64_t nTimeConnectTotal = 0;
2509 static int64_t nTimeFlush = 0;
2510 static int64_t nTimeChainState = 0;
2511 static int64_t nTimePostConnect = 0;
2512
2513 /**
2514  * Connect a new block to chainActive. pblock is either NULL or a pointer to a CBlock
2515  * corresponding to pindexNew, to bypass loading it again from disk.
2516  */
2517 bool static ConnectTip(CValidationState &state, CBlockIndex *pindexNew, CBlock *pblock) {
2518     assert(pindexNew->pprev == chainActive.Tip());
2519     mempool.check(pcoinsTip);
2520     // Read block from disk.
2521     int64_t nTime1 = GetTimeMicros();
2522     CBlock block;
2523     if (!pblock) {
2524         if (!ReadBlockFromDisk(block, pindexNew))
2525             return AbortNode(state, "Failed to read block");
2526         pblock = &block;
2527     }
2528     // Get the current commitment tree
2529     ZCIncrementalMerkleTree oldTree;
2530     assert(pcoinsTip->GetAnchorAt(pcoinsTip->GetBestAnchor(), oldTree));
2531     // Apply the block atomically to the chain state.
2532     int64_t nTime2 = GetTimeMicros(); nTimeReadFromDisk += nTime2 - nTime1;
2533     int64_t nTime3;
2534     LogPrint("bench", "  - Load block from disk: %.2fms [%.2fs]\n", (nTime2 - nTime1) * 0.001, nTimeReadFromDisk * 0.000001);
2535     {
2536         CCoinsViewCache view(pcoinsTip);
2537         CInv inv(MSG_BLOCK, pindexNew->GetBlockHash());
2538         bool rv = ConnectBlock(*pblock, state, pindexNew, view);
2539         GetMainSignals().BlockChecked(*pblock, state);
2540         if (!rv) {
2541             if (state.IsInvalid())
2542                 InvalidBlockFound(pindexNew, state);
2543             return error("ConnectTip(): ConnectBlock %s failed", pindexNew->GetBlockHash().ToString());
2544         }
2545         mapBlockSource.erase(inv.hash);
2546         nTime3 = GetTimeMicros(); nTimeConnectTotal += nTime3 - nTime2;
2547         LogPrint("bench", "  - Connect total: %.2fms [%.2fs]\n", (nTime3 - nTime2) * 0.001, nTimeConnectTotal * 0.000001);
2548         assert(view.Flush());
2549     }
2550     int64_t nTime4 = GetTimeMicros(); nTimeFlush += nTime4 - nTime3;
2551     LogPrint("bench", "  - Flush: %.2fms [%.2fs]\n", (nTime4 - nTime3) * 0.001, nTimeFlush * 0.000001);
2552     // Write the chain state to disk, if necessary.
2553     if (!FlushStateToDisk(state, FLUSH_STATE_IF_NEEDED))
2554         return false;
2555     int64_t nTime5 = GetTimeMicros(); nTimeChainState += nTime5 - nTime4;
2556     LogPrint("bench", "  - Writing chainstate: %.2fms [%.2fs]\n", (nTime5 - nTime4) * 0.001, nTimeChainState * 0.000001);
2557     // Remove conflicting transactions from the mempool.
2558     list<CTransaction> txConflicted;
2559     mempool.removeForBlock(pblock->vtx, pindexNew->nHeight, txConflicted, !IsInitialBlockDownload());
2560     mempool.check(pcoinsTip);
2561     // Update chainActive & related variables.
2562     UpdateTip(pindexNew);
2563     // Tell wallet about transactions that went from mempool
2564     // to conflicted:
2565     BOOST_FOREACH(const CTransaction &tx, txConflicted) {
2566         SyncWithWallets(tx, NULL);
2567     }
2568     // ... and about transactions that got confirmed:
2569     BOOST_FOREACH(const CTransaction &tx, pblock->vtx) {
2570         SyncWithWallets(tx, pblock);
2571     }
2572     // Update cached incremental witnesses
2573     GetMainSignals().ChainTip(pindexNew, pblock, oldTree, true);
2574
2575     int64_t nTime6 = GetTimeMicros(); nTimePostConnect += nTime6 - nTime5; nTimeTotal += nTime6 - nTime1;
2576     LogPrint("bench", "  - Connect postprocess: %.2fms [%.2fs]\n", (nTime6 - nTime5) * 0.001, nTimePostConnect * 0.000001);
2577     LogPrint("bench", "- Connect block: %.2fms [%.2fs]\n", (nTime6 - nTime1) * 0.001, nTimeTotal * 0.000001);
2578     return true;
2579 }
2580
2581 /**
2582  * Return the tip of the chain with the most work in it, that isn't
2583  * known to be invalid (it's however far from certain to be valid).
2584  */
2585 static CBlockIndex* FindMostWorkChain() {
2586     do {
2587         CBlockIndex *pindexNew = NULL;
2588
2589         // Find the best candidate header.
2590         {
2591             std::set<CBlockIndex*, CBlockIndexWorkComparator>::reverse_iterator it = setBlockIndexCandidates.rbegin();
2592             if (it == setBlockIndexCandidates.rend())
2593                 return NULL;
2594             pindexNew = *it;
2595         }
2596
2597         // Check whether all blocks on the path between the currently active chain and the candidate are valid.
2598         // Just going until the active chain is an optimization, as we know all blocks in it are valid already.
2599         CBlockIndex *pindexTest = pindexNew;
2600         bool fInvalidAncestor = false;
2601         while (pindexTest && !chainActive.Contains(pindexTest)) {
2602             assert(pindexTest->nChainTx || pindexTest->nHeight == 0);
2603
2604             // Pruned nodes may have entries in setBlockIndexCandidates for
2605             // which block files have been deleted.  Remove those as candidates
2606             // for the most work chain if we come across them; we can't switch
2607             // to a chain unless we have all the non-active-chain parent blocks.
2608             bool fFailedChain = pindexTest->nStatus & BLOCK_FAILED_MASK;
2609             bool fMissingData = !(pindexTest->nStatus & BLOCK_HAVE_DATA);
2610             if (fFailedChain || fMissingData) {
2611                 // Candidate chain is not usable (either invalid or missing data)
2612                 if (fFailedChain && (pindexBestInvalid == NULL || pindexNew->nChainWork > pindexBestInvalid->nChainWork))
2613                     pindexBestInvalid = pindexNew;
2614                 CBlockIndex *pindexFailed = pindexNew;
2615                 // Remove the entire chain from the set.
2616                 while (pindexTest != pindexFailed) {
2617                     if (fFailedChain) {
2618                         pindexFailed->nStatus |= BLOCK_FAILED_CHILD;
2619                     } else if (fMissingData) {
2620                         // If we're missing data, then add back to mapBlocksUnlinked,
2621                         // so that if the block arrives in the future we can try adding
2622                         // to setBlockIndexCandidates again.
2623                         mapBlocksUnlinked.insert(std::make_pair(pindexFailed->pprev, pindexFailed));
2624                     }
2625                     setBlockIndexCandidates.erase(pindexFailed);
2626                     pindexFailed = pindexFailed->pprev;
2627                 }
2628                 setBlockIndexCandidates.erase(pindexTest);
2629                 fInvalidAncestor = true;
2630                 break;
2631             }
2632             pindexTest = pindexTest->pprev;
2633         }
2634         if (!fInvalidAncestor)
2635             return pindexNew;
2636     } while(true);
2637 }
2638
2639 /** Delete all entries in setBlockIndexCandidates that are worse than the current tip. */
2640 static void PruneBlockIndexCandidates() {
2641     // Note that we can't delete the current block itself, as we may need to return to it later in case a
2642     // reorganization to a better block fails.
2643     std::set<CBlockIndex*, CBlockIndexWorkComparator>::iterator it = setBlockIndexCandidates.begin();
2644     while (it != setBlockIndexCandidates.end() && setBlockIndexCandidates.value_comp()(*it, chainActive.Tip())) {
2645         setBlockIndexCandidates.erase(it++);
2646     }
2647     // Either the current tip or a successor of it we're working towards is left in setBlockIndexCandidates.
2648     assert(!setBlockIndexCandidates.empty());
2649 }
2650
2651 /**
2652  * Try to make some progress towards making pindexMostWork the active block.
2653  * pblock is either NULL or a pointer to a CBlock corresponding to pindexMostWork.
2654  */
2655 static bool ActivateBestChainStep(CValidationState &state, CBlockIndex *pindexMostWork, CBlock *pblock) {
2656     AssertLockHeld(cs_main);
2657     bool fInvalidFound = false;
2658     const CBlockIndex *pindexOldTip = chainActive.Tip();
2659     const CBlockIndex *pindexFork = chainActive.FindFork(pindexMostWork);
2660
2661     // Disconnect active blocks which are no longer in the best chain.
2662     while (chainActive.Tip() && chainActive.Tip() != pindexFork) {
2663         if (!DisconnectTip(state))
2664             return false;
2665     }
2666
2667     // Build list of new blocks to connect.
2668     std::vector<CBlockIndex*> vpindexToConnect;
2669     bool fContinue = true;
2670     int nHeight = pindexFork ? pindexFork->nHeight : -1;
2671     while (fContinue && nHeight != pindexMostWork->nHeight) {
2672     // Don't iterate the entire list of potential improvements toward the best tip, as we likely only need
2673     // a few blocks along the way.
2674     int nTargetHeight = std::min(nHeight + 32, pindexMostWork->nHeight);
2675     vpindexToConnect.clear();
2676     vpindexToConnect.reserve(nTargetHeight - nHeight);
2677     CBlockIndex *pindexIter = pindexMostWork->GetAncestor(nTargetHeight);
2678     while (pindexIter && pindexIter->nHeight != nHeight) {
2679         vpindexToConnect.push_back(pindexIter);
2680         pindexIter = pindexIter->pprev;
2681     }
2682     nHeight = nTargetHeight;
2683
2684     // Connect new blocks.
2685     BOOST_REVERSE_FOREACH(CBlockIndex *pindexConnect, vpindexToConnect) {
2686         if (!ConnectTip(state, pindexConnect, pindexConnect == pindexMostWork ? pblock : NULL)) {
2687             if (state.IsInvalid()) {
2688                 // The block violates a consensus rule.
2689                 if (!state.CorruptionPossible())
2690                     InvalidChainFound(vpindexToConnect.back());
2691                 state = CValidationState();
2692                 fInvalidFound = true;
2693                 fContinue = false;
2694                 break;
2695             } else {
2696                 // A system error occurred (disk space, database error, ...).
2697                 return false;
2698             }
2699         } else {
2700             PruneBlockIndexCandidates();
2701             if (!pindexOldTip || chainActive.Tip()->nChainWork > pindexOldTip->nChainWork) {
2702                 // We're in a better position than we were. Return temporarily to release the lock.
2703                 fContinue = false;
2704                 break;
2705             }
2706         }
2707     }
2708     }
2709
2710     // Callbacks/notifications for a new best chain.
2711     if (fInvalidFound)
2712         CheckForkWarningConditionsOnNewFork(vpindexToConnect.back());
2713     else
2714         CheckForkWarningConditions();
2715
2716     return true;
2717 }
2718
2719 /**
2720  * Make the best chain active, in multiple steps. The result is either failure
2721  * or an activated best chain. pblock is either NULL or a pointer to a block
2722  * that is already loaded (to avoid loading it again from disk).
2723  */
2724 bool ActivateBestChain(CValidationState &state, CBlock *pblock) {
2725     CBlockIndex *pindexNewTip = NULL;
2726     CBlockIndex *pindexMostWork = NULL;
2727     const CChainParams& chainParams = Params();
2728     do {
2729         boost::this_thread::interruption_point();
2730
2731         bool fInitialDownload;
2732         {
2733             LOCK(cs_main);
2734             pindexMostWork = FindMostWorkChain();
2735
2736             // Whether we have anything to do at all.
2737             if (pindexMostWork == NULL || pindexMostWork == chainActive.Tip())
2738                 return true;
2739
2740             if (!ActivateBestChainStep(state, pindexMostWork, pblock && pblock->GetHash() == pindexMostWork->GetBlockHash() ? pblock : NULL))
2741                 return false;
2742
2743             pindexNewTip = chainActive.Tip();
2744             fInitialDownload = IsInitialBlockDownload();
2745         }
2746         // When we reach this point, we switched to a new tip (stored in pindexNewTip).
2747
2748         // Notifications/callbacks that can run without cs_main
2749         if (!fInitialDownload) {
2750             uint256 hashNewTip = pindexNewTip->GetBlockHash();
2751             // Relay inventory, but don't relay old inventory during initial block download.
2752             int nBlockEstimate = 0;
2753             if (fCheckpointsEnabled)
2754                 nBlockEstimate = Checkpoints::GetTotalBlocksEstimate(chainParams.Checkpoints());
2755             // Don't relay blocks if pruning -- could cause a peer to try to download, resulting
2756             // in a stalled download if the block file is pruned before the request.
2757             if (nLocalServices & NODE_NETWORK) {
2758                 LOCK(cs_vNodes);
2759                 BOOST_FOREACH(CNode* pnode, vNodes)
2760                     if (chainActive.Height() > (pnode->nStartingHeight != -1 ? pnode->nStartingHeight - 2000 : nBlockEstimate))
2761                         pnode->PushInventory(CInv(MSG_BLOCK, hashNewTip));
2762             }
2763             // Notify external listeners about the new tip.
2764             uiInterface.NotifyBlockTip(hashNewTip);
2765         }
2766     } while(pindexMostWork != chainActive.Tip());
2767     CheckBlockIndex();
2768
2769     // Write changes periodically to disk, after relay.
2770     if (!FlushStateToDisk(state, FLUSH_STATE_PERIODIC)) {
2771         return false;
2772     }
2773
2774     return true;
2775 }
2776
2777 bool InvalidateBlock(CValidationState& state, CBlockIndex *pindex) {
2778     AssertLockHeld(cs_main);
2779
2780     // Mark the block itself as invalid.
2781     pindex->nStatus |= BLOCK_FAILED_VALID;
2782     setDirtyBlockIndex.insert(pindex);
2783     setBlockIndexCandidates.erase(pindex);
2784
2785     while (chainActive.Contains(pindex)) {
2786         CBlockIndex *pindexWalk = chainActive.Tip();
2787         pindexWalk->nStatus |= BLOCK_FAILED_CHILD;
2788         setDirtyBlockIndex.insert(pindexWalk);
2789         setBlockIndexCandidates.erase(pindexWalk);
2790         // ActivateBestChain considers blocks already in chainActive
2791         // unconditionally valid already, so force disconnect away from it.
2792         if (!DisconnectTip(state)) {
2793             return false;
2794         }
2795     }
2796
2797     // The resulting new best tip may not be in setBlockIndexCandidates anymore, so
2798     // add it again.
2799     BlockMap::iterator it = mapBlockIndex.begin();
2800     while (it != mapBlockIndex.end()) {
2801         if (it->second->IsValid(BLOCK_VALID_TRANSACTIONS) && it->second->nChainTx && !setBlockIndexCandidates.value_comp()(it->second, chainActive.Tip())) {
2802             setBlockIndexCandidates.insert(it->second);
2803         }
2804         it++;
2805     }
2806
2807     InvalidChainFound(pindex);
2808     return true;
2809 }
2810
2811 bool ReconsiderBlock(CValidationState& state, CBlockIndex *pindex) {
2812     AssertLockHeld(cs_main);
2813
2814     int nHeight = pindex->nHeight;
2815
2816     // Remove the invalidity flag from this block and all its descendants.
2817     BlockMap::iterator it = mapBlockIndex.begin();
2818     while (it != mapBlockIndex.end()) {
2819         if (!it->second->IsValid() && it->second->GetAncestor(nHeight) == pindex) {
2820             it->second->nStatus &= ~BLOCK_FAILED_MASK;
2821             setDirtyBlockIndex.insert(it->second);
2822             if (it->second->IsValid(BLOCK_VALID_TRANSACTIONS) && it->second->nChainTx && setBlockIndexCandidates.value_comp()(chainActive.Tip(), it->second)) {
2823                 setBlockIndexCandidates.insert(it->second);
2824             }
2825             if (it->second == pindexBestInvalid) {
2826                 // Reset invalid block marker if it was pointing to one of those.
2827                 pindexBestInvalid = NULL;
2828             }
2829         }
2830         it++;
2831     }
2832
2833     // Remove the invalidity flag from all ancestors too.
2834     while (pindex != NULL) {
2835         if (pindex->nStatus & BLOCK_FAILED_MASK) {
2836             pindex->nStatus &= ~BLOCK_FAILED_MASK;
2837             setDirtyBlockIndex.insert(pindex);
2838         }
2839         pindex = pindex->pprev;
2840     }
2841     return true;
2842 }
2843
2844 CBlockIndex* AddToBlockIndex(const CBlockHeader& block)
2845 {
2846     // Check for duplicate
2847     uint256 hash = block.GetHash();
2848     BlockMap::iterator it = mapBlockIndex.find(hash);
2849     if (it != mapBlockIndex.end())
2850         return it->second;
2851
2852     // Construct new block index object
2853     CBlockIndex* pindexNew = new CBlockIndex(block);
2854     assert(pindexNew);
2855     // We assign the sequence id to blocks only when the full data is available,
2856     // to avoid miners withholding blocks but broadcasting headers, to get a
2857     // competitive advantage.
2858     pindexNew->nSequenceId = 0;
2859     BlockMap::iterator mi = mapBlockIndex.insert(make_pair(hash, pindexNew)).first;
2860     pindexNew->phashBlock = &((*mi).first);
2861     BlockMap::iterator miPrev = mapBlockIndex.find(block.hashPrevBlock);
2862     if (miPrev != mapBlockIndex.end())
2863     {
2864         pindexNew->pprev = (*miPrev).second;
2865         pindexNew->nHeight = pindexNew->pprev->nHeight + 1;
2866         pindexNew->BuildSkip();
2867     }
2868     pindexNew->nChainWork = (pindexNew->pprev ? pindexNew->pprev->nChainWork : 0) + GetBlockProof(*pindexNew);
2869     pindexNew->RaiseValidity(BLOCK_VALID_TREE);
2870     if (pindexBestHeader == NULL || pindexBestHeader->nChainWork < pindexNew->nChainWork)
2871         pindexBestHeader = pindexNew;
2872
2873     setDirtyBlockIndex.insert(pindexNew);
2874
2875     return pindexNew;
2876 }
2877
2878 /** Mark a block as having its data received and checked (up to BLOCK_VALID_TRANSACTIONS). */
2879 bool ReceivedBlockTransactions(const CBlock &block, CValidationState& state, CBlockIndex *pindexNew, const CDiskBlockPos& pos)
2880 {
2881     pindexNew->nTx = block.vtx.size();
2882     pindexNew->nChainTx = 0;
2883     pindexNew->nFile = pos.nFile;
2884     pindexNew->nDataPos = pos.nPos;
2885     pindexNew->nUndoPos = 0;
2886     pindexNew->nStatus |= BLOCK_HAVE_DATA;
2887     pindexNew->RaiseValidity(BLOCK_VALID_TRANSACTIONS);
2888     setDirtyBlockIndex.insert(pindexNew);
2889
2890     if (pindexNew->pprev == NULL || pindexNew->pprev->nChainTx) {
2891         // If pindexNew is the genesis block or all parents are BLOCK_VALID_TRANSACTIONS.
2892         deque<CBlockIndex*> queue;
2893         queue.push_back(pindexNew);
2894
2895         // Recursively process any descendant blocks that now may be eligible to be connected.
2896         while (!queue.empty()) {
2897             CBlockIndex *pindex = queue.front();
2898             queue.pop_front();
2899             pindex->nChainTx = (pindex->pprev ? pindex->pprev->nChainTx : 0) + pindex->nTx;
2900             {
2901                 LOCK(cs_nBlockSequenceId);
2902                 pindex->nSequenceId = nBlockSequenceId++;
2903             }
2904             if (chainActive.Tip() == NULL || !setBlockIndexCandidates.value_comp()(pindex, chainActive.Tip())) {
2905                 setBlockIndexCandidates.insert(pindex);
2906             }
2907             std::pair<std::multimap<CBlockIndex*, CBlockIndex*>::iterator, std::multimap<CBlockIndex*, CBlockIndex*>::iterator> range = mapBlocksUnlinked.equal_range(pindex);
2908             while (range.first != range.second) {
2909                 std::multimap<CBlockIndex*, CBlockIndex*>::iterator it = range.first;
2910                 queue.push_back(it->second);
2911                 range.first++;
2912                 mapBlocksUnlinked.erase(it);
2913             }
2914         }
2915     } else {
2916         if (pindexNew->pprev && pindexNew->pprev->IsValid(BLOCK_VALID_TREE)) {
2917             mapBlocksUnlinked.insert(std::make_pair(pindexNew->pprev, pindexNew));
2918         }
2919     }
2920
2921     return true;
2922 }
2923
2924 bool FindBlockPos(CValidationState &state, CDiskBlockPos &pos, unsigned int nAddSize, unsigned int nHeight, uint64_t nTime, bool fKnown = false)
2925 {
2926     LOCK(cs_LastBlockFile);
2927
2928     unsigned int nFile = fKnown ? pos.nFile : nLastBlockFile;
2929     if (vinfoBlockFile.size() <= nFile) {
2930         vinfoBlockFile.resize(nFile + 1);
2931     }
2932
2933     if (!fKnown) {
2934         while (vinfoBlockFile[nFile].nSize + nAddSize >= MAX_BLOCKFILE_SIZE) {
2935             nFile++;
2936             if (vinfoBlockFile.size() <= nFile) {
2937                 vinfoBlockFile.resize(nFile + 1);
2938             }
2939         }
2940         pos.nFile = nFile;
2941         pos.nPos = vinfoBlockFile[nFile].nSize;
2942     }
2943
2944     if (nFile != nLastBlockFile) {
2945         if (!fKnown) {
2946             LogPrintf("Leaving block file %i: %s\n", nFile, vinfoBlockFile[nFile].ToString());
2947         }
2948         FlushBlockFile(!fKnown);
2949         nLastBlockFile = nFile;
2950     }
2951
2952     vinfoBlockFile[nFile].AddBlock(nHeight, nTime);
2953     if (fKnown)
2954         vinfoBlockFile[nFile].nSize = std::max(pos.nPos + nAddSize, vinfoBlockFile[nFile].nSize);
2955     else
2956         vinfoBlockFile[nFile].nSize += nAddSize;
2957
2958     if (!fKnown) {
2959         unsigned int nOldChunks = (pos.nPos + BLOCKFILE_CHUNK_SIZE - 1) / BLOCKFILE_CHUNK_SIZE;
2960         unsigned int nNewChunks = (vinfoBlockFile[nFile].nSize + BLOCKFILE_CHUNK_SIZE - 1) / BLOCKFILE_CHUNK_SIZE;
2961         if (nNewChunks > nOldChunks) {
2962             if (fPruneMode)
2963                 fCheckForPruning = true;
2964             if (CheckDiskSpace(nNewChunks * BLOCKFILE_CHUNK_SIZE - pos.nPos)) {
2965                 FILE *file = OpenBlockFile(pos);
2966                 if (file) {
2967                     LogPrintf("Pre-allocating up to position 0x%x in blk%05u.dat\n", nNewChunks * BLOCKFILE_CHUNK_SIZE, pos.nFile);
2968                     AllocateFileRange(file, pos.nPos, nNewChunks * BLOCKFILE_CHUNK_SIZE - pos.nPos);
2969                     fclose(file);
2970                 }
2971             }
2972             else
2973                 return state.Error("out of disk space");
2974         }
2975     }
2976
2977     setDirtyFileInfo.insert(nFile);
2978     return true;
2979 }
2980
2981 bool FindUndoPos(CValidationState &state, int nFile, CDiskBlockPos &pos, unsigned int nAddSize)
2982 {
2983     pos.nFile = nFile;
2984
2985     LOCK(cs_LastBlockFile);
2986
2987     unsigned int nNewSize;
2988     pos.nPos = vinfoBlockFile[nFile].nUndoSize;
2989     nNewSize = vinfoBlockFile[nFile].nUndoSize += nAddSize;
2990     setDirtyFileInfo.insert(nFile);
2991
2992     unsigned int nOldChunks = (pos.nPos + UNDOFILE_CHUNK_SIZE - 1) / UNDOFILE_CHUNK_SIZE;
2993     unsigned int nNewChunks = (nNewSize + UNDOFILE_CHUNK_SIZE - 1) / UNDOFILE_CHUNK_SIZE;
2994     if (nNewChunks > nOldChunks) {
2995         if (fPruneMode)
2996             fCheckForPruning = true;
2997         if (CheckDiskSpace(nNewChunks * UNDOFILE_CHUNK_SIZE - pos.nPos)) {
2998             FILE *file = OpenUndoFile(pos);
2999             if (file) {
3000                 LogPrintf("Pre-allocating up to position 0x%x in rev%05u.dat\n", nNewChunks * UNDOFILE_CHUNK_SIZE, pos.nFile);
3001                 AllocateFileRange(file, pos.nPos, nNewChunks * UNDOFILE_CHUNK_SIZE - pos.nPos);
3002                 fclose(file);
3003             }
3004         }
3005         else
3006             return state.Error("out of disk space");
3007     }
3008
3009     return true;
3010 }
3011
3012 bool CheckBlockHeader(int32_t height,CBlockIndex *pindex, const CBlockHeader& blockhdr, CValidationState& state, bool fCheckPOW)
3013 {
3014     uint8_t pubkey33[33];
3015     // Check timestamp
3016     if (blockhdr.GetBlockTime() > GetAdjustedTime() + 60)
3017         return state.Invalid(error("CheckBlockHeader(): block timestamp too far in the future"),REJECT_INVALID, "time-too-new");
3018     // Check block version
3019     //if (block.nVersion < MIN_BLOCK_VERSION)
3020     //    return state.DoS(100, error("CheckBlockHeader(): block version too low"),REJECT_INVALID, "version-too-low");
3021
3022     // Check Equihash solution is valid
3023     if ( fCheckPOW && !CheckEquihashSolution(&blockhdr, Params()) )
3024         return state.DoS(100, error("CheckBlockHeader(): Equihash solution invalid"),REJECT_INVALID, "invalid-solution");
3025
3026     // Check proof of work matches claimed amount
3027     komodo_index2pubkey33(pubkey33,pindex,height);
3028     if ( fCheckPOW && !CheckProofOfWork(height,pubkey33,blockhdr.GetHash(), blockhdr.nBits, Params().GetConsensus()) )
3029         return state.DoS(50, error("CheckBlockHeader(): proof of work failed"),REJECT_INVALID, "high-hash");
3030     return true;
3031 }
3032
3033 bool CheckBlock(int32_t height,CBlockIndex *pindex,const CBlock& block, CValidationState& state, bool fCheckPOW, bool fCheckMerkleRoot)
3034 {
3035     // These are checks that are independent of context.
3036
3037     // Check that the header is valid (particularly PoW).  This is mostly
3038     // redundant with the call in AcceptBlockHeader.
3039     if (!CheckBlockHeader(height,pindex,block,state,fCheckPOW))
3040         return false;
3041
3042     // Check the merkle root.
3043     if (fCheckMerkleRoot) {
3044         bool mutated;
3045         uint256 hashMerkleRoot2 = block.BuildMerkleTree(&mutated);
3046         if (block.hashMerkleRoot != hashMerkleRoot2)
3047             return state.DoS(100, error("CheckBlock(): hashMerkleRoot mismatch"),
3048                              REJECT_INVALID, "bad-txnmrklroot", true);
3049
3050         // Check for merkle tree malleability (CVE-2012-2459): repeating sequences
3051         // of transactions in a block without affecting the merkle root of a block,
3052         // while still invalidating it.
3053         if (mutated)
3054             return state.DoS(100, error("CheckBlock(): duplicate transaction"),
3055                              REJECT_INVALID, "bad-txns-duplicate", true);
3056     }
3057
3058     // All potential-corruption validation must be done before we do any
3059     // transaction validation, as otherwise we may mark the header as invalid
3060     // because we receive the wrong transactions for it.
3061
3062     // Size limits
3063     if (block.vtx.empty() || block.vtx.size() > MAX_BLOCK_SIZE || ::GetSerializeSize(block, SER_NETWORK, PROTOCOL_VERSION) > MAX_BLOCK_SIZE)
3064         return state.DoS(100, error("CheckBlock(): size limits failed"),
3065                          REJECT_INVALID, "bad-blk-length");
3066
3067     // First transaction must be coinbase, the rest must not be
3068     if (block.vtx.empty() || !block.vtx[0].IsCoinBase())
3069         return state.DoS(100, error("CheckBlock(): first tx is not coinbase"),
3070                          REJECT_INVALID, "bad-cb-missing");
3071     for (unsigned int i = 1; i < block.vtx.size(); i++)
3072         if (block.vtx[i].IsCoinBase())
3073             return state.DoS(100, error("CheckBlock(): more than one coinbase"),
3074                              REJECT_INVALID, "bad-cb-multiple");
3075
3076     // Check transactions
3077     BOOST_FOREACH(const CTransaction& tx, block.vtx)
3078         if (!CheckTransaction(tx, state))
3079             return error("CheckBlock(): CheckTransaction failed");
3080
3081     unsigned int nSigOps = 0;
3082     BOOST_FOREACH(const CTransaction& tx, block.vtx)
3083     {
3084         nSigOps += GetLegacySigOpCount(tx);
3085     }
3086     if (nSigOps > MAX_BLOCK_SIGOPS)
3087         return state.DoS(100, error("CheckBlock(): out-of-bounds SigOpCount"),
3088                          REJECT_INVALID, "bad-blk-sigops", true);
3089
3090     return true;
3091 }
3092
3093 bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationState& state, CBlockIndex * const pindexPrev)
3094 {
3095     const CChainParams& chainParams = Params();
3096     const Consensus::Params& consensusParams = chainParams.GetConsensus();
3097     uint256 hash = block.GetHash();
3098     if (hash == consensusParams.hashGenesisBlock)
3099         return true;
3100
3101     assert(pindexPrev);
3102
3103     int nHeight = pindexPrev->nHeight+1;
3104
3105     // Check proof of work
3106     if (block.nBits != GetNextWorkRequired(pindexPrev, &block, consensusParams))
3107     {
3108         cout << block.nBits << " block.nBits vs. calc " << GetNextWorkRequired(pindexPrev, &block, consensusParams) << endl;
3109         return state.DoS(100, error("%s: incorrect proof of work", __func__),
3110                          REJECT_INVALID, "bad-diffbits");
3111     }
3112
3113     // Check timestamp against prev
3114     if (block.GetBlockTime() <= pindexPrev->GetMedianTimePast())
3115         return state.Invalid(error("%s: block's timestamp is too early", __func__),
3116                              REJECT_INVALID, "time-too-old");
3117
3118     if(fCheckpointsEnabled)
3119     {
3120         // Check that the block chain matches the known block chain up to a checkpoint
3121         if (!Checkpoints::CheckBlock(chainParams.Checkpoints(), nHeight, hash))
3122             return state.DoS(100, error("%s: rejected by checkpoint lock-in at %d", __func__, nHeight),REJECT_CHECKPOINT, "checkpoint mismatch");
3123
3124         // Don't accept any forks from the main chain prior to last checkpoint
3125         CBlockIndex* pcheckpoint = Checkpoints::GetLastCheckpoint(chainParams.Checkpoints());
3126         int32_t notarized_height;
3127         if (pcheckpoint && nHeight < pcheckpoint->nHeight)
3128             return state.DoS(100, error("%s: forked chain older than last checkpoint (height %d) vs %d", __func__, nHeight,pcheckpoint->nHeight));
3129         else if ( komodo_checkpoint(&notarized_height,nHeight,hash) < 0 )
3130             return state.DoS(100, error("%s: forked chain %d older than last notarized (height %d) vs %d", __func__,nHeight, notarized_height));
3131     }
3132
3133     // Reject block.nVersion < 4 blocks
3134     if (block.nVersion < 4)
3135         return state.Invalid(error("%s : rejected nVersion<4 block", __func__),
3136                              REJECT_OBSOLETE, "bad-version");
3137
3138     return true;
3139 }
3140
3141 bool ContextualCheckBlock(const CBlock& block, CValidationState& state, CBlockIndex * const pindexPrev)
3142 {
3143     const int nHeight = pindexPrev == NULL ? 0 : pindexPrev->nHeight + 1;
3144     const Consensus::Params& consensusParams = Params().GetConsensus();
3145
3146     // Check that all transactions are finalized
3147     BOOST_FOREACH(const CTransaction& tx, block.vtx) {
3148         int nLockTimeFlags = 0;
3149         int64_t nLockTimeCutoff = (nLockTimeFlags & LOCKTIME_MEDIAN_TIME_PAST)
3150                                 ? pindexPrev->GetMedianTimePast()
3151                                 : block.GetBlockTime();
3152         if (!IsFinalTx(tx, nHeight, nLockTimeCutoff)) {
3153             return state.DoS(10, error("%s: contains a non-final transaction", __func__), REJECT_INVALID, "bad-txns-nonfinal");
3154         }
3155     }
3156
3157     // Enforce block.nVersion=2 rule that the coinbase starts with serialized block height
3158     // if 750 of the last 1,000 blocks are version 2 or greater (51/100 if testnet):
3159     if (block.nVersion >= 2)
3160     {
3161         CScript expect = CScript() << nHeight;
3162         if (block.vtx[0].vin[0].scriptSig.size() < expect.size() ||
3163             !std::equal(expect.begin(), expect.end(), block.vtx[0].vin[0].scriptSig.begin())) {
3164             return state.DoS(100, error("%s: block height mismatch in coinbase", __func__), REJECT_INVALID, "bad-cb-height");
3165         }
3166     }
3167
3168     return true;
3169 }
3170
3171 bool AcceptBlockHeader(const CBlockHeader& block, CValidationState& state, CBlockIndex** ppindex)
3172 {
3173     const CChainParams& chainparams = Params();
3174     AssertLockHeld(cs_main);
3175     // Check for duplicate
3176     uint256 hash = block.GetHash();
3177     BlockMap::iterator miSelf = mapBlockIndex.find(hash);
3178     CBlockIndex *pindex = NULL;
3179     if (miSelf != mapBlockIndex.end()) {
3180         // Block header is already known.
3181         pindex = miSelf->second;
3182         if (ppindex)
3183             *ppindex = pindex;
3184         if (pindex != 0 && pindex->nStatus & BLOCK_FAILED_MASK)
3185             return state.Invalid(error("%s: block is marked invalid", __func__), 0, "duplicate");
3186         return true;
3187     }
3188
3189     if (!CheckBlockHeader(*ppindex!=0?(*ppindex)->nHeight:0,*ppindex, block, state))
3190         return false;
3191
3192     // Get prev block index
3193     CBlockIndex* pindexPrev = NULL;
3194     if (hash != chainparams.GetConsensus().hashGenesisBlock) {
3195         BlockMap::iterator mi = mapBlockIndex.find(block.hashPrevBlock);
3196         if (mi == mapBlockIndex.end())
3197             return state.DoS(10, error("%s: prev block not found", __func__), 0, "bad-prevblk");
3198         pindexPrev = (*mi).second;
3199         if (pindexPrev->nStatus & BLOCK_FAILED_MASK)
3200             return state.DoS(100, error("%s: prev block invalid", __func__), REJECT_INVALID, "bad-prevblk");
3201     }
3202     if (!ContextualCheckBlockHeader(block, state, pindexPrev))
3203         return false;
3204     if (pindex == NULL)
3205         pindex = AddToBlockIndex(block);
3206     //if (!CheckBlockHeader(pindex!=0?pindex->nHeight:0,pindex, block, state))
3207     //    return false;
3208     if (ppindex)
3209         *ppindex = pindex;
3210     return true;
3211 }
3212
3213 bool AcceptBlock(CBlock& block, CValidationState& state, CBlockIndex** ppindex, bool fRequested, CDiskBlockPos* dbp)
3214 {
3215     const CChainParams& chainparams = Params();
3216     AssertLockHeld(cs_main);
3217
3218     CBlockIndex *&pindex = *ppindex;
3219     if (!AcceptBlockHeader(block, state, &pindex))
3220         return false;
3221     if ( pindex == 0 )
3222     {
3223         fprintf(stderr,"AcceptBlock error null pindex\n");
3224         return false;
3225     }
3226     // Try to process all requested blocks that we don't have, but only
3227     // process an unrequested block if it's new and has enough work to
3228     // advance our tip, and isn't too many blocks ahead.
3229     bool fAlreadyHave = pindex->nStatus & BLOCK_HAVE_DATA;
3230     bool fHasMoreWork = (chainActive.Tip() ? pindex->nChainWork > chainActive.Tip()->nChainWork : true);
3231     // Blocks that are too out-of-order needlessly limit the effectiveness of
3232     // pruning, because pruning will not delete block files that contain any
3233     // blocks which are too close in height to the tip.  Apply this test
3234     // regardless of whether pruning is enabled; it should generally be safe to
3235     // not process unrequested blocks.
3236     bool fTooFarAhead = (pindex->nHeight > int(chainActive.Height() + MIN_BLOCKS_TO_KEEP));
3237
3238     // TODO: deal better with return value and error conditions for duplicate
3239     // and unrequested blocks.
3240     if (fAlreadyHave) return true;
3241     if (!fRequested) {  // If we didn't ask for it:
3242         if (pindex->nTx != 0) return true;  // This is a previously-processed block that was pruned
3243         if (!fHasMoreWork) return true;     // Don't process less-work chains
3244         if (fTooFarAhead) return true;      // Block height is too high
3245     }
3246
3247     if ((!CheckBlock(pindex->nHeight,pindex,block, state)) || !ContextualCheckBlock(block, state, pindex->pprev)) {
3248         if (state.IsInvalid() && !state.CorruptionPossible()) {
3249             pindex->nStatus |= BLOCK_FAILED_VALID;
3250             setDirtyBlockIndex.insert(pindex);
3251         }
3252         return false;
3253     }
3254
3255     int nHeight = pindex->nHeight;
3256
3257     // Write block to history file
3258     try {
3259         unsigned int nBlockSize = ::GetSerializeSize(block, SER_DISK, CLIENT_VERSION);
3260         CDiskBlockPos blockPos;
3261         if (dbp != NULL)
3262             blockPos = *dbp;
3263         if (!FindBlockPos(state, blockPos, nBlockSize+8, nHeight, block.GetBlockTime(), dbp != NULL))
3264             return error("AcceptBlock(): FindBlockPos failed");
3265         if (dbp == NULL)
3266             if (!WriteBlockToDisk(block, blockPos, chainparams.MessageStart()))
3267                 AbortNode(state, "Failed to write block");
3268         if (!ReceivedBlockTransactions(block, state, pindex, blockPos))
3269             return error("AcceptBlock(): ReceivedBlockTransactions failed");
3270     } catch (const std::runtime_error& e) {
3271         return AbortNode(state, std::string("System error: ") + e.what());
3272     }
3273
3274     if (fCheckForPruning)
3275         FlushStateToDisk(state, FLUSH_STATE_NONE); // we just allocated more disk space for block files
3276
3277     return true;
3278 }
3279
3280 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart, unsigned nRequired, const Consensus::Params& consensusParams)
3281 {
3282     unsigned int nFound = 0;
3283     for (int i = 0; i < consensusParams.nMajorityWindow && nFound < nRequired && pstart != NULL; i++)
3284     {
3285         if (pstart->nVersion >= minVersion)
3286             ++nFound;
3287         pstart = pstart->pprev;
3288     }
3289     return (nFound >= nRequired);
3290 }
3291
3292
3293 bool ProcessNewBlock(CValidationState &state, CNode* pfrom, CBlock* pblock, bool fForceProcessing, CDiskBlockPos *dbp)
3294 {
3295     // Preliminary checks
3296     bool checked = CheckBlock(komodo_block2height(pblock),0,*pblock, state);
3297
3298     {
3299         LOCK(cs_main);
3300         bool fRequested = MarkBlockAsReceived(pblock->GetHash());
3301         fRequested |= fForceProcessing;
3302         if (!checked) {
3303             return error("%s: CheckBlock FAILED", __func__);
3304         }
3305
3306         // Store to disk
3307         CBlockIndex *pindex = NULL;
3308         bool ret = AcceptBlock(*pblock, state, &pindex, fRequested, dbp);
3309         if (pindex && pfrom) {
3310             mapBlockSource[pindex->GetBlockHash()] = pfrom->GetId();
3311         }
3312         CheckBlockIndex();
3313         if (!ret)
3314             return error("%s: AcceptBlock FAILED", __func__);
3315     }
3316
3317     if (!ActivateBestChain(state, pblock))
3318         return error("%s: ActivateBestChain failed", __func__);
3319
3320     return true;
3321 }
3322
3323 bool TestBlockValidity(CValidationState &state, const CBlock& block, CBlockIndex * const pindexPrev, bool fCheckPOW, bool fCheckMerkleRoot)
3324 {
3325     AssertLockHeld(cs_main);
3326     assert(pindexPrev == chainActive.Tip());
3327
3328     CCoinsViewCache viewNew(pcoinsTip);
3329     CBlockIndex indexDummy(block);
3330     indexDummy.pprev = pindexPrev;
3331     indexDummy.nHeight = pindexPrev->nHeight + 1;
3332
3333     // NOTE: CheckBlockHeader is called by CheckBlock
3334     if (!ContextualCheckBlockHeader(block, state, pindexPrev))
3335         return false;
3336     if (!CheckBlock(indexDummy.nHeight,0,block, state, fCheckPOW, fCheckMerkleRoot))
3337         return false;
3338     if (!ContextualCheckBlock(block, state, pindexPrev))
3339         return false;
3340     if (!ConnectBlock(block, state, &indexDummy, viewNew, true))
3341         return false;
3342     assert(state.IsValid());
3343
3344     return true;
3345 }
3346
3347 /**
3348  * BLOCK PRUNING CODE
3349  */
3350
3351 /* Calculate the amount of disk space the block & undo files currently use */
3352 uint64_t CalculateCurrentUsage()
3353 {
3354     uint64_t retval = 0;
3355     BOOST_FOREACH(const CBlockFileInfo &file, vinfoBlockFile) {
3356         retval += file.nSize + file.nUndoSize;
3357     }
3358     return retval;
3359 }
3360
3361 /* Prune a block file (modify associated database entries)*/
3362 void PruneOneBlockFile(const int fileNumber)
3363 {
3364     for (BlockMap::iterator it = mapBlockIndex.begin(); it != mapBlockIndex.end(); ++it) {
3365         CBlockIndex* pindex = it->second;
3366         if (pindex->nFile == fileNumber) {
3367             pindex->nStatus &= ~BLOCK_HAVE_DATA;
3368             pindex->nStatus &= ~BLOCK_HAVE_UNDO;
3369             pindex->nFile = 0;
3370             pindex->nDataPos = 0;
3371             pindex->nUndoPos = 0;
3372             setDirtyBlockIndex.insert(pindex);
3373
3374             // Prune from mapBlocksUnlinked -- any block we prune would have
3375             // to be downloaded again in order to consider its chain, at which
3376             // point it would be considered as a candidate for
3377             // mapBlocksUnlinked or setBlockIndexCandidates.
3378             std::pair<std::multimap<CBlockIndex*, CBlockIndex*>::iterator, std::multimap<CBlockIndex*, CBlockIndex*>::iterator> range = mapBlocksUnlinked.equal_range(pindex->pprev);
3379             while (range.first != range.second) {
3380                 std::multimap<CBlockIndex *, CBlockIndex *>::iterator it = range.first;
3381                 range.first++;
3382                 if (it->second == pindex) {
3383                     mapBlocksUnlinked.erase(it);
3384                 }
3385             }
3386         }
3387     }
3388
3389     vinfoBlockFile[fileNumber].SetNull();
3390     setDirtyFileInfo.insert(fileNumber);
3391 }
3392
3393
3394 void UnlinkPrunedFiles(std::set<int>& setFilesToPrune)
3395 {
3396     for (set<int>::iterator it = setFilesToPrune.begin(); it != setFilesToPrune.end(); ++it) {
3397         CDiskBlockPos pos(*it, 0);
3398         boost::filesystem::remove(GetBlockPosFilename(pos, "blk"));
3399         boost::filesystem::remove(GetBlockPosFilename(pos, "rev"));
3400         LogPrintf("Prune: %s deleted blk/rev (%05u)\n", __func__, *it);
3401     }
3402 }
3403
3404 /* Calculate the block/rev files that should be deleted to remain under target*/
3405 void FindFilesToPrune(std::set<int>& setFilesToPrune)
3406 {
3407     LOCK2(cs_main, cs_LastBlockFile);
3408     if (chainActive.Tip() == NULL || nPruneTarget == 0) {
3409         return;
3410     }
3411     if (chainActive.Tip()->nHeight <= Params().PruneAfterHeight()) {
3412         return;
3413     }
3414
3415     unsigned int nLastBlockWeCanPrune = chainActive.Tip()->nHeight - MIN_BLOCKS_TO_KEEP;
3416     uint64_t nCurrentUsage = CalculateCurrentUsage();
3417     // We don't check to prune until after we've allocated new space for files
3418     // So we should leave a buffer under our target to account for another allocation
3419     // before the next pruning.
3420     uint64_t nBuffer = BLOCKFILE_CHUNK_SIZE + UNDOFILE_CHUNK_SIZE;
3421     uint64_t nBytesToPrune;
3422     int count=0;
3423
3424     if (nCurrentUsage + nBuffer >= nPruneTarget) {
3425         for (int fileNumber = 0; fileNumber < nLastBlockFile; fileNumber++) {
3426             nBytesToPrune = vinfoBlockFile[fileNumber].nSize + vinfoBlockFile[fileNumber].nUndoSize;
3427
3428             if (vinfoBlockFile[fileNumber].nSize == 0)
3429                 continue;
3430
3431             if (nCurrentUsage + nBuffer < nPruneTarget)  // are we below our target?
3432                 break;
3433
3434             // don't prune files that could have a block within MIN_BLOCKS_TO_KEEP of the main chain's tip but keep scanning
3435             if (vinfoBlockFile[fileNumber].nHeightLast > nLastBlockWeCanPrune)
3436                 continue;
3437
3438             PruneOneBlockFile(fileNumber);
3439             // Queue up the files for removal
3440             setFilesToPrune.insert(fileNumber);
3441             nCurrentUsage -= nBytesToPrune;
3442             count++;
3443         }
3444     }
3445
3446     LogPrint("prune", "Prune: target=%dMiB actual=%dMiB diff=%dMiB max_prune_height=%d removed %d blk/rev pairs\n",
3447            nPruneTarget/1024/1024, nCurrentUsage/1024/1024,
3448            ((int64_t)nPruneTarget - (int64_t)nCurrentUsage)/1024/1024,
3449            nLastBlockWeCanPrune, count);
3450 }
3451
3452 bool CheckDiskSpace(uint64_t nAdditionalBytes)
3453 {
3454     uint64_t nFreeBytesAvailable = boost::filesystem::space(GetDataDir()).available;
3455
3456     // Check for nMinDiskSpace bytes (currently 50MB)
3457     if (nFreeBytesAvailable < nMinDiskSpace + nAdditionalBytes)
3458         return AbortNode("Disk space is low!", _("Error: Disk space is low!"));
3459
3460     return true;
3461 }
3462
3463 FILE* OpenDiskFile(const CDiskBlockPos &pos, const char *prefix, bool fReadOnly)
3464 {
3465     if (pos.IsNull())
3466         return NULL;
3467     boost::filesystem::path path = GetBlockPosFilename(pos, prefix);
3468     boost::filesystem::create_directories(path.parent_path());
3469     FILE* file = fopen(path.string().c_str(), "rb+");
3470     if (!file && !fReadOnly)
3471         file = fopen(path.string().c_str(), "wb+");
3472     if (!file) {
3473         LogPrintf("Unable to open file %s\n", path.string());
3474         return NULL;
3475     }
3476     if (pos.nPos) {
3477         if (fseek(file, pos.nPos, SEEK_SET)) {
3478             LogPrintf("Unable to seek to position %u of %s\n", pos.nPos, path.string());
3479             fclose(file);
3480             return NULL;
3481         }
3482     }
3483     return file;
3484 }
3485
3486 FILE* OpenBlockFile(const CDiskBlockPos &pos, bool fReadOnly) {
3487     return OpenDiskFile(pos, "blk", fReadOnly);
3488 }
3489
3490 FILE* OpenUndoFile(const CDiskBlockPos &pos, bool fReadOnly) {
3491     return OpenDiskFile(pos, "rev", fReadOnly);
3492 }
3493
3494 boost::filesystem::path GetBlockPosFilename(const CDiskBlockPos &pos, const char *prefix)
3495 {
3496     return GetDataDir() / "blocks" / strprintf("%s%05u.dat", prefix, pos.nFile);
3497 }
3498
3499 CBlockIndex * InsertBlockIndex(uint256 hash)
3500 {
3501     if (hash.IsNull())
3502         return NULL;
3503
3504     // Return existing
3505     BlockMap::iterator mi = mapBlockIndex.find(hash);
3506     if (mi != mapBlockIndex.end())
3507         return (*mi).second;
3508
3509     // Create new
3510     CBlockIndex* pindexNew = new CBlockIndex();
3511     if (!pindexNew)
3512         throw runtime_error("LoadBlockIndex(): new CBlockIndex failed");
3513     mi = mapBlockIndex.insert(make_pair(hash, pindexNew)).first;
3514     pindexNew->phashBlock = &((*mi).first);
3515
3516     return pindexNew;
3517 }
3518
3519 bool static LoadBlockIndexDB()
3520 {
3521     const CChainParams& chainparams = Params();
3522     if (!pblocktree->LoadBlockIndexGuts())
3523         return false;
3524
3525     boost::this_thread::interruption_point();
3526
3527     // Calculate nChainWork
3528     vector<pair<int, CBlockIndex*> > vSortedByHeight;
3529     vSortedByHeight.reserve(mapBlockIndex.size());
3530     BOOST_FOREACH(const PAIRTYPE(uint256, CBlockIndex*)& item, mapBlockIndex)
3531     {
3532         CBlockIndex* pindex = item.second;
3533         vSortedByHeight.push_back(make_pair(pindex->nHeight, pindex));
3534     }
3535     sort(vSortedByHeight.begin(), vSortedByHeight.end());
3536     BOOST_FOREACH(const PAIRTYPE(int, CBlockIndex*)& item, vSortedByHeight)
3537     {
3538         CBlockIndex* pindex = item.second;
3539         pindex->nChainWork = (pindex->pprev ? pindex->pprev->nChainWork : 0) + GetBlockProof(*pindex);
3540         // We can link the chain of blocks for which we've received transactions at some point.
3541         // Pruned nodes may have deleted the block.
3542         if (pindex->nTx > 0) {
3543             if (pindex->pprev) {
3544                 if (pindex->pprev->nChainTx) {
3545                     pindex->nChainTx = pindex->pprev->nChainTx + pindex->nTx;
3546                 } else {
3547                     pindex->nChainTx = 0;
3548                     mapBlocksUnlinked.insert(std::make_pair(pindex->pprev, pindex));
3549                 }
3550             } else {
3551                 pindex->nChainTx = pindex->nTx;
3552             }
3553         }
3554         if (pindex->IsValid(BLOCK_VALID_TRANSACTIONS) && (pindex->nChainTx || pindex->pprev == NULL))
3555             setBlockIndexCandidates.insert(pindex);
3556         if (pindex->nStatus & BLOCK_FAILED_MASK && (!pindexBestInvalid || pindex->nChainWork > pindexBestInvalid->nChainWork))
3557             pindexBestInvalid = pindex;
3558         if (pindex->pprev)
3559             pindex->BuildSkip();
3560         if (pindex->IsValid(BLOCK_VALID_TREE) && (pindexBestHeader == NULL || CBlockIndexWorkComparator()(pindexBestHeader, pindex)))
3561             pindexBestHeader = pindex;
3562     }
3563
3564     // Load block file info
3565     pblocktree->ReadLastBlockFile(nLastBlockFile);
3566     vinfoBlockFile.resize(nLastBlockFile + 1);
3567     LogPrintf("%s: last block file = %i\n", __func__, nLastBlockFile);
3568     for (int nFile = 0; nFile <= nLastBlockFile; nFile++) {
3569         pblocktree->ReadBlockFileInfo(nFile, vinfoBlockFile[nFile]);
3570     }
3571     LogPrintf("%s: last block file info: %s\n", __func__, vinfoBlockFile[nLastBlockFile].ToString());
3572     for (int nFile = nLastBlockFile + 1; true; nFile++) {
3573         CBlockFileInfo info;
3574         if (pblocktree->ReadBlockFileInfo(nFile, info)) {
3575             vinfoBlockFile.push_back(info);
3576         } else {
3577             break;
3578         }
3579     }
3580
3581     // Check presence of blk files
3582     LogPrintf("Checking all blk files are present...\n");
3583     set<int> setBlkDataFiles;
3584     BOOST_FOREACH(const PAIRTYPE(uint256, CBlockIndex*)& item, mapBlockIndex)
3585     {
3586         CBlockIndex* pindex = item.second;
3587         if (pindex->nStatus & BLOCK_HAVE_DATA) {
3588             setBlkDataFiles.insert(pindex->nFile);
3589         }
3590     }
3591     for (std::set<int>::iterator it = setBlkDataFiles.begin(); it != setBlkDataFiles.end(); it++)
3592     {
3593         CDiskBlockPos pos(*it, 0);
3594         if (CAutoFile(OpenBlockFile(pos, true), SER_DISK, CLIENT_VERSION).IsNull()) {
3595             return false;
3596         }
3597     }
3598
3599     // Check whether we have ever pruned block & undo files
3600     pblocktree->ReadFlag("prunedblockfiles", fHavePruned);
3601     if (fHavePruned)
3602         LogPrintf("LoadBlockIndexDB(): Block files have previously been pruned\n");
3603
3604     // Check whether we need to continue reindexing
3605     bool fReindexing = false;
3606     pblocktree->ReadReindexing(fReindexing);
3607     fReindex |= fReindexing;
3608
3609     // Check whether we have a transaction index
3610     pblocktree->ReadFlag("txindex", fTxIndex);
3611     LogPrintf("%s: transaction index %s\n", __func__, fTxIndex ? "enabled" : "disabled");
3612
3613     // Load pointer to end of best chain
3614     BlockMap::iterator it = mapBlockIndex.find(pcoinsTip->GetBestBlock());
3615     if (it == mapBlockIndex.end())
3616         return true;
3617     chainActive.SetTip(it->second);
3618
3619     PruneBlockIndexCandidates();
3620
3621     LogPrintf("%s: hashBestChain=%s height=%d date=%s progress=%f\n", __func__,
3622         chainActive.Tip()->GetBlockHash().ToString(), chainActive.Height(),
3623         DateTimeStrFormat("%Y-%m-%d %H:%M:%S", chainActive.Tip()->GetBlockTime()),
3624         Checkpoints::GuessVerificationProgress(chainparams.Checkpoints(), chainActive.Tip()));
3625
3626     return true;
3627 }
3628
3629 CVerifyDB::CVerifyDB()
3630 {
3631     uiInterface.ShowProgress(_("Verifying blocks..."), 0);
3632 }
3633
3634 CVerifyDB::~CVerifyDB()
3635 {
3636     uiInterface.ShowProgress("", 100);
3637 }
3638
3639 bool CVerifyDB::VerifyDB(CCoinsView *coinsview, int nCheckLevel, int nCheckDepth)
3640 {
3641     LOCK(cs_main);
3642     if (chainActive.Tip() == NULL || chainActive.Tip()->pprev == NULL)
3643         return true;
3644
3645     // Verify blocks in the best chain
3646     if (nCheckDepth <= 0)
3647         nCheckDepth = 1000000000; // suffices until the year 19000
3648     if (nCheckDepth > chainActive.Height())
3649         nCheckDepth = chainActive.Height();
3650     nCheckLevel = std::max(0, std::min(4, nCheckLevel));
3651     LogPrintf("Verifying last %i blocks at level %i\n", nCheckDepth, nCheckLevel);
3652     CCoinsViewCache coins(coinsview);
3653     CBlockIndex* pindexState = chainActive.Tip();
3654     CBlockIndex* pindexFailure = NULL;
3655     int nGoodTransactions = 0;
3656     CValidationState state;
3657     for (CBlockIndex* pindex = chainActive.Tip(); pindex && pindex->pprev; pindex = pindex->pprev)
3658     {
3659         boost::this_thread::interruption_point();
3660         uiInterface.ShowProgress(_("Verifying blocks..."), std::max(1, std::min(99, (int)(((double)(chainActive.Height() - pindex->nHeight)) / (double)nCheckDepth * (nCheckLevel >= 4 ? 50 : 100)))));
3661         if (pindex->nHeight < chainActive.Height()-nCheckDepth)
3662             break;
3663         CBlock block;
3664         // check level 0: read from disk
3665         if (!ReadBlockFromDisk(block, pindex))
3666             return error("VerifyDB(): *** ReadBlockFromDisk failed at %d, hash=%s", pindex->nHeight, pindex->GetBlockHash().ToString());
3667         // check level 1: verify block validity
3668         if (nCheckLevel >= 1 && !CheckBlock(pindex->nHeight,pindex,block, state))
3669             return error("VerifyDB(): *** found bad block at %d, hash=%s\n", pindex->nHeight, pindex->GetBlockHash().ToString());
3670         // check level 2: verify undo validity
3671         if (nCheckLevel >= 2 && pindex) {
3672             CBlockUndo undo;
3673             CDiskBlockPos pos = pindex->GetUndoPos();
3674             if (!pos.IsNull()) {
3675                 if (!UndoReadFromDisk(undo, pos, pindex->pprev->GetBlockHash()))
3676                     return error("VerifyDB(): *** found bad undo data at %d, hash=%s\n", pindex->nHeight, pindex->GetBlockHash().ToString());
3677             }
3678         }
3679         // check level 3: check for inconsistencies during memory-only disconnect of tip blocks
3680         if (nCheckLevel >= 3 && pindex == pindexState && (coins.DynamicMemoryUsage() + pcoinsTip->DynamicMemoryUsage()) <= nCoinCacheUsage) {
3681             bool fClean = true;
3682             if (!DisconnectBlock(block, state, pindex, coins, &fClean))
3683                 return error("VerifyDB(): *** irrecoverable inconsistency in block data at %d, hash=%s", pindex->nHeight, pindex->GetBlockHash().ToString());
3684             pindexState = pindex->pprev;
3685             if (!fClean) {
3686                 nGoodTransactions = 0;
3687                 pindexFailure = pindex;
3688             } else
3689                 nGoodTransactions += block.vtx.size();
3690         }
3691         if (ShutdownRequested())
3692             return true;
3693     }
3694     if (pindexFailure)
3695         return error("VerifyDB(): *** coin database inconsistencies found (last %i blocks, %i good transactions before that)\n", chainActive.Height() - pindexFailure->nHeight + 1, nGoodTransactions);
3696
3697     // check level 4: try reconnecting blocks
3698     if (nCheckLevel >= 4) {
3699         CBlockIndex *pindex = pindexState;
3700         while (pindex != chainActive.Tip()) {
3701             boost::this_thread::interruption_point();
3702             uiInterface.ShowProgress(_("Verifying blocks..."), std::max(1, std::min(99, 100 - (int)(((double)(chainActive.Height() - pindex->nHeight)) / (double)nCheckDepth * 50))));
3703             pindex = chainActive.Next(pindex);
3704             CBlock block;
3705             if (!ReadBlockFromDisk(block, pindex))
3706                 return error("VerifyDB(): *** ReadBlockFromDisk failed at %d, hash=%s", pindex->nHeight, pindex->GetBlockHash().ToString());
3707             if (!ConnectBlock(block, state, pindex, coins))
3708                 return error("VerifyDB(): *** found unconnectable block at %d, hash=%s", pindex->nHeight, pindex->GetBlockHash().ToString());
3709         }
3710     }
3711
3712     LogPrintf("No coin database inconsistencies in last %i blocks (%i transactions)\n", chainActive.Height() - pindexState->nHeight, nGoodTransactions);
3713
3714     return true;
3715 }
3716
3717 void UnloadBlockIndex()
3718 {
3719     LOCK(cs_main);
3720     setBlockIndexCandidates.clear();
3721     chainActive.SetTip(NULL);
3722     pindexBestInvalid = NULL;
3723     pindexBestHeader = NULL;
3724     mempool.clear();
3725     mapOrphanTransactions.clear();
3726     mapOrphanTransactionsByPrev.clear();
3727     nSyncStarted = 0;
3728     mapBlocksUnlinked.clear();
3729     vinfoBlockFile.clear();
3730     nLastBlockFile = 0;
3731     nBlockSequenceId = 1;
3732     mapBlockSource.clear();
3733     mapBlocksInFlight.clear();
3734     nQueuedValidatedHeaders = 0;
3735     nPreferredDownload = 0;
3736     setDirtyBlockIndex.clear();
3737     setDirtyFileInfo.clear();
3738     mapNodeState.clear();
3739     recentRejects.reset(NULL);
3740
3741     BOOST_FOREACH(BlockMap::value_type& entry, mapBlockIndex) {
3742         delete entry.second;
3743     }
3744     mapBlockIndex.clear();
3745     fHavePruned = false;
3746 }
3747
3748 bool LoadBlockIndex()
3749 {
3750     // Load block index from databases
3751     if (!fReindex && !LoadBlockIndexDB())
3752         return false;
3753     return true;
3754 }
3755
3756
3757 bool InitBlockIndex() {
3758     const CChainParams& chainparams = Params();
3759     LOCK(cs_main);
3760
3761     // Initialize global variables that cannot be constructed at startup.
3762     recentRejects.reset(new CRollingBloomFilter(120000, 0.000001));
3763
3764     // Check whether we're already initialized
3765     if (chainActive.Genesis() != NULL)
3766         return true;
3767
3768     // Use the provided setting for -txindex in the new database
3769     fTxIndex = GetBoolArg("-txindex", false);
3770     pblocktree->WriteFlag("txindex", fTxIndex);
3771     LogPrintf("Initializing databases...\n");
3772
3773     // Only add the genesis block if not reindexing (in which case we reuse the one already on disk)
3774     if (!fReindex) {
3775         try {
3776             CBlock &block = const_cast<CBlock&>(Params().GenesisBlock());
3777             // Start new block file
3778             unsigned int nBlockSize = ::GetSerializeSize(block, SER_DISK, CLIENT_VERSION);
3779             CDiskBlockPos blockPos;
3780             CValidationState state;
3781             if (!FindBlockPos(state, blockPos, nBlockSize+8, 0, block.GetBlockTime()))
3782                 return error("LoadBlockIndex(): FindBlockPos failed");
3783             if (!WriteBlockToDisk(block, blockPos, chainparams.MessageStart()))
3784                 return error("LoadBlockIndex(): writing genesis block to disk failed");
3785             CBlockIndex *pindex = AddToBlockIndex(block);
3786             if (!ReceivedBlockTransactions(block, state, pindex, blockPos))
3787                 return error("LoadBlockIndex(): genesis block not accepted");
3788             if (!ActivateBestChain(state, &block))
3789                 return error("LoadBlockIndex(): genesis block cannot be activated");
3790             // Force a chainstate write so that when we VerifyDB in a moment, it doesn't check stale data
3791             return FlushStateToDisk(state, FLUSH_STATE_ALWAYS);
3792         } catch (const std::runtime_error& e) {
3793             return error("LoadBlockIndex(): failed to initialize block database: %s", e.what());
3794         }
3795     }
3796
3797     return true;
3798 }
3799
3800
3801
3802 bool LoadExternalBlockFile(FILE* fileIn, CDiskBlockPos *dbp)
3803 {
3804     const CChainParams& chainparams = Params();
3805     // Map of disk positions for blocks with unknown parent (only used for reindex)
3806     static std::multimap<uint256, CDiskBlockPos> mapBlocksUnknownParent;
3807     int64_t nStart = GetTimeMillis();
3808
3809     int nLoaded = 0;
3810     try {
3811         // This takes over fileIn and calls fclose() on it in the CBufferedFile destructor
3812         CBufferedFile blkdat(fileIn, 2*MAX_BLOCK_SIZE, MAX_BLOCK_SIZE+8, SER_DISK, CLIENT_VERSION);
3813         uint64_t nRewind = blkdat.GetPos();
3814         while (!blkdat.eof()) {
3815             boost::this_thread::interruption_point();
3816
3817             blkdat.SetPos(nRewind);
3818             nRewind++; // start one byte further next time, in case of failure
3819             blkdat.SetLimit(); // remove former limit
3820             unsigned int nSize = 0;
3821             try {
3822                 // locate a header
3823                 unsigned char buf[MESSAGE_START_SIZE];
3824                 blkdat.FindByte(Params().MessageStart()[0]);
3825                 nRewind = blkdat.GetPos()+1;
3826                 blkdat >> FLATDATA(buf);
3827                 if (memcmp(buf, Params().MessageStart(), MESSAGE_START_SIZE))
3828                     continue;
3829                 // read size
3830                 blkdat >> nSize;
3831                 if (nSize < 80 || nSize > MAX_BLOCK_SIZE)
3832                     continue;
3833             } catch (const std::exception&) {
3834                 // no valid block header found; don't complain
3835                 break;
3836             }
3837             try {
3838                 // read block
3839                 uint64_t nBlockPos = blkdat.GetPos();
3840                 if (dbp)
3841                     dbp->nPos = nBlockPos;
3842                 blkdat.SetLimit(nBlockPos + nSize);
3843                 blkdat.SetPos(nBlockPos);
3844                 CBlock block;
3845                 blkdat >> block;
3846                 nRewind = blkdat.GetPos();
3847
3848                 // detect out of order blocks, and store them for later
3849                 uint256 hash = block.GetHash();
3850                 if (hash != chainparams.GetConsensus().hashGenesisBlock && mapBlockIndex.find(block.hashPrevBlock) == mapBlockIndex.end()) {
3851                     LogPrint("reindex", "%s: Out of order block %s, parent %s not known\n", __func__, hash.ToString(),
3852                             block.hashPrevBlock.ToString());
3853                     if (dbp)
3854                         mapBlocksUnknownParent.insert(std::make_pair(block.hashPrevBlock, *dbp));
3855                     continue;
3856                 }
3857
3858                 // process in case the block isn't known yet
3859                 if (mapBlockIndex.count(hash) == 0 || (mapBlockIndex[hash]->nStatus & BLOCK_HAVE_DATA) == 0) {
3860                     CValidationState state;
3861                     if (ProcessNewBlock(state, NULL, &block, true, dbp))
3862                         nLoaded++;
3863                     if (state.IsError())
3864                         break;
3865                 } else if (hash != chainparams.GetConsensus().hashGenesisBlock && mapBlockIndex[hash]->nHeight % 1000 == 0) {
3866                     LogPrintf("Block Import: already had block %s at height %d\n", hash.ToString(), mapBlockIndex[hash]->nHeight);
3867                 }
3868
3869                 // Recursively process earlier encountered successors of this block
3870                 deque<uint256> queue;
3871                 queue.push_back(hash);
3872                 while (!queue.empty()) {
3873                     uint256 head = queue.front();
3874                     queue.pop_front();
3875                     std::pair<std::multimap<uint256, CDiskBlockPos>::iterator, std::multimap<uint256, CDiskBlockPos>::iterator> range = mapBlocksUnknownParent.equal_range(head);
3876                     while (range.first != range.second) {
3877                         std::multimap<uint256, CDiskBlockPos>::iterator it = range.first;
3878                         if (ReadBlockFromDisk(mapBlockIndex[hash]!=0?mapBlockIndex[hash]->nHeight:0,block, it->second))
3879                         {
3880                             LogPrintf("%s: Processing out of order child %s of %s\n", __func__, block.GetHash().ToString(),
3881                                     head.ToString());
3882                             CValidationState dummy;
3883                             if (ProcessNewBlock(dummy, NULL, &block, true, &it->second))
3884                             {
3885                                 nLoaded++;
3886                                 queue.push_back(block.GetHash());
3887                             }
3888                         }
3889                         range.first++;
3890                         mapBlocksUnknownParent.erase(it);
3891                     }
3892                 }
3893             } catch (const std::exception& e) {
3894                 LogPrintf("%s: Deserialize or I/O error - %s\n", __func__, e.what());
3895             }
3896         }
3897     } catch (const std::runtime_error& e) {
3898         AbortNode(std::string("System error: ") + e.what());
3899     }
3900     if (nLoaded > 0)
3901         LogPrintf("Loaded %i blocks from external file in %dms\n", nLoaded, GetTimeMillis() - nStart);
3902     return nLoaded > 0;
3903 }
3904
3905 void static CheckBlockIndex()
3906 {
3907     const Consensus::Params& consensusParams = Params().GetConsensus();
3908     if (!fCheckBlockIndex) {
3909         return;
3910     }
3911
3912     LOCK(cs_main);
3913
3914     // During a reindex, we read the genesis block and call CheckBlockIndex before ActivateBestChain,
3915     // so we have the genesis block in mapBlockIndex but no active chain.  (A few of the tests when
3916     // iterating the block tree require that chainActive has been initialized.)
3917     if (chainActive.Height() < 0) {
3918         assert(mapBlockIndex.size() <= 1);
3919         return;
3920     }
3921
3922     // Build forward-pointing map of the entire block tree.
3923     std::multimap<CBlockIndex*,CBlockIndex*> forward;
3924     for (BlockMap::iterator it = mapBlockIndex.begin(); it != mapBlockIndex.end(); it++) {
3925         forward.insert(std::make_pair(it->second->pprev, it->second));
3926     }
3927
3928     assert(forward.size() == mapBlockIndex.size());
3929
3930     std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> rangeGenesis = forward.equal_range(NULL);
3931     CBlockIndex *pindex = rangeGenesis.first->second;
3932     rangeGenesis.first++;
3933     assert(rangeGenesis.first == rangeGenesis.second); // There is only one index entry with parent NULL.
3934
3935     // Iterate over the entire block tree, using depth-first search.
3936     // Along the way, remember whether there are blocks on the path from genesis
3937     // block being explored which are the first to have certain properties.
3938     size_t nNodes = 0;
3939     int nHeight = 0;
3940     CBlockIndex* pindexFirstInvalid = NULL; // Oldest ancestor of pindex which is invalid.
3941     CBlockIndex* pindexFirstMissing = NULL; // Oldest ancestor of pindex which does not have BLOCK_HAVE_DATA.
3942     CBlockIndex* pindexFirstNeverProcessed = NULL; // Oldest ancestor of pindex for which nTx == 0.
3943     CBlockIndex* pindexFirstNotTreeValid = NULL; // Oldest ancestor of pindex which does not have BLOCK_VALID_TREE (regardless of being valid or not).
3944     CBlockIndex* pindexFirstNotTransactionsValid = NULL; // Oldest ancestor of pindex which does not have BLOCK_VALID_TRANSACTIONS (regardless of being valid or not).
3945     CBlockIndex* pindexFirstNotChainValid = NULL; // Oldest ancestor of pindex which does not have BLOCK_VALID_CHAIN (regardless of being valid or not).
3946     CBlockIndex* pindexFirstNotScriptsValid = NULL; // Oldest ancestor of pindex which does not have BLOCK_VALID_SCRIPTS (regardless of being valid or not).
3947     while (pindex != NULL) {
3948         nNodes++;
3949         if (pindexFirstInvalid == NULL && pindex->nStatus & BLOCK_FAILED_VALID) pindexFirstInvalid = pindex;
3950         if (pindexFirstMissing == NULL && !(pindex->nStatus & BLOCK_HAVE_DATA)) pindexFirstMissing = pindex;
3951         if (pindexFirstNeverProcessed == NULL && pindex->nTx == 0) pindexFirstNeverProcessed = pindex;
3952         if (pindex->pprev != NULL && pindexFirstNotTreeValid == NULL && (pindex->nStatus & BLOCK_VALID_MASK) < BLOCK_VALID_TREE) pindexFirstNotTreeValid = pindex;
3953         if (pindex->pprev != NULL && pindexFirstNotTransactionsValid == NULL && (pindex->nStatus & BLOCK_VALID_MASK) < BLOCK_VALID_TRANSACTIONS) pindexFirstNotTransactionsValid = pindex;
3954         if (pindex->pprev != NULL && pindexFirstNotChainValid == NULL && (pindex->nStatus & BLOCK_VALID_MASK) < BLOCK_VALID_CHAIN) pindexFirstNotChainValid = pindex;
3955         if (pindex->pprev != NULL && pindexFirstNotScriptsValid == NULL && (pindex->nStatus & BLOCK_VALID_MASK) < BLOCK_VALID_SCRIPTS) pindexFirstNotScriptsValid = pindex;
3956
3957         // Begin: actual consistency checks.
3958         if (pindex->pprev == NULL) {
3959             // Genesis block checks.
3960             assert(pindex->GetBlockHash() == consensusParams.hashGenesisBlock); // Genesis block's hash must match.
3961             assert(pindex == chainActive.Genesis()); // The current active chain's genesis block must be this block.
3962         }
3963         if (pindex->nChainTx == 0) assert(pindex->nSequenceId == 0);  // nSequenceId can't be set for blocks that aren't linked
3964         // VALID_TRANSACTIONS is equivalent to nTx > 0 for all nodes (whether or not pruning has occurred).
3965         // HAVE_DATA is only equivalent to nTx > 0 (or VALID_TRANSACTIONS) if no pruning has occurred.
3966         if (!fHavePruned) {
3967             // If we've never pruned, then HAVE_DATA should be equivalent to nTx > 0
3968             assert(!(pindex->nStatus & BLOCK_HAVE_DATA) == (pindex->nTx == 0));
3969             assert(pindexFirstMissing == pindexFirstNeverProcessed);
3970         } else {
3971             // If we have pruned, then we can only say that HAVE_DATA implies nTx > 0
3972             if (pindex->nStatus & BLOCK_HAVE_DATA) assert(pindex->nTx > 0);
3973         }
3974         if (pindex->nStatus & BLOCK_HAVE_UNDO) assert(pindex->nStatus & BLOCK_HAVE_DATA);
3975         assert(((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_TRANSACTIONS) == (pindex->nTx > 0)); // This is pruning-independent.
3976         // All parents having had data (at some point) is equivalent to all parents being VALID_TRANSACTIONS, which is equivalent to nChainTx being set.
3977         assert((pindexFirstNeverProcessed != NULL) == (pindex->nChainTx == 0)); // nChainTx != 0 is used to signal that all parent blocks have been processed (but may have been pruned).
3978         assert((pindexFirstNotTransactionsValid != NULL) == (pindex->nChainTx == 0));
3979         assert(pindex->nHeight == nHeight); // nHeight must be consistent.
3980         assert(pindex->pprev == NULL || pindex->nChainWork >= pindex->pprev->nChainWork); // For every block except the genesis block, the chainwork must be larger than the parent's.
3981         assert(nHeight < 2 || (pindex->pskip && (pindex->pskip->nHeight < nHeight))); // The pskip pointer must point back for all but the first 2 blocks.
3982         assert(pindexFirstNotTreeValid == NULL); // All mapBlockIndex entries must at least be TREE valid
3983         if ((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_TREE) assert(pindexFirstNotTreeValid == NULL); // TREE valid implies all parents are TREE valid
3984         if ((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_CHAIN) assert(pindexFirstNotChainValid == NULL); // CHAIN valid implies all parents are CHAIN valid
3985         if ((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_SCRIPTS) assert(pindexFirstNotScriptsValid == NULL); // SCRIPTS valid implies all parents are SCRIPTS valid
3986         if (pindexFirstInvalid == NULL) {
3987             // Checks for not-invalid blocks.
3988             assert((pindex->nStatus & BLOCK_FAILED_MASK) == 0); // The failed mask cannot be set for blocks without invalid parents.
3989         }
3990         if (!CBlockIndexWorkComparator()(pindex, chainActive.Tip()) && pindexFirstNeverProcessed == NULL) {
3991             if (pindexFirstInvalid == NULL) {
3992                 // If this block sorts at least as good as the current tip and
3993                 // is valid and we have all data for its parents, it must be in
3994                 // setBlockIndexCandidates.  chainActive.Tip() must also be there
3995                 // even if some data has been pruned.
3996                 if (pindexFirstMissing == NULL || pindex == chainActive.Tip()) {
3997                     assert(setBlockIndexCandidates.count(pindex));
3998                 }
3999                 // If some parent is missing, then it could be that this block was in
4000                 // setBlockIndexCandidates but had to be removed because of the missing data.
4001                 // In this case it must be in mapBlocksUnlinked -- see test below.
4002             }
4003         } else { // If this block sorts worse than the current tip or some ancestor's block has never been seen, it cannot be in setBlockIndexCandidates.
4004             assert(setBlockIndexCandidates.count(pindex) == 0);
4005         }
4006         // Check whether this block is in mapBlocksUnlinked.
4007         std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> rangeUnlinked = mapBlocksUnlinked.equal_range(pindex->pprev);
4008         bool foundInUnlinked = false;
4009         while (rangeUnlinked.first != rangeUnlinked.second) {
4010             assert(rangeUnlinked.first->first == pindex->pprev);
4011             if (rangeUnlinked.first->second == pindex) {
4012                 foundInUnlinked = true;
4013                 break;
4014             }
4015             rangeUnlinked.first++;
4016         }
4017         if (pindex->pprev && (pindex->nStatus & BLOCK_HAVE_DATA) && pindexFirstNeverProcessed != NULL && pindexFirstInvalid == NULL) {
4018             // If this block has block data available, some parent was never received, and has no invalid parents, it must be in mapBlocksUnlinked.
4019             assert(foundInUnlinked);
4020         }
4021         if (!(pindex->nStatus & BLOCK_HAVE_DATA)) assert(!foundInUnlinked); // Can't be in mapBlocksUnlinked if we don't HAVE_DATA
4022         if (pindexFirstMissing == NULL) assert(!foundInUnlinked); // We aren't missing data for any parent -- cannot be in mapBlocksUnlinked.
4023         if (pindex->pprev && (pindex->nStatus & BLOCK_HAVE_DATA) && pindexFirstNeverProcessed == NULL && pindexFirstMissing != NULL) {
4024             // We HAVE_DATA for this block, have received data for all parents at some point, but we're currently missing data for some parent.
4025             assert(fHavePruned); // We must have pruned.
4026             // This block may have entered mapBlocksUnlinked if:
4027             //  - it has a descendant that at some point had more work than the
4028             //    tip, and
4029             //  - we tried switching to that descendant but were missing
4030             //    data for some intermediate block between chainActive and the
4031             //    tip.
4032             // So if this block is itself better than chainActive.Tip() and it wasn't in
4033             // setBlockIndexCandidates, then it must be in mapBlocksUnlinked.
4034             if (!CBlockIndexWorkComparator()(pindex, chainActive.Tip()) && setBlockIndexCandidates.count(pindex) == 0) {
4035                 if (pindexFirstInvalid == NULL) {
4036                     assert(foundInUnlinked);
4037                 }
4038             }
4039         }
4040         // assert(pindex->GetBlockHash() == pindex->GetBlockHeader().GetHash()); // Perhaps too slow
4041         // End: actual consistency checks.
4042
4043         // Try descending into the first subnode.
4044         std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> range = forward.equal_range(pindex);
4045         if (range.first != range.second) {
4046             // A subnode was found.
4047             pindex = range.first->second;
4048             nHeight++;
4049             continue;
4050         }
4051         // This is a leaf node.
4052         // Move upwards until we reach a node of which we have not yet visited the last child.
4053         while (pindex) {
4054             // We are going to either move to a parent or a sibling of pindex.
4055             // If pindex was the first with a certain property, unset the corresponding variable.
4056             if (pindex == pindexFirstInvalid) pindexFirstInvalid = NULL;
4057             if (pindex == pindexFirstMissing) pindexFirstMissing = NULL;
4058             if (pindex == pindexFirstNeverProcessed) pindexFirstNeverProcessed = NULL;
4059             if (pindex == pindexFirstNotTreeValid) pindexFirstNotTreeValid = NULL;
4060             if (pindex == pindexFirstNotTransactionsValid) pindexFirstNotTransactionsValid = NULL;
4061             if (pindex == pindexFirstNotChainValid) pindexFirstNotChainValid = NULL;
4062             if (pindex == pindexFirstNotScriptsValid) pindexFirstNotScriptsValid = NULL;
4063             // Find our parent.
4064             CBlockIndex* pindexPar = pindex->pprev;
4065             // Find which child we just visited.
4066             std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> rangePar = forward.equal_range(pindexPar);
4067             while (rangePar.first->second != pindex) {
4068                 assert(rangePar.first != rangePar.second); // Our parent must have at least the node we're coming from as child.
4069                 rangePar.first++;
4070             }
4071             // Proceed to the next one.
4072             rangePar.first++;
4073             if (rangePar.first != rangePar.second) {
4074                 // Move to the sibling.
4075                 pindex = rangePar.first->second;
4076                 break;
4077             } else {
4078                 // Move up further.
4079                 pindex = pindexPar;
4080                 nHeight--;
4081                 continue;
4082             }
4083         }
4084     }
4085
4086     // Check that we actually traversed the entire map.
4087     assert(nNodes == forward.size());
4088 }
4089
4090 //////////////////////////////////////////////////////////////////////////////
4091 //
4092 // CAlert
4093 //
4094
4095 string GetWarnings(string strFor)
4096 {
4097     int nPriority = 0;
4098     string strStatusBar;
4099     string strRPC;
4100
4101     if (!CLIENT_VERSION_IS_RELEASE)
4102         strStatusBar = _("This is a pre-release test build - use at your own risk - do not use for mining or merchant applications");
4103
4104     if (GetBoolArg("-testsafemode", false))
4105         strStatusBar = strRPC = "testsafemode enabled";
4106
4107     // Misc warnings like out of disk space and clock is wrong
4108     if (strMiscWarning != "")
4109     {
4110         nPriority = 1000;
4111         strStatusBar = strMiscWarning;
4112     }
4113
4114     if (fLargeWorkForkFound)
4115     {
4116         nPriority = 2000;
4117         strStatusBar = strRPC = _("Warning: The network does not appear to fully agree! Some miners appear to be experiencing issues.");
4118     }
4119     else if (fLargeWorkInvalidChainFound)
4120     {
4121         nPriority = 2000;
4122         strStatusBar = strRPC = _("Warning: We do not appear to fully agree with our peers! You may need to upgrade, or other nodes may need to upgrade.");
4123     }
4124
4125     // Alerts
4126     {
4127         LOCK(cs_mapAlerts);
4128         BOOST_FOREACH(PAIRTYPE(const uint256, CAlert)& item, mapAlerts)
4129         {
4130             const CAlert& alert = item.second;
4131             if (alert.AppliesToMe() && alert.nPriority > nPriority)
4132             {
4133                 nPriority = alert.nPriority;
4134                 strStatusBar = alert.strStatusBar;
4135                 if (alert.nPriority >= ALERT_PRIORITY_SAFE_MODE) {
4136                     strRPC = alert.strRPCError;
4137                 }
4138             }
4139         }
4140     }
4141
4142     if (strFor == "statusbar")
4143         return strStatusBar;
4144     else if (strFor == "rpc")
4145         return strRPC;
4146     assert(!"GetWarnings(): invalid parameter");
4147     return "error";
4148 }
4149
4150
4151
4152
4153
4154
4155
4156
4157 //////////////////////////////////////////////////////////////////////////////
4158 //
4159 // Messages
4160 //
4161
4162
4163 bool static AlreadyHave(const CInv& inv)
4164 {
4165     switch (inv.type)
4166     {
4167     case MSG_TX:
4168         {
4169             assert(recentRejects);
4170             if (chainActive.Tip()->GetBlockHash() != hashRecentRejectsChainTip)
4171             {
4172                 // If the chain tip has changed previously rejected transactions
4173                 // might be now valid, e.g. due to a nLockTime'd tx becoming valid,
4174                 // or a double-spend. Reset the rejects filter and give those
4175                 // txs a second chance.
4176                 hashRecentRejectsChainTip = chainActive.Tip()->GetBlockHash();
4177                 recentRejects->reset();
4178             }
4179
4180             return recentRejects->contains(inv.hash) ||
4181                    mempool.exists(inv.hash) ||
4182                    mapOrphanTransactions.count(inv.hash) ||
4183                    pcoinsTip->HaveCoins(inv.hash);
4184         }
4185     case MSG_BLOCK:
4186         return mapBlockIndex.count(inv.hash);
4187     }
4188     // Don't know what it is, just say we already got one
4189     return true;
4190 }
4191
4192 void static ProcessGetData(CNode* pfrom)
4193 {
4194     std::deque<CInv>::iterator it = pfrom->vRecvGetData.begin();
4195
4196     vector<CInv> vNotFound;
4197
4198     LOCK(cs_main);
4199
4200     while (it != pfrom->vRecvGetData.end()) {
4201         // Don't bother if send buffer is too full to respond anyway
4202         if (pfrom->nSendSize >= SendBufferSize())
4203             break;
4204
4205         const CInv &inv = *it;
4206         {
4207             boost::this_thread::interruption_point();
4208             it++;
4209
4210             if (inv.type == MSG_BLOCK || inv.type == MSG_FILTERED_BLOCK)
4211             {
4212                 bool send = false;
4213                 BlockMap::iterator mi = mapBlockIndex.find(inv.hash);
4214                 if (mi != mapBlockIndex.end())
4215                 {
4216                     if (chainActive.Contains(mi->second)) {
4217                         send = true;
4218                     } else {
4219                         static const int nOneMonth = 30 * 24 * 60 * 60;
4220                         // To prevent fingerprinting attacks, only send blocks outside of the active
4221                         // chain if they are valid, and no more than a month older (both in time, and in
4222                         // best equivalent proof of work) than the best header chain we know about.
4223                         send = mi->second->IsValid(BLOCK_VALID_SCRIPTS) && (pindexBestHeader != NULL) &&
4224                             (pindexBestHeader->GetBlockTime() - mi->second->GetBlockTime() < nOneMonth) &&
4225                             (GetBlockProofEquivalentTime(*pindexBestHeader, *mi->second, *pindexBestHeader, Params().GetConsensus()) < nOneMonth);
4226                         if (!send) {
4227                             LogPrintf("%s: ignoring request from peer=%i for old block that isn't in the main chain\n", __func__, pfrom->GetId());
4228                         }
4229                     }
4230                 }
4231                 // Pruned nodes may have deleted the block, so check whether
4232                 // it's available before trying to send.
4233                 if (send && (mi->second->nStatus & BLOCK_HAVE_DATA))
4234                 {
4235                     // Send block from disk
4236                     CBlock block;
4237                     if (!ReadBlockFromDisk(block, (*mi).second))
4238                         assert(!"cannot load block from disk");
4239                     if (inv.type == MSG_BLOCK)
4240                         pfrom->PushMessage("block", block);
4241                     else // MSG_FILTERED_BLOCK)
4242                     {
4243                         LOCK(pfrom->cs_filter);
4244                         if (pfrom->pfilter)
4245                         {
4246                             CMerkleBlock merkleBlock(block, *pfrom->pfilter);
4247                             pfrom->PushMessage("merkleblock", merkleBlock);
4248                             // CMerkleBlock just contains hashes, so also push any transactions in the block the client did not see
4249                             // This avoids hurting performance by pointlessly requiring a round-trip
4250                             // Note that there is currently no way for a node to request any single transactions we didn't send here -
4251                             // they must either disconnect and retry or request the full block.
4252                             // Thus, the protocol spec specified allows for us to provide duplicate txn here,
4253                             // however we MUST always provide at least what the remote peer needs
4254                             typedef std::pair<unsigned int, uint256> PairType;
4255                             BOOST_FOREACH(PairType& pair, merkleBlock.vMatchedTxn)
4256                                 if (!pfrom->setInventoryKnown.count(CInv(MSG_TX, pair.second)))
4257                                     pfrom->PushMessage("tx", block.vtx[pair.first]);
4258                         }
4259                         // else
4260                             // no response
4261                     }
4262
4263                     // Trigger the peer node to send a getblocks request for the next batch of inventory
4264                     if (inv.hash == pfrom->hashContinue)
4265                     {
4266                         // Bypass PushInventory, this must send even if redundant,
4267                         // and we want it right after the last block so they don't
4268                         // wait for other stuff first.
4269                         vector<CInv> vInv;
4270                         vInv.push_back(CInv(MSG_BLOCK, chainActive.Tip()->GetBlockHash()));
4271                         pfrom->PushMessage("inv", vInv);
4272                         pfrom->hashContinue.SetNull();
4273                     }
4274                 }
4275             }
4276             else if (inv.IsKnownType())
4277             {
4278                 // Send stream from relay memory
4279                 bool pushed = false;
4280                 {
4281                     LOCK(cs_mapRelay);
4282                     map<CInv, CDataStream>::iterator mi = mapRelay.find(inv);
4283                     if (mi != mapRelay.end()) {
4284                         pfrom->PushMessage(inv.GetCommand(), (*mi).second);
4285                         pushed = true;
4286                     }
4287                 }
4288                 if (!pushed && inv.type == MSG_TX) {
4289                     CTransaction tx;
4290                     if (mempool.lookup(inv.hash, tx)) {
4291                         CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
4292                         ss.reserve(1000);
4293                         ss << tx;
4294                         pfrom->PushMessage("tx", ss);
4295                         pushed = true;
4296                     }
4297                 }
4298                 if (!pushed) {
4299                     vNotFound.push_back(inv);
4300                 }
4301             }
4302
4303             // Track requests for our stuff.
4304             GetMainSignals().Inventory(inv.hash);
4305
4306             if (inv.type == MSG_BLOCK || inv.type == MSG_FILTERED_BLOCK)
4307                 break;
4308         }
4309     }
4310
4311     pfrom->vRecvGetData.erase(pfrom->vRecvGetData.begin(), it);
4312
4313     if (!vNotFound.empty()) {
4314         // Let the peer know that we didn't find what it asked for, so it doesn't
4315         // have to wait around forever. Currently only SPV clients actually care
4316         // about this message: it's needed when they are recursively walking the
4317         // dependencies of relevant unconfirmed transactions. SPV clients want to
4318         // do that because they want to know about (and store and rebroadcast and
4319         // risk analyze) the dependencies of transactions relevant to them, without
4320         // having to download the entire memory pool.
4321         pfrom->PushMessage("notfound", vNotFound);
4322     }
4323 }
4324
4325 bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv, int64_t nTimeReceived)
4326 {
4327     const CChainParams& chainparams = Params();
4328     RandAddSeedPerfmon();
4329     LogPrint("net", "received: %s (%u bytes) peer=%d\n", SanitizeString(strCommand), vRecv.size(), pfrom->id);
4330     if (mapArgs.count("-dropmessagestest") && GetRand(atoi(mapArgs["-dropmessagestest"])) == 0)
4331     {
4332         LogPrintf("dropmessagestest DROPPING RECV MESSAGE\n");
4333         return true;
4334     }
4335
4336
4337
4338
4339     if (strCommand == "version")
4340     {
4341         // Each connection can only send one version message
4342         if (pfrom->nVersion != 0)
4343         {
4344             pfrom->PushMessage("reject", strCommand, REJECT_DUPLICATE, string("Duplicate version message"));
4345             Misbehaving(pfrom->GetId(), 1);
4346             return false;
4347         }
4348
4349         int64_t nTime;
4350         CAddress addrMe;
4351         CAddress addrFrom;
4352         uint64_t nNonce = 1;
4353         vRecv >> pfrom->nVersion >> pfrom->nServices >> nTime >> addrMe;
4354         if (pfrom->nVersion < MIN_PEER_PROTO_VERSION)
4355         {
4356             // disconnect from peers older than this proto version
4357             LogPrintf("peer=%d using obsolete version %i; disconnecting\n", pfrom->id, pfrom->nVersion);
4358             pfrom->PushMessage("reject", strCommand, REJECT_OBSOLETE,
4359                                strprintf("Version must be %d or greater", MIN_PEER_PROTO_VERSION));
4360             pfrom->fDisconnect = true;
4361             return false;
4362         }
4363
4364         if (pfrom->nVersion == 10300)
4365             pfrom->nVersion = 300;
4366         if (!vRecv.empty())
4367             vRecv >> addrFrom >> nNonce;
4368         if (!vRecv.empty()) {
4369             vRecv >> LIMITED_STRING(pfrom->strSubVer, 256);
4370             pfrom->cleanSubVer = SanitizeString(pfrom->strSubVer);
4371         }
4372         if (!vRecv.empty())
4373             vRecv >> pfrom->nStartingHeight;
4374         if (!vRecv.empty())
4375             vRecv >> pfrom->fRelayTxes; // set to true after we get the first filter* message
4376         else
4377             pfrom->fRelayTxes = true;
4378
4379         // Disconnect if we connected to ourself
4380         if (nNonce == nLocalHostNonce && nNonce > 1)
4381         {
4382             LogPrintf("connected to self at %s, disconnecting\n", pfrom->addr.ToString());
4383             pfrom->fDisconnect = true;
4384             return true;
4385         }
4386
4387         pfrom->addrLocal = addrMe;
4388         if (pfrom->fInbound && addrMe.IsRoutable())
4389         {
4390             SeenLocal(addrMe);
4391         }
4392
4393         // Be shy and don't send version until we hear
4394         if (pfrom->fInbound)
4395             pfrom->PushVersion();
4396
4397         pfrom->fClient = !(pfrom->nServices & NODE_NETWORK);
4398
4399         // Potentially mark this peer as a preferred download peer.
4400         UpdatePreferredDownload(pfrom, State(pfrom->GetId()));
4401
4402         // Change version
4403         pfrom->PushMessage("verack");
4404         pfrom->ssSend.SetVersion(min(pfrom->nVersion, PROTOCOL_VERSION));
4405
4406         if (!pfrom->fInbound)
4407         {
4408             // Advertise our address
4409             if (fListen && !IsInitialBlockDownload())
4410             {
4411                 CAddress addr = GetLocalAddress(&pfrom->addr);
4412                 if (addr.IsRoutable())
4413                 {
4414                     pfrom->PushAddress(addr);
4415                 } else if (IsPeerAddrLocalGood(pfrom)) {
4416                     addr.SetIP(pfrom->addrLocal);
4417                     pfrom->PushAddress(addr);
4418                 }
4419             }
4420
4421             // Get recent addresses
4422             if (pfrom->fOneShot || pfrom->nVersion >= CADDR_TIME_VERSION || addrman.size() < 1000)
4423             {
4424                 pfrom->PushMessage("getaddr");
4425                 pfrom->fGetAddr = true;
4426             }
4427             addrman.Good(pfrom->addr);
4428         } else {
4429             if (((CNetAddr)pfrom->addr) == (CNetAddr)addrFrom)
4430             {
4431                 addrman.Add(addrFrom, addrFrom);
4432                 addrman.Good(addrFrom);
4433             }
4434         }
4435
4436         // Relay alerts
4437         {
4438             LOCK(cs_mapAlerts);
4439             BOOST_FOREACH(PAIRTYPE(const uint256, CAlert)& item, mapAlerts)
4440                 item.second.RelayTo(pfrom);
4441         }
4442
4443         pfrom->fSuccessfullyConnected = true;
4444
4445         string remoteAddr;
4446         if (fLogIPs)
4447             remoteAddr = ", peeraddr=" + pfrom->addr.ToString();
4448
4449         LogPrintf("receive version message: %s: version %d, blocks=%d, us=%s, peer=%d%s\n",
4450                   pfrom->cleanSubVer, pfrom->nVersion,
4451                   pfrom->nStartingHeight, addrMe.ToString(), pfrom->id,
4452                   remoteAddr);
4453
4454         int64_t nTimeOffset = nTime - GetTime();
4455         pfrom->nTimeOffset = nTimeOffset;
4456         AddTimeData(pfrom->addr, nTimeOffset);
4457     }
4458
4459
4460     else if (pfrom->nVersion == 0)
4461     {
4462         // Must have a version message before anything else
4463         Misbehaving(pfrom->GetId(), 1);
4464         return false;
4465     }
4466
4467
4468     else if (strCommand == "verack")
4469     {
4470         pfrom->SetRecvVersion(min(pfrom->nVersion, PROTOCOL_VERSION));
4471
4472         // Mark this node as currently connected, so we update its timestamp later.
4473         if (pfrom->fNetworkNode) {
4474             LOCK(cs_main);
4475             State(pfrom->GetId())->fCurrentlyConnected = true;
4476         }
4477     }
4478
4479
4480     else if (strCommand == "addr")
4481     {
4482         vector<CAddress> vAddr;
4483         vRecv >> vAddr;
4484
4485         // Don't want addr from older versions unless seeding
4486         if (pfrom->nVersion < CADDR_TIME_VERSION && addrman.size() > 1000)
4487             return true;
4488         if (vAddr.size() > 1000)
4489         {
4490             Misbehaving(pfrom->GetId(), 20);
4491             return error("message addr size() = %u", vAddr.size());
4492         }
4493
4494         // Store the new addresses
4495         vector<CAddress> vAddrOk;
4496         int64_t nNow = GetAdjustedTime();
4497         int64_t nSince = nNow - 10 * 60;
4498         BOOST_FOREACH(CAddress& addr, vAddr)
4499         {
4500             boost::this_thread::interruption_point();
4501
4502             if (addr.nTime <= 100000000 || addr.nTime > nNow + 10 * 60)
4503                 addr.nTime = nNow - 5 * 24 * 60 * 60;
4504             pfrom->AddAddressKnown(addr);
4505             bool fReachable = IsReachable(addr);
4506             if (addr.nTime > nSince && !pfrom->fGetAddr && vAddr.size() <= 10 && addr.IsRoutable())
4507             {
4508                 // Relay to a limited number of other nodes
4509                 {
4510                     LOCK(cs_vNodes);
4511                     // Use deterministic randomness to send to the same nodes for 24 hours
4512                     // at a time so the addrKnowns of the chosen nodes prevent repeats
4513                     static uint256 hashSalt;
4514                     if (hashSalt.IsNull())
4515                         hashSalt = GetRandHash();
4516                     uint64_t hashAddr = addr.GetHash();
4517                     uint256 hashRand = ArithToUint256(UintToArith256(hashSalt) ^ (hashAddr<<32) ^ ((GetTime()+hashAddr)/(24*60*60)));
4518                     hashRand = Hash(BEGIN(hashRand), END(hashRand));
4519                     multimap<uint256, CNode*> mapMix;
4520                     BOOST_FOREACH(CNode* pnode, vNodes)
4521                     {
4522                         if (pnode->nVersion < CADDR_TIME_VERSION)
4523                             continue;
4524                         unsigned int nPointer;
4525                         memcpy(&nPointer, &pnode, sizeof(nPointer));
4526                         uint256 hashKey = ArithToUint256(UintToArith256(hashRand) ^ nPointer);
4527                         hashKey = Hash(BEGIN(hashKey), END(hashKey));
4528                         mapMix.insert(make_pair(hashKey, pnode));
4529                     }
4530                     int nRelayNodes = fReachable ? 2 : 1; // limited relaying of addresses outside our network(s)
4531                     for (multimap<uint256, CNode*>::iterator mi = mapMix.begin(); mi != mapMix.end() && nRelayNodes-- > 0; ++mi)
4532                         ((*mi).second)->PushAddress(addr);
4533                 }
4534             }
4535             // Do not store addresses outside our network
4536             if (fReachable)
4537                 vAddrOk.push_back(addr);
4538         }
4539         addrman.Add(vAddrOk, pfrom->addr, 2 * 60 * 60);
4540         if (vAddr.size() < 1000)
4541             pfrom->fGetAddr = false;
4542         if (pfrom->fOneShot)
4543             pfrom->fDisconnect = true;
4544     }
4545
4546
4547     else if (strCommand == "inv")
4548     {
4549         vector<CInv> vInv;
4550         vRecv >> vInv;
4551         if (vInv.size() > MAX_INV_SZ)
4552         {
4553             Misbehaving(pfrom->GetId(), 20);
4554             return error("message inv size() = %u", vInv.size());
4555         }
4556
4557         LOCK(cs_main);
4558
4559         std::vector<CInv> vToFetch;
4560
4561         for (unsigned int nInv = 0; nInv < vInv.size(); nInv++)
4562         {
4563             const CInv &inv = vInv[nInv];
4564
4565             boost::this_thread::interruption_point();
4566             pfrom->AddInventoryKnown(inv);
4567
4568             bool fAlreadyHave = AlreadyHave(inv);
4569             LogPrint("net", "got inv: %s  %s peer=%d\n", inv.ToString(), fAlreadyHave ? "have" : "new", pfrom->id);
4570
4571             if (!fAlreadyHave && !fImporting && !fReindex && inv.type != MSG_BLOCK)
4572                 pfrom->AskFor(inv);
4573
4574             if (inv.type == MSG_BLOCK) {
4575                 UpdateBlockAvailability(pfrom->GetId(), inv.hash);
4576                 if (!fAlreadyHave && !fImporting && !fReindex && !mapBlocksInFlight.count(inv.hash)) {
4577                     // First request the headers preceding the announced block. In the normal fully-synced
4578                     // case where a new block is announced that succeeds the current tip (no reorganization),
4579                     // there are no such headers.
4580                     // Secondly, and only when we are close to being synced, we request the announced block directly,
4581                     // to avoid an extra round-trip. Note that we must *first* ask for the headers, so by the
4582                     // time the block arrives, the header chain leading up to it is already validated. Not
4583                     // doing this will result in the received block being rejected as an orphan in case it is
4584                     // not a direct successor.
4585                     pfrom->PushMessage("getheaders", chainActive.GetLocator(pindexBestHeader), inv.hash);
4586                     CNodeState *nodestate = State(pfrom->GetId());
4587                     if (chainActive.Tip()->GetBlockTime() > GetAdjustedTime() - chainparams.GetConsensus().nPowTargetSpacing * 20 &&
4588                         nodestate->nBlocksInFlight < MAX_BLOCKS_IN_TRANSIT_PER_PEER) {
4589                         vToFetch.push_back(inv);
4590                         // Mark block as in flight already, even though the actual "getdata" message only goes out
4591                         // later (within the same cs_main lock, though).
4592                         MarkBlockAsInFlight(pfrom->GetId(), inv.hash, chainparams.GetConsensus());
4593                     }
4594                     LogPrint("net", "getheaders (%d) %s to peer=%d\n", pindexBestHeader->nHeight, inv.hash.ToString(), pfrom->id);
4595                 }
4596             }
4597
4598             // Track requests for our stuff
4599             GetMainSignals().Inventory(inv.hash);
4600
4601             if (pfrom->nSendSize > (SendBufferSize() * 2)) {
4602                 Misbehaving(pfrom->GetId(), 50);
4603                 return error("send buffer size() = %u", pfrom->nSendSize);
4604             }
4605         }
4606
4607         if (!vToFetch.empty())
4608             pfrom->PushMessage("getdata", vToFetch);
4609     }
4610
4611
4612     else if (strCommand == "getdata")
4613     {
4614         vector<CInv> vInv;
4615         vRecv >> vInv;
4616         if (vInv.size() > MAX_INV_SZ)
4617         {
4618             Misbehaving(pfrom->GetId(), 20);
4619             return error("message getdata size() = %u", vInv.size());
4620         }
4621
4622         if (fDebug || (vInv.size() != 1))
4623             LogPrint("net", "received getdata (%u invsz) peer=%d\n", vInv.size(), pfrom->id);
4624
4625         if ((fDebug && vInv.size() > 0) || (vInv.size() == 1))
4626             LogPrint("net", "received getdata for: %s peer=%d\n", vInv[0].ToString(), pfrom->id);
4627
4628         pfrom->vRecvGetData.insert(pfrom->vRecvGetData.end(), vInv.begin(), vInv.end());
4629         ProcessGetData(pfrom);
4630     }
4631
4632
4633     else if (strCommand == "getblocks")
4634     {
4635         CBlockLocator locator;
4636         uint256 hashStop;
4637         vRecv >> locator >> hashStop;
4638
4639         LOCK(cs_main);
4640
4641         // Find the last block the caller has in the main chain
4642         CBlockIndex* pindex = FindForkInGlobalIndex(chainActive, locator);
4643
4644         // Send the rest of the chain
4645         if (pindex)
4646             pindex = chainActive.Next(pindex);
4647         int nLimit = 500;
4648         LogPrint("net", "getblocks %d to %s limit %d from peer=%d\n", (pindex ? pindex->nHeight : -1), hashStop.IsNull() ? "end" : hashStop.ToString(), nLimit, pfrom->id);
4649         for (; pindex; pindex = chainActive.Next(pindex))
4650         {
4651             if (pindex->GetBlockHash() == hashStop)
4652             {
4653                 LogPrint("net", "  getblocks stopping at %d %s\n", pindex->nHeight, pindex->GetBlockHash().ToString());
4654                 break;
4655             }
4656             pfrom->PushInventory(CInv(MSG_BLOCK, pindex->GetBlockHash()));
4657             if (--nLimit <= 0)
4658             {
4659                 // When this block is requested, we'll send an inv that'll
4660                 // trigger the peer to getblocks the next batch of inventory.
4661                 LogPrint("net", "  getblocks stopping at limit %d %s\n", pindex->nHeight, pindex->GetBlockHash().ToString());
4662                 pfrom->hashContinue = pindex->GetBlockHash();
4663                 break;
4664             }
4665         }
4666     }
4667
4668
4669     else if (strCommand == "getheaders")
4670     {
4671         CBlockLocator locator;
4672         uint256 hashStop;
4673         vRecv >> locator >> hashStop;
4674
4675         LOCK(cs_main);
4676
4677         if (IsInitialBlockDownload())
4678             return true;
4679
4680         CBlockIndex* pindex = NULL;
4681         if (locator.IsNull())
4682         {
4683             // If locator is null, return the hashStop block
4684             BlockMap::iterator mi = mapBlockIndex.find(hashStop);
4685             if (mi == mapBlockIndex.end())
4686                 return true;
4687             pindex = (*mi).second;
4688         }
4689         else
4690         {
4691             // Find the last block the caller has in the main chain
4692             pindex = FindForkInGlobalIndex(chainActive, locator);
4693             if (pindex)
4694                 pindex = chainActive.Next(pindex);
4695         }
4696
4697         // we must use CBlocks, as CBlockHeaders won't include the 0x00 nTx count at the end
4698         vector<CBlock> vHeaders;
4699         int nLimit = MAX_HEADERS_RESULTS;
4700         LogPrint("net", "getheaders %d to %s from peer=%d\n", (pindex ? pindex->nHeight : -1), hashStop.ToString(), pfrom->id);
4701         for (; pindex; pindex = chainActive.Next(pindex))
4702         {
4703             vHeaders.push_back(pindex->GetBlockHeader());
4704             if (--nLimit <= 0 || pindex->GetBlockHash() == hashStop)
4705                 break;
4706         }
4707         pfrom->PushMessage("headers", vHeaders);
4708     }
4709
4710
4711     else if (strCommand == "tx")
4712     {
4713         vector<uint256> vWorkQueue;
4714         vector<uint256> vEraseQueue;
4715         CTransaction tx;
4716         vRecv >> tx;
4717
4718         CInv inv(MSG_TX, tx.GetHash());
4719         pfrom->AddInventoryKnown(inv);
4720
4721         LOCK(cs_main);
4722
4723         bool fMissingInputs = false;
4724         CValidationState state;
4725
4726         pfrom->setAskFor.erase(inv.hash);
4727         mapAlreadyAskedFor.erase(inv);
4728
4729         if (!AlreadyHave(inv) && AcceptToMemoryPool(mempool, state, tx, true, &fMissingInputs))
4730         {
4731             mempool.check(pcoinsTip);
4732             RelayTransaction(tx);
4733             vWorkQueue.push_back(inv.hash);
4734
4735             LogPrint("mempool", "AcceptToMemoryPool: peer=%d %s: accepted %s (poolsz %u)\n",
4736                 pfrom->id, pfrom->cleanSubVer,
4737                 tx.GetHash().ToString(),
4738                 mempool.mapTx.size());
4739
4740             // Recursively process any orphan transactions that depended on this one
4741             set<NodeId> setMisbehaving;
4742             for (unsigned int i = 0; i < vWorkQueue.size(); i++)
4743             {
4744                 map<uint256, set<uint256> >::iterator itByPrev = mapOrphanTransactionsByPrev.find(vWorkQueue[i]);
4745                 if (itByPrev == mapOrphanTransactionsByPrev.end())
4746                     continue;
4747                 for (set<uint256>::iterator mi = itByPrev->second.begin();
4748                      mi != itByPrev->second.end();
4749                      ++mi)
4750                 {
4751                     const uint256& orphanHash = *mi;
4752                     const CTransaction& orphanTx = mapOrphanTransactions[orphanHash].tx;
4753                     NodeId fromPeer = mapOrphanTransactions[orphanHash].fromPeer;
4754                     bool fMissingInputs2 = false;
4755                     // Use a dummy CValidationState so someone can't setup nodes to counter-DoS based on orphan
4756                     // resolution (that is, feeding people an invalid transaction based on LegitTxX in order to get
4757                     // anyone relaying LegitTxX banned)
4758                     CValidationState stateDummy;
4759
4760
4761                     if (setMisbehaving.count(fromPeer))
4762                         continue;
4763                     if (AcceptToMemoryPool(mempool, stateDummy, orphanTx, true, &fMissingInputs2))
4764                     {
4765                         LogPrint("mempool", "   accepted orphan tx %s\n", orphanHash.ToString());
4766                         RelayTransaction(orphanTx);
4767                         vWorkQueue.push_back(orphanHash);
4768                         vEraseQueue.push_back(orphanHash);
4769                     }
4770                     else if (!fMissingInputs2)
4771                     {
4772                         int nDos = 0;
4773                         if (stateDummy.IsInvalid(nDos) && nDos > 0)
4774                         {
4775                             // Punish peer that gave us an invalid orphan tx
4776                             Misbehaving(fromPeer, nDos);
4777                             setMisbehaving.insert(fromPeer);
4778                             LogPrint("mempool", "   invalid orphan tx %s\n", orphanHash.ToString());
4779                         }
4780                         // Has inputs but not accepted to mempool
4781                         // Probably non-standard or insufficient fee/priority
4782                         LogPrint("mempool", "   removed orphan tx %s\n", orphanHash.ToString());
4783                         vEraseQueue.push_back(orphanHash);
4784                         assert(recentRejects);
4785                         recentRejects->insert(orphanHash);
4786                     }
4787                     mempool.check(pcoinsTip);
4788                 }
4789             }
4790
4791             BOOST_FOREACH(uint256 hash, vEraseQueue)
4792                 EraseOrphanTx(hash);
4793         }
4794         // TODO: currently, prohibit joinsplits from entering mapOrphans
4795         else if (fMissingInputs && tx.vjoinsplit.size() == 0)
4796         {
4797             AddOrphanTx(tx, pfrom->GetId());
4798
4799             // DoS prevention: do not allow mapOrphanTransactions to grow unbounded
4800             unsigned int nMaxOrphanTx = (unsigned int)std::max((int64_t)0, GetArg("-maxorphantx", DEFAULT_MAX_ORPHAN_TRANSACTIONS));
4801             unsigned int nEvicted = LimitOrphanTxSize(nMaxOrphanTx);
4802             if (nEvicted > 0)
4803                 LogPrint("mempool", "mapOrphan overflow, removed %u tx\n", nEvicted);
4804         } else {
4805             assert(recentRejects);
4806             recentRejects->insert(tx.GetHash());
4807
4808             if (pfrom->fWhitelisted) {
4809                 // Always relay transactions received from whitelisted peers, even
4810                 // if they were already in the mempool or rejected from it due
4811                 // to policy, allowing the node to function as a gateway for
4812                 // nodes hidden behind it.
4813                 //
4814                 // Never relay transactions that we would assign a non-zero DoS
4815                 // score for, as we expect peers to do the same with us in that
4816                 // case.
4817                 int nDoS = 0;
4818                 if (!state.IsInvalid(nDoS) || nDoS == 0) {
4819                     LogPrintf("Force relaying tx %s from whitelisted peer=%d\n", tx.GetHash().ToString(), pfrom->id);
4820                     RelayTransaction(tx);
4821                 } else {
4822                     LogPrintf("Not relaying invalid transaction %s from whitelisted peer=%d (%s (code %d))\n",
4823                         tx.GetHash().ToString(), pfrom->id, state.GetRejectReason(), state.GetRejectCode());
4824                 }
4825             }
4826         }
4827         int nDoS = 0;
4828         if (state.IsInvalid(nDoS))
4829         {
4830             LogPrint("mempool", "%s from peer=%d %s was not accepted into the memory pool: %s\n", tx.GetHash().ToString(),
4831                 pfrom->id, pfrom->cleanSubVer,
4832                 state.GetRejectReason());
4833             pfrom->PushMessage("reject", strCommand, state.GetRejectCode(),
4834                                state.GetRejectReason().substr(0, MAX_REJECT_MESSAGE_LENGTH), inv.hash);
4835             if (nDoS > 0)
4836                 Misbehaving(pfrom->GetId(), nDoS);
4837         }
4838     }
4839
4840
4841     else if (strCommand == "headers" && !fImporting && !fReindex) // Ignore headers received while importing
4842     {
4843         std::vector<CBlockHeader> headers;
4844
4845         // Bypass the normal CBlock deserialization, as we don't want to risk deserializing 2000 full blocks.
4846         unsigned int nCount = ReadCompactSize(vRecv);
4847         if (nCount > MAX_HEADERS_RESULTS) {
4848             Misbehaving(pfrom->GetId(), 20);
4849             return error("headers message size = %u", nCount);
4850         }
4851         headers.resize(nCount);
4852         for (unsigned int n = 0; n < nCount; n++) {
4853             vRecv >> headers[n];
4854             ReadCompactSize(vRecv); // ignore tx count; assume it is 0.
4855         }
4856
4857         LOCK(cs_main);
4858
4859         if (nCount == 0) {
4860             // Nothing interesting. Stop asking this peers for more headers.
4861             return true;
4862         }
4863
4864         CBlockIndex *pindexLast = NULL;
4865         BOOST_FOREACH(const CBlockHeader& header, headers) {
4866             CValidationState state;
4867             if (pindexLast != NULL && header.hashPrevBlock != pindexLast->GetBlockHash()) {
4868                 Misbehaving(pfrom->GetId(), 20);
4869                 return error("non-continuous headers sequence");
4870             }
4871             if (!AcceptBlockHeader(header, state, &pindexLast)) {
4872                 int nDoS;
4873                 if (state.IsInvalid(nDoS)) {
4874                     if (nDoS > 0)
4875                         Misbehaving(pfrom->GetId(), nDoS);
4876                     return error("invalid header received");
4877                 }
4878             }
4879         }
4880
4881         if (pindexLast)
4882             UpdateBlockAvailability(pfrom->GetId(), pindexLast->GetBlockHash());
4883
4884         if (nCount == MAX_HEADERS_RESULTS && pindexLast) {
4885             // Headers message had its maximum size; the peer may have more headers.
4886             // TODO: optimize: if pindexLast is an ancestor of chainActive.Tip or pindexBestHeader, continue
4887             // from there instead.
4888             LogPrint("net", "more getheaders (%d) to end to peer=%d (startheight:%d)\n", pindexLast->nHeight, pfrom->id, pfrom->nStartingHeight);
4889             pfrom->PushMessage("getheaders", chainActive.GetLocator(pindexLast), uint256());
4890         }
4891
4892         CheckBlockIndex();
4893     }
4894
4895     else if (strCommand == "block" && !fImporting && !fReindex) // Ignore blocks received while importing
4896     {
4897         CBlock block;
4898         vRecv >> block;
4899
4900         CInv inv(MSG_BLOCK, block.GetHash());
4901         LogPrint("net", "received block %s peer=%d\n", inv.hash.ToString(), pfrom->id);
4902
4903         pfrom->AddInventoryKnown(inv);
4904
4905         CValidationState state;
4906         // Process all blocks from whitelisted peers, even if not requested,
4907         // unless we're still syncing with the network.
4908         // Such an unrequested block may still be processed, subject to the
4909         // conditions in AcceptBlock().
4910         bool forceProcessing = pfrom->fWhitelisted && !IsInitialBlockDownload();
4911         ProcessNewBlock(state, pfrom, &block, forceProcessing, NULL);
4912         int nDoS;
4913         if (state.IsInvalid(nDoS)) {
4914             pfrom->PushMessage("reject", strCommand, state.GetRejectCode(),
4915                                state.GetRejectReason().substr(0, MAX_REJECT_MESSAGE_LENGTH), inv.hash);
4916             if (nDoS > 0) {
4917                 LOCK(cs_main);
4918                 Misbehaving(pfrom->GetId(), nDoS);
4919             }
4920         }
4921
4922     }
4923
4924
4925     // This asymmetric behavior for inbound and outbound connections was introduced
4926     // to prevent a fingerprinting attack: an attacker can send specific fake addresses
4927     // to users' AddrMan and later request them by sending getaddr messages.
4928     // Making nodes which are behind NAT and can only make outgoing connections ignore
4929     // the getaddr message mitigates the attack.
4930     else if ((strCommand == "getaddr") && (pfrom->fInbound))
4931     {
4932         // Only send one GetAddr response per connection to reduce resource waste
4933         //  and discourage addr stamping of INV announcements.
4934         if (pfrom->fSentAddr) {
4935             LogPrint("net", "Ignoring repeated \"getaddr\". peer=%d\n", pfrom->id);
4936             return true;
4937         }
4938         pfrom->fSentAddr = true;
4939
4940         pfrom->vAddrToSend.clear();
4941         vector<CAddress> vAddr = addrman.GetAddr();
4942         BOOST_FOREACH(const CAddress &addr, vAddr)
4943             pfrom->PushAddress(addr);
4944     }
4945
4946
4947     else if (strCommand == "mempool")
4948     {
4949         LOCK2(cs_main, pfrom->cs_filter);
4950
4951         std::vector<uint256> vtxid;
4952         mempool.queryHashes(vtxid);
4953         vector<CInv> vInv;
4954         BOOST_FOREACH(uint256& hash, vtxid) {
4955             CInv inv(MSG_TX, hash);
4956             CTransaction tx;
4957             bool fInMemPool = mempool.lookup(hash, tx);
4958             if (!fInMemPool) continue; // another thread removed since queryHashes, maybe...
4959             if ((pfrom->pfilter && pfrom->pfilter->IsRelevantAndUpdate(tx)) ||
4960                (!pfrom->pfilter))
4961                 vInv.push_back(inv);
4962             if (vInv.size() == MAX_INV_SZ) {
4963                 pfrom->PushMessage("inv", vInv);
4964                 vInv.clear();
4965             }
4966         }
4967         if (vInv.size() > 0)
4968             pfrom->PushMessage("inv", vInv);
4969     }
4970
4971
4972     else if (strCommand == "ping")
4973     {
4974         if (pfrom->nVersion > BIP0031_VERSION)
4975         {
4976             uint64_t nonce = 0;
4977             vRecv >> nonce;
4978             // Echo the message back with the nonce. This allows for two useful features:
4979             //
4980             // 1) A remote node can quickly check if the connection is operational
4981             // 2) Remote nodes can measure the latency of the network thread. If this node
4982             //    is overloaded it won't respond to pings quickly and the remote node can
4983             //    avoid sending us more work, like chain download requests.
4984             //
4985             // The nonce stops the remote getting confused between different pings: without
4986             // it, if the remote node sends a ping once per second and this node takes 5
4987             // seconds to respond to each, the 5th ping the remote sends would appear to
4988             // return very quickly.
4989             pfrom->PushMessage("pong", nonce);
4990         }
4991     }
4992
4993
4994     else if (strCommand == "pong")
4995     {
4996         int64_t pingUsecEnd = nTimeReceived;
4997         uint64_t nonce = 0;
4998         size_t nAvail = vRecv.in_avail();
4999         bool bPingFinished = false;
5000         std::string sProblem;
5001
5002         if (nAvail >= sizeof(nonce)) {
5003             vRecv >> nonce;
5004
5005             // Only process pong message if there is an outstanding ping (old ping without nonce should never pong)
5006             if (pfrom->nPingNonceSent != 0) {
5007                 if (nonce == pfrom->nPingNonceSent) {
5008                     // Matching pong received, this ping is no longer outstanding
5009                     bPingFinished = true;
5010                     int64_t pingUsecTime = pingUsecEnd - pfrom->nPingUsecStart;
5011                     if (pingUsecTime > 0) {
5012                         // Successful ping time measurement, replace previous
5013                         pfrom->nPingUsecTime = pingUsecTime;
5014                         pfrom->nMinPingUsecTime = std::min(pfrom->nMinPingUsecTime, pingUsecTime);
5015                     } else {
5016                         // This should never happen
5017                         sProblem = "Timing mishap";
5018                     }
5019                 } else {
5020                     // Nonce mismatches are normal when pings are overlapping
5021                     sProblem = "Nonce mismatch";
5022                     if (nonce == 0) {
5023                         // This is most likely a bug in another implementation somewhere; cancel this ping
5024                         bPingFinished = true;
5025                         sProblem = "Nonce zero";
5026                     }
5027                 }
5028             } else {
5029                 sProblem = "Unsolicited pong without ping";
5030             }
5031         } else {
5032             // This is most likely a bug in another implementation somewhere; cancel this ping
5033             bPingFinished = true;
5034             sProblem = "Short payload";
5035         }
5036
5037         if (!(sProblem.empty())) {
5038             LogPrint("net", "pong peer=%d %s: %s, %x expected, %x received, %u bytes\n",
5039                 pfrom->id,
5040                 pfrom->cleanSubVer,
5041                 sProblem,
5042                 pfrom->nPingNonceSent,
5043                 nonce,
5044                 nAvail);
5045         }
5046         if (bPingFinished) {
5047             pfrom->nPingNonceSent = 0;
5048         }
5049     }
5050
5051
5052     else if (fAlerts && strCommand == "alert")
5053     {
5054         CAlert alert;
5055         vRecv >> alert;
5056
5057         uint256 alertHash = alert.GetHash();
5058         if (pfrom->setKnown.count(alertHash) == 0)
5059         {
5060             if (alert.ProcessAlert(Params().AlertKey()))
5061             {
5062                 // Relay
5063                 pfrom->setKnown.insert(alertHash);
5064                 {
5065                     LOCK(cs_vNodes);
5066                     BOOST_FOREACH(CNode* pnode, vNodes)
5067                         alert.RelayTo(pnode);
5068                 }
5069             }
5070             else {
5071                 // Small DoS penalty so peers that send us lots of
5072                 // duplicate/expired/invalid-signature/whatever alerts
5073                 // eventually get banned.
5074                 // This isn't a Misbehaving(100) (immediate ban) because the
5075                 // peer might be an older or different implementation with
5076                 // a different signature key, etc.
5077                 Misbehaving(pfrom->GetId(), 10);
5078             }
5079         }
5080     }
5081
5082
5083     else if (strCommand == "filterload")
5084     {
5085         CBloomFilter filter;
5086         vRecv >> filter;
5087
5088         if (!filter.IsWithinSizeConstraints())
5089             // There is no excuse for sending a too-large filter
5090             Misbehaving(pfrom->GetId(), 100);
5091         else
5092         {
5093             LOCK(pfrom->cs_filter);
5094             delete pfrom->pfilter;
5095             pfrom->pfilter = new CBloomFilter(filter);
5096             pfrom->pfilter->UpdateEmptyFull();
5097         }
5098         pfrom->fRelayTxes = true;
5099     }
5100
5101
5102     else if (strCommand == "filteradd")
5103     {
5104         vector<unsigned char> vData;
5105         vRecv >> vData;
5106
5107         // Nodes must NEVER send a data item > 520 bytes (the max size for a script data object,
5108         // and thus, the maximum size any matched object can have) in a filteradd message
5109         if (vData.size() > MAX_SCRIPT_ELEMENT_SIZE)
5110         {
5111             Misbehaving(pfrom->GetId(), 100);
5112         } else {
5113             LOCK(pfrom->cs_filter);
5114             if (pfrom->pfilter)
5115                 pfrom->pfilter->insert(vData);
5116             else
5117                 Misbehaving(pfrom->GetId(), 100);
5118         }
5119     }
5120
5121
5122     else if (strCommand == "filterclear")
5123     {
5124         LOCK(pfrom->cs_filter);
5125         delete pfrom->pfilter;
5126         pfrom->pfilter = new CBloomFilter();
5127         pfrom->fRelayTxes = true;
5128     }
5129
5130
5131     else if (strCommand == "reject")
5132     {
5133         if (fDebug) {
5134             try {
5135                 string strMsg; unsigned char ccode; string strReason;
5136                 vRecv >> LIMITED_STRING(strMsg, CMessageHeader::COMMAND_SIZE) >> ccode >> LIMITED_STRING(strReason, MAX_REJECT_MESSAGE_LENGTH);
5137
5138                 ostringstream ss;
5139                 ss << strMsg << " code " << itostr(ccode) << ": " << strReason;
5140
5141                 if (strMsg == "block" || strMsg == "tx")
5142                 {
5143                     uint256 hash;
5144                     vRecv >> hash;
5145                     ss << ": hash " << hash.ToString();
5146                 }
5147                 LogPrint("net", "Reject %s\n", SanitizeString(ss.str()));
5148             } catch (const std::ios_base::failure&) {
5149                 // Avoid feedback loops by preventing reject messages from triggering a new reject message.
5150                 LogPrint("net", "Unparseable reject message received\n");
5151             }
5152         }
5153     }
5154     else if (strCommand == "notfound") {
5155         // We do not care about the NOTFOUND message, but logging an Unknown Command
5156         // message would be undesirable as we transmit it ourselves.
5157     }
5158
5159     else {
5160         // Ignore unknown commands for extensibility
5161         LogPrint("net", "Unknown command \"%s\" from peer=%d\n", SanitizeString(strCommand), pfrom->id);
5162     }
5163
5164
5165
5166     return true;
5167 }
5168
5169 // requires LOCK(cs_vRecvMsg)
5170 bool ProcessMessages(CNode* pfrom)
5171 {
5172     //if (fDebug)
5173     //    LogPrintf("%s(%u messages)\n", __func__, pfrom->vRecvMsg.size());
5174
5175     //
5176     // Message format
5177     //  (4) message start
5178     //  (12) command
5179     //  (4) size
5180     //  (4) checksum
5181     //  (x) data
5182     //
5183     bool fOk = true;
5184
5185     if (!pfrom->vRecvGetData.empty())
5186         ProcessGetData(pfrom);
5187
5188     // this maintains the order of responses
5189     if (!pfrom->vRecvGetData.empty()) return fOk;
5190
5191     std::deque<CNetMessage>::iterator it = pfrom->vRecvMsg.begin();
5192     while (!pfrom->fDisconnect && it != pfrom->vRecvMsg.end()) {
5193         // Don't bother if send buffer is too full to respond anyway
5194         if (pfrom->nSendSize >= SendBufferSize())
5195             break;
5196
5197         // get next message
5198         CNetMessage& msg = *it;
5199
5200         //if (fDebug)
5201         //    LogPrintf("%s(message %u msgsz, %u bytes, complete:%s)\n", __func__,
5202         //            msg.hdr.nMessageSize, msg.vRecv.size(),
5203         //            msg.complete() ? "Y" : "N");
5204
5205         // end, if an incomplete message is found
5206         if (!msg.complete())
5207             break;
5208
5209         // at this point, any failure means we can delete the current message
5210         it++;
5211
5212         // Scan for message start
5213         if (memcmp(msg.hdr.pchMessageStart, Params().MessageStart(), MESSAGE_START_SIZE) != 0) {
5214             LogPrintf("PROCESSMESSAGE: INVALID MESSAGESTART %s peer=%d\n", SanitizeString(msg.hdr.GetCommand()), pfrom->id);
5215             fOk = false;
5216             break;
5217         }
5218
5219         // Read header
5220         CMessageHeader& hdr = msg.hdr;
5221         if (!hdr.IsValid(Params().MessageStart()))
5222         {
5223             LogPrintf("PROCESSMESSAGE: ERRORS IN HEADER %s peer=%d\n", SanitizeString(hdr.GetCommand()), pfrom->id);
5224             continue;
5225         }
5226         string strCommand = hdr.GetCommand();
5227
5228         // Message size
5229         unsigned int nMessageSize = hdr.nMessageSize;
5230
5231         // Checksum
5232         CDataStream& vRecv = msg.vRecv;
5233         uint256 hash = Hash(vRecv.begin(), vRecv.begin() + nMessageSize);
5234         unsigned int nChecksum = ReadLE32((unsigned char*)&hash);
5235         if (nChecksum != hdr.nChecksum)
5236         {
5237             LogPrintf("%s(%s, %u bytes): CHECKSUM ERROR nChecksum=%08x hdr.nChecksum=%08x\n", __func__,
5238                SanitizeString(strCommand), nMessageSize, nChecksum, hdr.nChecksum);
5239             continue;
5240         }
5241
5242         // Process message
5243         bool fRet = false;
5244         try
5245         {
5246             fRet = ProcessMessage(pfrom, strCommand, vRecv, msg.nTime);
5247             boost::this_thread::interruption_point();
5248         }
5249         catch (const std::ios_base::failure& e)
5250         {
5251             pfrom->PushMessage("reject", strCommand, REJECT_MALFORMED, string("error parsing message"));
5252             if (strstr(e.what(), "end of data"))
5253             {
5254                 // Allow exceptions from under-length message on vRecv
5255                 LogPrintf("%s(%s, %u bytes): Exception '%s' caught, normally caused by a message being shorter than its stated length\n", __func__, SanitizeString(strCommand), nMessageSize, e.what());
5256             }
5257             else if (strstr(e.what(), "size too large"))
5258             {
5259                 // Allow exceptions from over-long size
5260                 LogPrintf("%s(%s, %u bytes): Exception '%s' caught\n", __func__, SanitizeString(strCommand), nMessageSize, e.what());
5261             }
5262             else
5263             {
5264                 PrintExceptionContinue(&e, "ProcessMessages()");
5265             }
5266         }
5267         catch (const boost::thread_interrupted&) {
5268             throw;
5269         }
5270         catch (const std::exception& e) {
5271             PrintExceptionContinue(&e, "ProcessMessages()");
5272         } catch (...) {
5273             PrintExceptionContinue(NULL, "ProcessMessages()");
5274         }
5275
5276         if (!fRet)
5277             LogPrintf("%s(%s, %u bytes) FAILED peer=%d\n", __func__, SanitizeString(strCommand), nMessageSize, pfrom->id);
5278
5279         break;
5280     }
5281
5282     // In case the connection got shut down, its receive buffer was wiped
5283     if (!pfrom->fDisconnect)
5284         pfrom->vRecvMsg.erase(pfrom->vRecvMsg.begin(), it);
5285
5286     return fOk;
5287 }
5288
5289
5290 bool SendMessages(CNode* pto, bool fSendTrickle)
5291 {
5292     const Consensus::Params& consensusParams = Params().GetConsensus();
5293     {
5294         // Don't send anything until we get its version message
5295         if (pto->nVersion == 0)
5296             return true;
5297
5298         //
5299         // Message: ping
5300         //
5301         bool pingSend = false;
5302         if (pto->fPingQueued) {
5303             // RPC ping request by user
5304             pingSend = true;
5305         }
5306         if (pto->nPingNonceSent == 0 && pto->nPingUsecStart + PING_INTERVAL * 1000000 < GetTimeMicros()) {
5307             // Ping automatically sent as a latency probe & keepalive.
5308             pingSend = true;
5309         }
5310         if (pingSend) {
5311             uint64_t nonce = 0;
5312             while (nonce == 0) {
5313                 GetRandBytes((unsigned char*)&nonce, sizeof(nonce));
5314             }
5315             pto->fPingQueued = false;
5316             pto->nPingUsecStart = GetTimeMicros();
5317             if (pto->nVersion > BIP0031_VERSION) {
5318                 pto->nPingNonceSent = nonce;
5319                 pto->PushMessage("ping", nonce);
5320             } else {
5321                 // Peer is too old to support ping command with nonce, pong will never arrive.
5322                 pto->nPingNonceSent = 0;
5323                 pto->PushMessage("ping");
5324             }
5325         }
5326
5327         TRY_LOCK(cs_main, lockMain); // Acquire cs_main for IsInitialBlockDownload() and CNodeState()
5328         if (!lockMain)
5329             return true;
5330
5331         // Address refresh broadcast
5332         static int64_t nLastRebroadcast;
5333         if (!IsInitialBlockDownload() && (GetTime() - nLastRebroadcast > 24 * 60 * 60))
5334         {
5335             LOCK(cs_vNodes);
5336             BOOST_FOREACH(CNode* pnode, vNodes)
5337             {
5338                 // Periodically clear addrKnown to allow refresh broadcasts
5339                 if (nLastRebroadcast)
5340                     pnode->addrKnown.reset();
5341
5342                 // Rebroadcast our address
5343                 AdvertizeLocal(pnode);
5344             }
5345             if (!vNodes.empty())
5346                 nLastRebroadcast = GetTime();
5347         }
5348
5349         //
5350         // Message: addr
5351         //
5352         if (fSendTrickle)
5353         {
5354             vector<CAddress> vAddr;
5355             vAddr.reserve(pto->vAddrToSend.size());
5356             BOOST_FOREACH(const CAddress& addr, pto->vAddrToSend)
5357             {
5358                 if (!pto->addrKnown.contains(addr.GetKey()))
5359                 {
5360                     pto->addrKnown.insert(addr.GetKey());
5361                     vAddr.push_back(addr);
5362                     // receiver rejects addr messages larger than 1000
5363                     if (vAddr.size() >= 1000)
5364                     {
5365                         pto->PushMessage("addr", vAddr);
5366                         vAddr.clear();
5367                     }
5368                 }
5369             }
5370             pto->vAddrToSend.clear();
5371             if (!vAddr.empty())
5372                 pto->PushMessage("addr", vAddr);
5373         }
5374
5375         CNodeState &state = *State(pto->GetId());
5376         if (state.fShouldBan) {
5377             if (pto->fWhitelisted)
5378                 LogPrintf("Warning: not punishing whitelisted peer %s!\n", pto->addr.ToString());
5379             else {
5380                 pto->fDisconnect = true;
5381                 if (pto->addr.IsLocal())
5382                     LogPrintf("Warning: not banning local peer %s!\n", pto->addr.ToString());
5383                 else
5384                 {
5385                     CNode::Ban(pto->addr);
5386                 }
5387             }
5388             state.fShouldBan = false;
5389         }
5390
5391         BOOST_FOREACH(const CBlockReject& reject, state.rejects)
5392             pto->PushMessage("reject", (string)"block", reject.chRejectCode, reject.strRejectReason, reject.hashBlock);
5393         state.rejects.clear();
5394
5395         // Start block sync
5396         if (pindexBestHeader == NULL)
5397             pindexBestHeader = chainActive.Tip();
5398         bool fFetch = state.fPreferredDownload || (nPreferredDownload == 0 && !pto->fClient && !pto->fOneShot); // Download if this is a nice peer, or we have no nice peers and this one might do.
5399         if (!state.fSyncStarted && !pto->fClient && !fImporting && !fReindex) {
5400             // Only actively request headers from a single peer, unless we're close to today.
5401             if ((nSyncStarted == 0 && fFetch) || pindexBestHeader->GetBlockTime() > GetAdjustedTime() - 24 * 60 * 60) {
5402                 state.fSyncStarted = true;
5403                 nSyncStarted++;
5404                 CBlockIndex *pindexStart = pindexBestHeader->pprev ? pindexBestHeader->pprev : pindexBestHeader;
5405                 LogPrint("net", "initial getheaders (%d) to peer=%d (startheight:%d)\n", pindexStart->nHeight, pto->id, pto->nStartingHeight);
5406                 pto->PushMessage("getheaders", chainActive.GetLocator(pindexStart), uint256());
5407             }
5408         }
5409
5410         // Resend wallet transactions that haven't gotten in a block yet
5411         // Except during reindex, importing and IBD, when old wallet
5412         // transactions become unconfirmed and spams other nodes.
5413         if (!fReindex && !fImporting && !IsInitialBlockDownload())
5414         {
5415             GetMainSignals().Broadcast(nTimeBestReceived);
5416         }
5417
5418         //
5419         // Message: inventory
5420         //
5421         vector<CInv> vInv;
5422         vector<CInv> vInvWait;
5423         {
5424             LOCK(pto->cs_inventory);
5425             vInv.reserve(pto->vInventoryToSend.size());
5426             vInvWait.reserve(pto->vInventoryToSend.size());
5427             BOOST_FOREACH(const CInv& inv, pto->vInventoryToSend)
5428             {
5429                 if (pto->setInventoryKnown.count(inv))
5430                     continue;
5431
5432                 // trickle out tx inv to protect privacy
5433                 if (inv.type == MSG_TX && !fSendTrickle)
5434                 {
5435                     // 1/4 of tx invs blast to all immediately
5436                     static uint256 hashSalt;
5437                     if (hashSalt.IsNull())
5438                         hashSalt = GetRandHash();
5439                     uint256 hashRand = ArithToUint256(UintToArith256(inv.hash) ^ UintToArith256(hashSalt));
5440                     hashRand = Hash(BEGIN(hashRand), END(hashRand));
5441                     bool fTrickleWait = ((UintToArith256(hashRand) & 3) != 0);
5442
5443                     if (fTrickleWait)
5444                     {
5445                         vInvWait.push_back(inv);
5446                         continue;
5447                     }
5448                 }
5449
5450                 // returns true if wasn't already contained in the set
5451                 if (pto->setInventoryKnown.insert(inv).second)
5452                 {
5453                     vInv.push_back(inv);
5454                     if (vInv.size() >= 1000)
5455                     {
5456                         pto->PushMessage("inv", vInv);
5457                         vInv.clear();
5458                     }
5459                 }
5460             }
5461             pto->vInventoryToSend = vInvWait;
5462         }
5463         if (!vInv.empty())
5464             pto->PushMessage("inv", vInv);
5465
5466         // Detect whether we're stalling
5467         int64_t nNow = GetTimeMicros();
5468         if (!pto->fDisconnect && state.nStallingSince && state.nStallingSince < nNow - 1000000 * BLOCK_STALLING_TIMEOUT) {
5469             // Stalling only triggers when the block download window cannot move. During normal steady state,
5470             // the download window should be much larger than the to-be-downloaded set of blocks, so disconnection
5471             // should only happen during initial block download.
5472             LogPrintf("Peer=%d is stalling block download, disconnecting\n", pto->id);
5473             pto->fDisconnect = true;
5474         }
5475         // In case there is a block that has been in flight from this peer for (2 + 0.5 * N) times the block interval
5476         // (with N the number of validated blocks that were in flight at the time it was requested), disconnect due to
5477         // timeout. We compensate for in-flight blocks to prevent killing off peers due to our own downstream link
5478         // being saturated. We only count validated in-flight blocks so peers can't advertise non-existing block hashes
5479         // to unreasonably increase our timeout.
5480         // We also compare the block download timeout originally calculated against the time at which we'd disconnect
5481         // if we assumed the block were being requested now (ignoring blocks we've requested from this peer, since we're
5482         // only looking at this peer's oldest request).  This way a large queue in the past doesn't result in a
5483         // permanently large window for this block to be delivered (ie if the number of blocks in flight is decreasing
5484         // more quickly than once every 5 minutes, then we'll shorten the download window for this block).
5485         if (!pto->fDisconnect && state.vBlocksInFlight.size() > 0) {
5486             QueuedBlock &queuedBlock = state.vBlocksInFlight.front();
5487             int64_t nTimeoutIfRequestedNow = GetBlockTimeout(nNow, nQueuedValidatedHeaders - state.nBlocksInFlightValidHeaders, consensusParams);
5488             if (queuedBlock.nTimeDisconnect > nTimeoutIfRequestedNow) {
5489                 LogPrint("net", "Reducing block download timeout for peer=%d block=%s, orig=%d new=%d\n", pto->id, queuedBlock.hash.ToString(), queuedBlock.nTimeDisconnect, nTimeoutIfRequestedNow);
5490                 queuedBlock.nTimeDisconnect = nTimeoutIfRequestedNow;
5491             }
5492             if (queuedBlock.nTimeDisconnect < nNow) {
5493                 LogPrintf("Timeout downloading block %s from peer=%d, disconnecting\n", queuedBlock.hash.ToString(), pto->id);
5494                 pto->fDisconnect = true;
5495             }
5496         }
5497
5498         //
5499         // Message: getdata (blocks)
5500         //
5501         vector<CInv> vGetData;
5502         if (!pto->fDisconnect && !pto->fClient && (fFetch || !IsInitialBlockDownload()) && state.nBlocksInFlight < MAX_BLOCKS_IN_TRANSIT_PER_PEER) {
5503             vector<CBlockIndex*> vToDownload;
5504             NodeId staller = -1;
5505             FindNextBlocksToDownload(pto->GetId(), MAX_BLOCKS_IN_TRANSIT_PER_PEER - state.nBlocksInFlight, vToDownload, staller);
5506             BOOST_FOREACH(CBlockIndex *pindex, vToDownload) {
5507                 vGetData.push_back(CInv(MSG_BLOCK, pindex->GetBlockHash()));
5508                 MarkBlockAsInFlight(pto->GetId(), pindex->GetBlockHash(), consensusParams, pindex);
5509                 LogPrint("net", "Requesting block %s (%d) peer=%d\n", pindex->GetBlockHash().ToString(),
5510                     pindex->nHeight, pto->id);
5511             }
5512             if (state.nBlocksInFlight == 0 && staller != -1) {
5513                 if (State(staller)->nStallingSince == 0) {
5514                     State(staller)->nStallingSince = nNow;
5515                     LogPrint("net", "Stall started peer=%d\n", staller);
5516                 }
5517             }
5518         }
5519
5520         //
5521         // Message: getdata (non-blocks)
5522         //
5523         while (!pto->fDisconnect && !pto->mapAskFor.empty() && (*pto->mapAskFor.begin()).first <= nNow)
5524         {
5525             const CInv& inv = (*pto->mapAskFor.begin()).second;
5526             if (!AlreadyHave(inv))
5527             {
5528                 if (fDebug)
5529                     LogPrint("net", "Requesting %s peer=%d\n", inv.ToString(), pto->id);
5530                 vGetData.push_back(inv);
5531                 if (vGetData.size() >= 1000)
5532                 {
5533                     pto->PushMessage("getdata", vGetData);
5534                     vGetData.clear();
5535                 }
5536             } else {
5537                 //If we're not going to ask, don't expect a response.
5538                 pto->setAskFor.erase(inv.hash);
5539             }
5540             pto->mapAskFor.erase(pto->mapAskFor.begin());
5541         }
5542         if (!vGetData.empty())
5543             pto->PushMessage("getdata", vGetData);
5544
5545     }
5546     return true;
5547 }
5548
5549  std::string CBlockFileInfo::ToString() const {
5550      return strprintf("CBlockFileInfo(blocks=%u, size=%u, heights=%u...%u, time=%s...%s)", nBlocks, nSize, nHeightFirst, nHeightLast, DateTimeStrFormat("%Y-%m-%d", nTimeFirst), DateTimeStrFormat("%Y-%m-%d", nTimeLast));
5551  }
5552
5553
5554
5555 class CMainCleanup
5556 {
5557 public:
5558     CMainCleanup() {}
5559     ~CMainCleanup() {
5560         // block headers
5561         BlockMap::iterator it1 = mapBlockIndex.begin();
5562         for (; it1 != mapBlockIndex.end(); it1++)
5563             delete (*it1).second;
5564         mapBlockIndex.clear();
5565
5566         // orphan transactions
5567         mapOrphanTransactions.clear();
5568         mapOrphanTransactionsByPrev.clear();
5569     }
5570 } instance_of_cmaincleanup;
5571
5572 extern "C" const char* getDataDir()
5573 {
5574         return GetDataDir().string().c_str();
5575 }
5576