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 "importcoin.h"
  14 #include "chainparams.h"
  15 #include "checkpoints.h"
  16 #include "checkqueue.h"
  17 #include "consensus/upgrades.h"
  18 #include "consensus/validation.h"
  19 #include "deprecation.h"
  20 #include "init.h"
  21 #include "merkleblock.h"
  22 #include "metrics.h"
  23 #include "notarisationdb.h"
  24 #include "net.h"
  25 #include "pow.h"
  26 #include "script/interpreter.h"
  27 #include "txdb.h"
  28 #include "txmempool.h"
  29 #include "ui_interface.h"
  30 #include "undo.h"
  31 #include "util.h"
  32 #include "utilmoneystr.h"
  33 #include "validationinterface.h"
  34 #include "wallet/asyncrpcoperation_sendmany.h"
  35 #include "wallet/asyncrpcoperation_shieldcoinbase.h"
  36
  37 #include <cstring>
  38 #include <algorithm>
  39 #include <atomic>
  40 #include <sstream>
  41 #include <map>
  42 #include <unordered_map>
  43 #include <vector>
  44
  45 #include <boost/algorithm/string/replace.hpp>
  46 #include <boost/filesystem.hpp>
  47 #include <boost/filesystem/fstream.hpp>
  48 #include <boost/math/distributions/poisson.hpp>
  49 #include <boost/thread.hpp>
  50 #include <boost/static_assert.hpp>
  51
  52 using namespace std;
  53
  54 #if defined(NDEBUG)
  55 # error "Zcash cannot be compiled without assertions."
  56 #endif
  57
  58 #include "librustzcash.h"
  59
  60 /**
  61  * Global state
  62  */
  63
  64 CCriticalSection cs_main;
  65 extern uint8_t NOTARY_PUBKEY33[33];
  66 extern int32_t KOMODO_LOADINGBLOCKS,KOMODO_LONGESTCHAIN,KOMODO_INSYNC,KOMODO_CONNECTING;
  67 int32_t KOMODO_NEWBLOCKS;
  68 int32_t komodo_block2pubkey33(uint8_t *pubkey33,CBlock *block);
  69 void komodo_broadcast(CBlock *pblock,int32_t limit);
  70
  71 BlockMap mapBlockIndex;
  72 CChain chainActive;
  73 CBlockIndex *pindexBestHeader = NULL;
  74 static int64_t nTimeBestReceived = 0;
  75 CWaitableCriticalSection csBestBlock;
  76 CConditionVariable cvBlockChange;
  77 int nScriptCheckThreads = 0;
  78 bool fExperimentalMode = false;
  79 bool fImporting = false;
  80 bool fReindex = false;
  81 bool fTxIndex = false;
  82 bool fAddressIndex = false;
  83 bool fTimestampIndex = false;
  84 bool fSpentIndex = false;
  85 bool fHavePruned = false;
  86 bool fPruneMode = false;
  87 bool fIsBareMultisigStd = true;
  88 bool fCheckBlockIndex = false;
  89 bool fCheckpointsEnabled = true;
  90 bool fCoinbaseEnforcedProtectionEnabled = true;
  91 size_t nCoinCacheUsage = 5000 * 300;
  92 uint64_t nPruneTarget = 0;
  93 bool fAlerts = DEFAULT_ALERTS;
  94 /* If the tip is older than this (in seconds), the node is considered to be in initial block download.
  95  */
  96 int64_t nMaxTipAge = DEFAULT_MAX_TIP_AGE;
  97
  98 unsigned int expiryDelta = DEFAULT_TX_EXPIRY_DELTA;
  99
 100 /** Fees smaller than this (in satoshi) are considered zero fee (for relaying and mining) */
 101 CFeeRate minRelayTxFee = CFeeRate(DEFAULT_MIN_RELAY_TX_FEE);
 102
 103 CTxMemPool mempool(::minRelayTxFee);
 104
 105 struct COrphanTx {
 106     CTransaction tx;
 107     NodeId fromPeer;
 108 };
 109 map<uint256, COrphanTx> mapOrphanTransactions GUARDED_BY(cs_main);;
 110 map<uint256, set<uint256> > mapOrphanTransactionsByPrev GUARDED_BY(cs_main);;
 111 void EraseOrphansFor(NodeId peer) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 112
 113 /**
 114  * Returns true if there are nRequired or more blocks of minVersion or above
 115  * in the last Consensus::Params::nMajorityWindow blocks, starting at pstart and going backwards.
 116  */
 117 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart, unsigned nRequired, const Consensus::Params& consensusParams);
 118 static void CheckBlockIndex();
 119
 120 /** Constant stuff for coinbase transactions we create: */
 121 CScript COINBASE_FLAGS;
 122
 123 const string strMessageMagic = "Komodo Signed Message:\n";
 124
 125 // Internal stuff
 126 namespace {
 127
 128     struct CBlockIndexWorkComparator
 129     {
 130         bool operator()(CBlockIndex *pa, CBlockIndex *pb) const {
 131             // First sort by most total work, ...
 132             if (pa->chainPower > pb->chainPower) return false;
 133             if (pa->chainPower < pb->chainPower) return true;
 134
 135             // ... then by earliest time received, ...
 136             if (pa->nSequenceId < pb->nSequenceId) return false;
 137             if (pa->nSequenceId > pb->nSequenceId) return true;
 138
 139             // Use pointer address as tie breaker (should only happen with blocks
 140             // loaded from disk, as those all have id 0).
 141             if (pa < pb) return false;
 142             if (pa > pb) return true;
 143
 144             // Identical blocks.
 145             return false;
 146         }
 147     };
 148
 149     CBlockIndex *pindexBestInvalid;
 150
 151     /**
 152      * The set of all CBlockIndex entries with BLOCK_VALID_TRANSACTIONS (for itself and all ancestors) and
 153      * as good as our current tip or better. Entries may be failed, though, and pruning nodes may be
 154      * missing the data for the block.
 155      */
 156     set<CBlockIndex*, CBlockIndexWorkComparator> setBlockIndexCandidates;
 157
 158     /** Number of nodes with fSyncStarted. */
 159     int nSyncStarted = 0;
 160
 161     /** All pairs A->B, where A (or one if its ancestors) misses transactions, but B has transactions.
 162      * Pruned nodes may have entries where B is missing data.
 163      */
 164     multimap<CBlockIndex*, CBlockIndex*> mapBlocksUnlinked;
 165
 166     CCriticalSection cs_LastBlockFile;
 167     std::vector<CBlockFileInfo> vinfoBlockFile;
 168     int nLastBlockFile = 0;
 169     /** Global flag to indicate we should check to see if there are
 170      *  block/undo files that should be deleted.  Set on startup
 171      *  or if we allocate more file space when we're in prune mode
 172      */
 173     bool fCheckForPruning = false;
 174
 175     /**
 176      * Every received block is assigned a unique and increasing identifier, so we
 177      * know which one to give priority in case of a fork.
 178      */
 179     CCriticalSection cs_nBlockSequenceId;
 180     /** Blocks loaded from disk are assigned id 0, so start the counter at 1. */
 181     uint32_t nBlockSequenceId = 1;
 182
 183     /**
 184      * Sources of received blocks, saved to be able to send them reject
 185      * messages or ban them when processing happens afterwards. Protected by
 186      * cs_main.
 187      */
 188     map<uint256, NodeId> mapBlockSource;
 189
 190     /**
 191      * Filter for transactions that were recently rejected by
 192      * AcceptToMemoryPool. These are not rerequested until the chain tip
 193      * changes, at which point the entire filter is reset. Protected by
 194      * cs_main.
 195      *
 196      * Without this filter we'd be re-requesting txs from each of our peers,
 197      * increasing bandwidth consumption considerably. For instance, with 100
 198      * peers, half of which relay a tx we don't accept, that might be a 50x
 199      * bandwidth increase. A flooding attacker attempting to roll-over the
 200      * filter using minimum-sized, 60byte, transactions might manage to send
 201      * 1000/sec if we have fast peers, so we pick 120,000 to give our peers a
 202      * two minute window to send invs to us.
 203      *
 204      * Decreasing the false positive rate is fairly cheap, so we pick one in a
 205      * million to make it highly unlikely for users to have issues with this
 206      * filter.
 207      *
 208      * Memory used: 1.7MB
 209      */
 210     boost::scoped_ptr<CRollingBloomFilter> recentRejects;
 211     uint256 hashRecentRejectsChainTip;
 212
 213     /** Blocks that are in flight, and that are in the queue to be downloaded. Protected by cs_main. */
 214     struct QueuedBlock {
 215         uint256 hash;
 216         CBlockIndex *pindex;  //! Optional.
 217         int64_t nTime;  //! Time of "getdata" request in microseconds.
 218         bool fValidatedHeaders;  //! Whether this block has validated headers at the time of request.
 219         int64_t nTimeDisconnect; //! The timeout for this block request (for disconnecting a slow peer)
 220     };
 221     map<uint256, pair<NodeId, list<QueuedBlock>::iterator> > mapBlocksInFlight;
 222
 223     /** Number of blocks in flight with validated headers. */
 224     int nQueuedValidatedHeaders = 0;
 225
 226     /** Number of preferable block download peers. */
 227     int nPreferredDownload = 0;
 228
 229     /** Dirty block index entries. */
 230     set<CBlockIndex*> setDirtyBlockIndex;
 231
 232     /** Dirty block file entries. */
 233     set<int> setDirtyFileInfo;
 234 } // anon namespace
 235
 236 //////////////////////////////////////////////////////////////////////////////
 237 //
 238 // Registration of network node signals.
 239 //
 240
 241 namespace {
 242
 243     struct CBlockReject {
 244         unsigned char chRejectCode;
 245         string strRejectReason;
 246         uint256 hashBlock;
 247     };
 248
 249     /**
 250      * Maintain validation-specific state about nodes, protected by cs_main, instead
 251      * by CNode's own locks. This simplifies asynchronous operation, where
 252      * processing of incoming data is done after the ProcessMessage call returns,
 253      * and we're no longer holding the node's locks.
 254      */
 255     struct CNodeState {
 256         //! The peer's address
 257         CService address;
 258         //! Whether we have a fully established connection.
 259         bool fCurrentlyConnected;
 260         //! Accumulated misbehaviour score for this peer.
 261         int nMisbehavior;
 262         //! Whether this peer should be disconnected and banned (unless whitelisted).
 263         bool fShouldBan;
 264         //! String name of this peer (debugging/logging purposes).
 265         std::string name;
 266         //! List of asynchronously-determined block rejections to notify this peer about.
 267         std::vector<CBlockReject> rejects;
 268         //! The best known block we know this peer has announced.
 269         CBlockIndex *pindexBestKnownBlock;
 270         //! The hash of the last unknown block this peer has announced.
 271         uint256 hashLastUnknownBlock;
 272         //! The last full block we both have.
 273         CBlockIndex *pindexLastCommonBlock;
 274         //! Whether we've started headers synchronization with this peer.
 275         bool fSyncStarted;
 276         //! Since when we're stalling block download progress (in microseconds), or 0.
 277         int64_t nStallingSince;
 278         list<QueuedBlock> vBlocksInFlight;
 279         int nBlocksInFlight;
 280         int nBlocksInFlightValidHeaders;
 281         //! Whether we consider this a preferred download peer.
 282         bool fPreferredDownload;
 283
 284         CNodeState() {
 285             fCurrentlyConnected = false;
 286             nMisbehavior = 0;
 287             fShouldBan = false;
 288             pindexBestKnownBlock = NULL;
 289             hashLastUnknownBlock.SetNull();
 290             pindexLastCommonBlock = NULL;
 291             fSyncStarted = false;
 292             nStallingSince = 0;
 293             nBlocksInFlight = 0;
 294             nBlocksInFlightValidHeaders = 0;
 295             fPreferredDownload = false;
 296         }
 297     };
 298
 299     /** Map maintaining per-node state. Requires cs_main. */
 300     map<NodeId, CNodeState> mapNodeState;
 301
 302     // Requires cs_main.
 303     CNodeState *State(NodeId pnode) {
 304         map<NodeId, CNodeState>::iterator it = mapNodeState.find(pnode);
 305         if (it == mapNodeState.end())
 306             return NULL;
 307         return &it->second;
 308     }
 309
 310     int GetHeight()
 311     {
 312         return chainActive.LastTip()->GetHeight();
 313     }
 314
 315     void UpdatePreferredDownload(CNode* node, CNodeState* state)
 316     {
 317         nPreferredDownload -= state->fPreferredDownload;
 318
 319         // Whether this node should be marked as a preferred download node.
 320         state->fPreferredDownload = (!node->fInbound || node->fWhitelisted) && !node->fOneShot && !node->fClient;
 321
 322         nPreferredDownload += state->fPreferredDownload;
 323     }
 324
 325     // Returns time at which to timeout block request (nTime in microseconds)
 326     int64_t GetBlockTimeout(int64_t nTime, int nValidatedQueuedBefore, const Consensus::Params &consensusParams)
 327     {
 328         return nTime + 500000 * consensusParams.nPowTargetSpacing * (4 + nValidatedQueuedBefore);
 329     }
 330
 331     void InitializeNode(NodeId nodeid, const CNode *pnode) {
 332         LOCK(cs_main);
 333         CNodeState &state = mapNodeState.insert(std::make_pair(nodeid, CNodeState())).first->second;
 334         state.name = pnode->addrName;
 335         state.address = pnode->addr;
 336     }
 337
 338     void FinalizeNode(NodeId nodeid) {
 339         LOCK(cs_main);
 340         CNodeState *state = State(nodeid);
 341
 342         if (state->fSyncStarted)
 343             nSyncStarted--;
 344
 345         if (state->nMisbehavior == 0 && state->fCurrentlyConnected) {
 346             AddressCurrentlyConnected(state->address);
 347         }
 348
 349         BOOST_FOREACH(const QueuedBlock& entry, state->vBlocksInFlight)
 350         mapBlocksInFlight.erase(entry.hash);
 351         EraseOrphansFor(nodeid);
 352         nPreferredDownload -= state->fPreferredDownload;
 353
 354         mapNodeState.erase(nodeid);
 355     }
 356
 357     void LimitMempoolSize(CTxMemPool& pool, size_t limit, unsigned long age)
 358     {
 359         /*    int expired = pool.Expire(GetTime() - age);
 360          if (expired != 0)
 361          LogPrint("mempool", "Expired %i transactions from the memory pool\n", expired);
 362
 363          std::vector<uint256> vNoSpendsRemaining;
 364          pool.TrimToSize(limit, &vNoSpendsRemaining);
 365          BOOST_FOREACH(const uint256& removed, vNoSpendsRemaining)
 366          pcoinsTip->Uncache(removed);*/
 367     }
 368
 369     // Requires cs_main.
 370     // Returns a bool indicating whether we requested this block.
 371     bool MarkBlockAsReceived(const uint256& hash) {
 372         map<uint256, pair<NodeId, list<QueuedBlock>::iterator> >::iterator itInFlight = mapBlocksInFlight.find(hash);
 373         if (itInFlight != mapBlocksInFlight.end()) {
 374             CNodeState *state = State(itInFlight->second.first);
 375             nQueuedValidatedHeaders -= itInFlight->second.second->fValidatedHeaders;
 376             state->nBlocksInFlightValidHeaders -= itInFlight->second.second->fValidatedHeaders;
 377             state->vBlocksInFlight.erase(itInFlight->second.second);
 378             state->nBlocksInFlight--;
 379             state->nStallingSince = 0;
 380             mapBlocksInFlight.erase(itInFlight);
 381             return true;
 382         }
 383         return false;
 384     }
 385
 386     // Requires cs_main.
 387     void MarkBlockAsInFlight(NodeId nodeid, const uint256& hash, const Consensus::Params& consensusParams, CBlockIndex *pindex = NULL) {
 388         CNodeState *state = State(nodeid);
 389         assert(state != NULL);
 390
 391         // Make sure it's not listed somewhere already.
 392         MarkBlockAsReceived(hash);
 393
 394         int64_t nNow = GetTimeMicros();
 395         QueuedBlock newentry = {hash, pindex, nNow, pindex != NULL, GetBlockTimeout(nNow, nQueuedValidatedHeaders, consensusParams)};
 396         nQueuedValidatedHeaders += newentry.fValidatedHeaders;
 397         list<QueuedBlock>::iterator it = state->vBlocksInFlight.insert(state->vBlocksInFlight.end(), newentry);
 398         state->nBlocksInFlight++;
 399         state->nBlocksInFlightValidHeaders += newentry.fValidatedHeaders;
 400         mapBlocksInFlight[hash] = std::make_pair(nodeid, it);
 401     }
 402
 403     /** Check whether the last unknown block a peer advertized is not yet known. */
 404     void ProcessBlockAvailability(NodeId nodeid) {
 405         CNodeState *state = State(nodeid);
 406         assert(state != NULL);
 407
 408         if (!state->hashLastUnknownBlock.IsNull()) {
 409             BlockMap::iterator itOld = mapBlockIndex.find(state->hashLastUnknownBlock);
 410             if (itOld != mapBlockIndex.end() && itOld->second != 0 && (itOld->second->chainPower > CChainPower()))
 411             {
 412                 if (state->pindexBestKnownBlock == NULL || itOld->second->chainPower >= state->pindexBestKnownBlock->chainPower)
 413                     state->pindexBestKnownBlock = itOld->second;
 414                 state->hashLastUnknownBlock.SetNull();
 415             }
 416         }
 417     }
 418
 419     /** Update tracking information about which blocks a peer is assumed to have. */
 420     void UpdateBlockAvailability(NodeId nodeid, const uint256 &hash) {
 421         CNodeState *state = State(nodeid);
 422         assert(state != NULL);
 423
 424         /*ProcessBlockAvailability(nodeid);
 425
 426          BlockMap::iterator it = mapBlockIndex.find(hash);
 427          if (it != mapBlockIndex.end() && it->second->nChainWork > 0) {
 428          // An actually better block was announced.
 429          if (state->pindexBestKnownBlock == NULL || it->second->nChainWork >= state->pindexBestKnownBlock->nChainWork)
 430          state->pindexBestKnownBlock = it->second;
 431          } else*/
 432         {
 433             // An unknown block was announced; just assume that the latest one is the best one.
 434             state->hashLastUnknownBlock = hash;
 435         }
 436     }
 437
 438     /** Find the last common ancestor two blocks have.
 439      *  Both pa and pb must be non-NULL. */
 440     CBlockIndex* LastCommonAncestor(CBlockIndex* pa, CBlockIndex* pb) {
 441         if (pa->GetHeight() > pb->GetHeight()) {
 442             pa = pa->GetAncestor(pb->GetHeight());
 443         } else if (pb->GetHeight() > pa->GetHeight()) {
 444             pb = pb->GetAncestor(pa->GetHeight());
 445         }
 446
 447         while (pa != pb && pa && pb) {
 448             pa = pa->pprev;
 449             pb = pb->pprev;
 450         }
 451
 452         // Eventually all chain branches meet at the genesis block.
 453         assert(pa == pb);
 454         return pa;
 455     }
 456
 457     /** Update pindexLastCommonBlock and add not-in-flight missing successors to vBlocks, until it has
 458      *  at most count entries. */
 459     void FindNextBlocksToDownload(NodeId nodeid, unsigned int count, std::vector<CBlockIndex*>& vBlocks, NodeId& nodeStaller) {
 460         if (count == 0)
 461             return;
 462
 463         vBlocks.reserve(vBlocks.size() + count);
 464         CNodeState *state = State(nodeid);
 465         assert(state != NULL);
 466
 467         // Make sure pindexBestKnownBlock is up to date, we'll need it.
 468         ProcessBlockAvailability(nodeid);
 469
 470         if (state->pindexBestKnownBlock == NULL || state->pindexBestKnownBlock->chainPower < chainActive.Tip()->chainPower) {
 471             // This peer has nothing interesting.
 472             return;
 473         }
 474
 475         if (state->pindexLastCommonBlock == NULL) {
 476             // Bootstrap quickly by guessing a parent of our best tip is the forking point.
 477             // Guessing wrong in either direction is not a problem.
 478             state->pindexLastCommonBlock = chainActive[std::min(state->pindexBestKnownBlock->GetHeight(), chainActive.Height())];
 479         }
 480
 481         // If the peer reorganized, our previous pindexLastCommonBlock may not be an ancestor
 482         // of its current tip anymore. Go back enough to fix that.
 483         state->pindexLastCommonBlock = LastCommonAncestor(state->pindexLastCommonBlock, state->pindexBestKnownBlock);
 484         if (state->pindexLastCommonBlock == state->pindexBestKnownBlock)
 485             return;
 486
 487         std::vector<CBlockIndex*> vToFetch;
 488         CBlockIndex *pindexWalk = state->pindexLastCommonBlock;
 489         // Never fetch further than the best block we know the peer has, or more than BLOCK_DOWNLOAD_WINDOW + 1 beyond the last
 490         // linked block we have in common with this peer. The +1 is so we can detect stalling, namely if we would be able to
 491         // download that next block if the window were 1 larger.
 492         int nWindowEnd = state->pindexLastCommonBlock->GetHeight() + BLOCK_DOWNLOAD_WINDOW;
 493         int nMaxHeight = std::min<int>(state->pindexBestKnownBlock->GetHeight(), nWindowEnd + 1);
 494         NodeId waitingfor = -1;
 495         while (pindexWalk->GetHeight() < nMaxHeight) {
 496             // Read up to 128 (or more, if more blocks than that are needed) successors of pindexWalk (towards
 497             // pindexBestKnownBlock) into vToFetch. We fetch 128, because CBlockIndex::GetAncestor may be as expensive
 498             // as iterating over ~100 CBlockIndex* entries anyway.
 499             int nToFetch = std::min(nMaxHeight - pindexWalk->GetHeight(), std::max<int>(count - vBlocks.size(), 128));
 500             vToFetch.resize(nToFetch);
 501             pindexWalk = state->pindexBestKnownBlock->GetAncestor(pindexWalk->GetHeight() + nToFetch);
 502             vToFetch[nToFetch - 1] = pindexWalk;
 503             for (unsigned int i = nToFetch - 1; i > 0; i--) {
 504                 vToFetch[i - 1] = vToFetch[i]->pprev;
 505             }
 506
 507             // Iterate over those blocks in vToFetch (in forward direction), adding the ones that
 508             // are not yet downloaded and not in flight to vBlocks. In the meantime, update
 509             // pindexLastCommonBlock as long as all ancestors are already downloaded, or if it's
 510             // already part of our chain (and therefore don't need it even if pruned).
 511             BOOST_FOREACH(CBlockIndex* pindex, vToFetch) {
 512                 if (!pindex->IsValid(BLOCK_VALID_TREE)) {
 513                     // We consider the chain that this peer is on invalid.
 514                     return;
 515                 }
 516                 if (pindex->nStatus & BLOCK_HAVE_DATA || chainActive.Contains(pindex)) {
 517                     if (pindex->nChainTx)
 518                         state->pindexLastCommonBlock = pindex;
 519                 } else if (mapBlocksInFlight.count(pindex->GetBlockHash()) == 0) {
 520                     // The block is not already downloaded, and not yet in flight.
 521                     if (pindex->GetHeight() > nWindowEnd) {
 522                         // We reached the end of the window.
 523                         if (vBlocks.size() == 0 && waitingfor != nodeid) {
 524                             // We aren't able to fetch anything, but we would be if the download window was one larger.
 525                             nodeStaller = waitingfor;
 526                         }
 527                         return;
 528                     }
 529                     vBlocks.push_back(pindex);
 530                     if (vBlocks.size() == count) {
 531                         return;
 532                     }
 533                 } else if (waitingfor == -1) {
 534                     // This is the first already-in-flight block.
 535                     waitingfor = mapBlocksInFlight[pindex->GetBlockHash()].first;
 536                 }
 537             }
 538         }
 539     }
 540
 541 } // anon namespace
 542
 543 bool GetNodeStateStats(NodeId nodeid, CNodeStateStats &stats) {
 544     LOCK(cs_main);
 545     CNodeState *state = State(nodeid);
 546     if (state == NULL)
 547         return false;
 548     stats.nMisbehavior = state->nMisbehavior;
 549     stats.nSyncHeight = state->pindexBestKnownBlock ? state->pindexBestKnownBlock->GetHeight() : -1;
 550     stats.nCommonHeight = state->pindexLastCommonBlock ? state->pindexLastCommonBlock->GetHeight() : -1;
 551     BOOST_FOREACH(const QueuedBlock& queue, state->vBlocksInFlight) {
 552         if (queue.pindex)
 553             stats.vHeightInFlight.push_back(queue.pindex->GetHeight());
 554     }
 555     return true;
 556 }
 557
 558 void RegisterNodeSignals(CNodeSignals& nodeSignals)
 559 {
 560     nodeSignals.GetHeight.connect(&GetHeight);
 561     nodeSignals.ProcessMessages.connect(&ProcessMessages);
 562     nodeSignals.SendMessages.connect(&SendMessages);
 563     nodeSignals.InitializeNode.connect(&InitializeNode);
 564     nodeSignals.FinalizeNode.connect(&FinalizeNode);
 565 }
 566
 567 void UnregisterNodeSignals(CNodeSignals& nodeSignals)
 568 {
 569     nodeSignals.GetHeight.disconnect(&GetHeight);
 570     nodeSignals.ProcessMessages.disconnect(&ProcessMessages);
 571     nodeSignals.SendMessages.disconnect(&SendMessages);
 572     nodeSignals.InitializeNode.disconnect(&InitializeNode);
 573     nodeSignals.FinalizeNode.disconnect(&FinalizeNode);
 574 }
 575
 576 CBlockIndex* FindForkInGlobalIndex(const CChain& chain, const CBlockLocator& locator)
 577 {
 578     // Find the first block the caller has in the main chain
 579     BOOST_FOREACH(const uint256& hash, locator.vHave) {
 580         BlockMap::iterator mi = mapBlockIndex.find(hash);
 581         if (mi != mapBlockIndex.end())
 582         {
 583             CBlockIndex* pindex = (*mi).second;
 584             if (pindex != 0 && chain.Contains(pindex))
 585                 return pindex;
 586             if (pindex != 0 && pindex->GetAncestor(chain.Height()) == chain.Tip()) {
 587                 return chain.Tip();
 588             }
 589         }
 590     }
 591     return chain.Genesis();
 592 }
 593
 594 CCoinsViewCache *pcoinsTip = NULL;
 595 CBlockTreeDB *pblocktree = NULL;
 596
 597 // Komodo globals
 598
 599 #define KOMODO_ZCASH
 600 #include "komodo.h"
 601
 602 UniValue komodo_snapshot(int top)
 603 {
 604     LOCK(cs_main);
 605     int64_t total = -1;
 606     UniValue result(UniValue::VOBJ);
 607
 608     if (fAddressIndex) {
 609             if ( pblocktree != 0 ) {
 610                 result = pblocktree->Snapshot(top);
 611             } else {
 612                 fprintf(stderr,"null pblocktree start with -addressindex=1\n");
 613             }
 614     } else {
 615             fprintf(stderr,"getsnapshot requires -addressindex=1\n");
 616     }
 617     return(result);
 618 }
 619
 620 //////////////////////////////////////////////////////////////////////////////
 621 //
 622 // mapOrphanTransactions
 623 //
 624
 625 bool AddOrphanTx(const CTransaction& tx, NodeId peer) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
 626 {
 627     uint256 hash = tx.GetHash();
 628     if (mapOrphanTransactions.count(hash))
 629         return false;
 630
 631     // Ignore big transactions, to avoid a
 632     // send-big-orphans memory exhaustion attack. If a peer has a legitimate
 633     // large transaction with a missing parent then we assume
 634     // it will rebroadcast it later, after the parent transaction(s)
 635     // have been mined or received.
 636     // 10,000 orphans, each of which is at most 5,000 bytes big is
 637     // at most 500 megabytes of orphans:
 638     unsigned int sz = GetSerializeSize(tx, SER_NETWORK, tx.nVersion);
 639     if (sz > 5000)
 640     {
 641         LogPrint("mempool", "ignoring large orphan tx (size: %u, hash: %s)\n", sz, hash.ToString());
 642         return false;
 643     }
 644
 645     mapOrphanTransactions[hash].tx = tx;
 646     mapOrphanTransactions[hash].fromPeer = peer;
 647     BOOST_FOREACH(const CTxIn& txin, tx.vin)
 648     mapOrphanTransactionsByPrev[txin.prevout.hash].insert(hash);
 649
 650     LogPrint("mempool", "stored orphan tx %s (mapsz %u prevsz %u)\n", hash.ToString(),
 651              mapOrphanTransactions.size(), mapOrphanTransactionsByPrev.size());
 652     return true;
 653 }
 654
 655 void static EraseOrphanTx(uint256 hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
 656 {
 657     map<uint256, COrphanTx>::iterator it = mapOrphanTransactions.find(hash);
 658     if (it == mapOrphanTransactions.end())
 659         return;
 660     BOOST_FOREACH(const CTxIn& txin, it->second.tx.vin)
 661     {
 662         map<uint256, set<uint256> >::iterator itPrev = mapOrphanTransactionsByPrev.find(txin.prevout.hash);
 663         if (itPrev == mapOrphanTransactionsByPrev.end())
 664             continue;
 665         itPrev->second.erase(hash);
 666         if (itPrev->second.empty())
 667             mapOrphanTransactionsByPrev.erase(itPrev);
 668     }
 669     mapOrphanTransactions.erase(it);
 670 }
 671
 672 void EraseOrphansFor(NodeId peer)
 673 {
 674     int nErased = 0;
 675     map<uint256, COrphanTx>::iterator iter = mapOrphanTransactions.begin();
 676     while (iter != mapOrphanTransactions.end())
 677     {
 678         map<uint256, COrphanTx>::iterator maybeErase = iter++; // increment to avoid iterator becoming invalid
 679         if (maybeErase->second.fromPeer == peer)
 680         {
 681             EraseOrphanTx(maybeErase->second.tx.GetHash());
 682             ++nErased;
 683         }
 684     }
 685     if (nErased > 0) LogPrint("mempool", "Erased %d orphan tx from peer %d\n", nErased, peer);
 686 }
 687
 688
 689 unsigned int LimitOrphanTxSize(unsigned int nMaxOrphans) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
 690 {
 691     unsigned int nEvicted = 0;
 692     while (mapOrphanTransactions.size() > nMaxOrphans)
 693     {
 694         // Evict a random orphan:
 695         uint256 randomhash = GetRandHash();
 696         map<uint256, COrphanTx>::iterator it = mapOrphanTransactions.lower_bound(randomhash);
 697         if (it == mapOrphanTransactions.end())
 698             it = mapOrphanTransactions.begin();
 699             EraseOrphanTx(it->first);
 700             ++nEvicted;
 701     }
 702     return nEvicted;
 703 }
 704
 705
 706 bool IsStandardTx(const CTransaction& tx, string& reason, const int nHeight)
 707 {
 708     bool overwinterActive = NetworkUpgradeActive(nHeight, Params().GetConsensus(), Consensus::UPGRADE_OVERWINTER);
 709     bool saplingActive = NetworkUpgradeActive(nHeight, Params().GetConsensus(), Consensus::UPGRADE_SAPLING);
 710
 711     if (saplingActive) {
 712         // Sapling standard rules apply
 713         if (tx.nVersion > CTransaction::SAPLING_MAX_CURRENT_VERSION || tx.nVersion < CTransaction::SAPLING_MIN_CURRENT_VERSION) {
 714             reason = "sapling-version";
 715             return false;
 716         }
 717     } else if (overwinterActive) {
 718         // Overwinter standard rules apply
 719         if (tx.nVersion > CTransaction::OVERWINTER_MAX_CURRENT_VERSION || tx.nVersion < CTransaction::OVERWINTER_MIN_CURRENT_VERSION) {
 720             reason = "overwinter-version";
 721             return false;
 722         }
 723     } else {
 724         // Sprout standard rules apply
 725         if (tx.nVersion > CTransaction::SPROUT_MAX_CURRENT_VERSION || tx.nVersion < CTransaction::SPROUT_MIN_CURRENT_VERSION) {
 726             reason = "version";
 727             return false;
 728         }
 729     }
 730
 731     BOOST_FOREACH(const CTxIn& txin, tx.vin)
 732     {
 733         // Biggest 'standard' txin is a 15-of-15 P2SH multisig with compressed
 734         // keys. (remember the 520 byte limit on redeemScript size) That works
 735         // out to a (15*(33+1))+3=513 byte redeemScript, 513+1+15*(73+1)+3=1627
 736         // bytes of scriptSig, which we round off to 1650 bytes for some minor
 737         // future-proofing. That's also enough to spend a 20-of-20
 738         // CHECKMULTISIG scriptPubKey, though such a scriptPubKey is not
 739         // considered standard)
 740         if (txin.scriptSig.size() > 1650) {
 741             reason = "scriptsig-size";
 742             return false;
 743         }
 744         if (!txin.scriptSig.IsPushOnly()) {
 745             reason = "scriptsig-not-pushonly";
 746             return false;
 747         }
 748     }
 749
 750     unsigned int v=0,nDataOut = 0;
 751     txnouttype whichType;
 752     BOOST_FOREACH(const CTxOut& txout, tx.vout)
 753     {
 754         if (!::IsStandard(txout.scriptPubKey, whichType))
 755         {
 756             reason = "scriptpubkey";
 757             //fprintf(stderr,">>>>>>>>>>>>>>> vout.%d nDataout.%d\n",v,nDataOut);
 758             return false;
 759         }
 760
 761         if (whichType == TX_NULL_DATA)
 762         {
 763             if ( txout.scriptPubKey.size() > IGUANA_MAXSCRIPTSIZE )
 764             {
 765                 reason = "opreturn too big";
 766                 return(false);
 767             }
 768             nDataOut++;
 769             //fprintf(stderr,"is OP_RETURN\n");
 770         }
 771         else if ((whichType == TX_MULTISIG) && (!fIsBareMultisigStd)) {
 772             reason = "bare-multisig";
 773             return false;
 774         } else if (txout.scriptPubKey.IsPayToCryptoCondition() == 0 && txout.IsDust(::minRelayTxFee)) {
 775             reason = "dust";
 776             return false;
 777         }
 778         v++;
 779     }
 780
 781     // only one OP_RETURN txout is permitted
 782     if (nDataOut > 1) {
 783         reason = "multi-op-return";
 784         return false;
 785     }
 786
 787     return true;
 788 }
 789
 790 bool IsFinalTx(const CTransaction &tx, int nBlockHeight, int64_t nBlockTime)
 791 {
 792     int32_t i;
 793     if (tx.nLockTime == 0)
 794         return true;
 795     if ((int64_t)tx.nLockTime < ((int64_t)tx.nLockTime < LOCKTIME_THRESHOLD ? (int64_t)nBlockHeight : nBlockTime))
 796         return true;
 797     BOOST_FOREACH(const CTxIn& txin, tx.vin)
 798     {
 799         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)) )
 800         {
 801
 802         }
 803         else if (!txin.IsFinal())
 804         {
 805             //printf("non-final txin seq.%x locktime.%u vs nTime.%u\n",txin.nSequence,(uint32_t)tx.nLockTime,(uint32_t)nBlockTime);
 806             return false;
 807         }
 808     }
 809     return true;
 810 }
 811
 812 bool IsExpiredTx(const CTransaction &tx, int nBlockHeight)
 813 {
 814     if (tx.nExpiryHeight == 0 || tx.IsCoinBase()) {
 815         return false;
 816     }
 817     return static_cast<uint32_t>(nBlockHeight) > tx.nExpiryHeight;
 818 }
 819
 820 bool CheckFinalTx(const CTransaction &tx, int flags)
 821 {
 822     AssertLockHeld(cs_main);
 823
 824     // By convention a negative value for flags indicates that the
 825     // current network-enforced consensus rules should be used. In
 826     // a future soft-fork scenario that would mean checking which
 827     // rules would be enforced for the next block and setting the
 828     // appropriate flags. At the present time no soft-forks are
 829     // scheduled, so no flags are set.
 830     flags = std::max(flags, 0);
 831
 832     // CheckFinalTx() uses chainActive.Height()+1 to evaluate
 833     // nLockTime because when IsFinalTx() is called within
 834     // CBlock::AcceptBlock(), the height of the block *being*
 835     // evaluated is what is used. Thus if we want to know if a
 836     // transaction can be part of the *next* block, we need to call
 837     // IsFinalTx() with one more than chainActive.Height().
 838     const int nBlockHeight = chainActive.Height() + 1;
 839
 840     // Timestamps on the other hand don't get any special treatment,
 841     // because we can't know what timestamp the next block will have,
 842     // and there aren't timestamp applications where it matters.
 843     // However this changes once median past time-locks are enforced:
 844     const int64_t nBlockTime = (flags & LOCKTIME_MEDIAN_TIME_PAST)
 845     ? chainActive.Tip()->GetMedianTimePast()
 846     : GetAdjustedTime();
 847
 848     return IsFinalTx(tx, nBlockHeight, nBlockTime);
 849 }
 850
 851 /**
 852  * Check transaction inputs to mitigate two
 853  * potential denial-of-service attacks:
 854  *
 855  * 1. scriptSigs with extra data stuffed into them,
 856  *    not consumed by scriptPubKey (or P2SH script)
 857  * 2. P2SH scripts with a crazy number of expensive
 858  *    CHECKSIG/CHECKMULTISIG operations
 859  */
 860 bool AreInputsStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs, uint32_t consensusBranchId)
 861 {
 862     if (tx.IsCoinBase())
 863         return true; // Coinbases don't use vin normally
 864
 865     if (tx.IsCoinImport())
 866         return tx.vin[0].scriptSig.IsCoinImport();
 867
 868     for (unsigned int i = 0; i < tx.vin.size(); i++)
 869     {
 870         const CTxOut& prev = mapInputs.GetOutputFor(tx.vin[i]);
 871
 872         vector<vector<unsigned char> > vSolutions;
 873         txnouttype whichType;
 874         // get the scriptPubKey corresponding to this input:
 875         const CScript& prevScript = prev.scriptPubKey;
 876         //printf("Previous script: %s\n", prevScript.ToString().c_str());
 877
 878         if (!Solver(prevScript, whichType, vSolutions))
 879             return false;
 880         int nArgsExpected = ScriptSigArgsExpected(whichType, vSolutions);
 881         if (nArgsExpected < 0)
 882             return false;
 883
 884         // Transactions with extra stuff in their scriptSigs are
 885         // non-standard. Note that this EvalScript() call will
 886         // be quick, because if there are any operations
 887         // beside "push data" in the scriptSig
 888         // IsStandardTx() will have already returned false
 889         // and this method isn't called.
 890         vector<vector<unsigned char> > stack;
 891         //printf("Checking script: %s\n", tx.vin[i].scriptSig.ToString().c_str());
 892         if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker(), consensusBranchId))
 893             return false;
 894
 895         if (whichType == TX_SCRIPTHASH)
 896         {
 897             if (stack.empty())
 898                 return false;
 899             CScript subscript(stack.back().begin(), stack.back().end());
 900             vector<vector<unsigned char> > vSolutions2;
 901             txnouttype whichType2;
 902             if (Solver(subscript, whichType2, vSolutions2))
 903             {
 904                 int tmpExpected = ScriptSigArgsExpected(whichType2, vSolutions2);
 905                 if (tmpExpected < 0)
 906                     return false;
 907                 nArgsExpected += tmpExpected;
 908             }
 909             else
 910             {
 911                 // Any other Script with less than 15 sigops OK:
 912                 unsigned int sigops = subscript.GetSigOpCount(true);
 913                 // ... extra data left on the stack after execution is OK, too:
 914                 return (sigops <= MAX_P2SH_SIGOPS);
 915             }
 916         }
 917
 918         if (stack.size() != (unsigned int)nArgsExpected)
 919             return false;
 920     }
 921
 922     return true;
 923 }
 924
 925 unsigned int GetLegacySigOpCount(const CTransaction& tx)
 926 {
 927     unsigned int nSigOps = 0;
 928     BOOST_FOREACH(const CTxIn& txin, tx.vin)
 929     {
 930         nSigOps += txin.scriptSig.GetSigOpCount(false);
 931     }
 932     BOOST_FOREACH(const CTxOut& txout, tx.vout)
 933     {
 934         nSigOps += txout.scriptPubKey.GetSigOpCount(false);
 935     }
 936     return nSigOps;
 937 }
 938
 939 unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewCache& inputs)
 940 {
 941     if (tx.IsCoinBase() || tx.IsCoinImport())
 942         return 0;
 943
 944     unsigned int nSigOps = 0;
 945     for (unsigned int i = 0; i < tx.vin.size(); i++)
 946     {
 947         const CTxOut &prevout = inputs.GetOutputFor(tx.vin[i]);
 948         if (prevout.scriptPubKey.IsPayToScriptHash())
 949             nSigOps += prevout.scriptPubKey.GetSigOpCount(tx.vin[i].scriptSig);
 950     }
 951     return nSigOps;
 952 }
 953
 954 /**
 955  * Ensure that a coinbase transaction is structured according to the consensus rules of the
 956  * chain
 957  */
 958 bool ContextualCheckCoinbaseTransaction(const CTransaction& tx, const int nHeight)
 959 {
 960     // if time locks are on, ensure that this coin base is time locked exactly as it should be
 961     if (((uint64_t)(tx.GetValueOut()) >= ASSETCHAINS_TIMELOCKGTE) ||
 962         (((nHeight >= 31680) || strcmp(ASSETCHAINS_SYMBOL, "VRSC") != 0) && komodo_ac_block_subsidy(nHeight) >= ASSETCHAINS_TIMELOCKGTE))
 963     {
 964         CScriptID scriptHash;
 965
 966         // to be valid, it must be a P2SH transaction and have an op_return in vout[1] that
 967         // holds the full output script, which may include multisig, etc., but starts with
 968         // the time lock verify of the correct time lock for this block height
 969         if (tx.vout.size() == 2 &&
 970             CScriptExt(tx.vout[0].scriptPubKey).IsPayToScriptHash(&scriptHash) &&
 971             tx.vout[1].scriptPubKey.size() >= 7 && // minimum for any possible future to prevent out of bounds
 972             tx.vout[1].scriptPubKey[0] == OP_RETURN)
 973         {
 974             opcodetype op;
 975             std::vector<uint8_t> opretData = std::vector<uint8_t>();
 976             CScript::const_iterator it = tx.vout[1].scriptPubKey.begin() + 1;
 977             if (tx.vout[1].scriptPubKey.GetOp2(it, op, &opretData))
 978             {
 979                 if (opretData.size() > 0 && opretData.data()[0] == OPRETTYPE_TIMELOCK)
 980                 {
 981                     int64_t unlocktime;
 982                     CScriptExt opretScript = CScriptExt(&opretData[1], &opretData[opretData.size()]);
 983
 984                     if (CScriptID(opretScript) == scriptHash &&
 985                         opretScript.IsCheckLockTimeVerify(&unlocktime) &&
 986                         komodo_block_unlocktime(nHeight) == unlocktime)
 987                     {
 988                         return(true);
 989                     }
 990                 }
 991             }
 992         }
 993         return(false);
 994     }
 995     return(true);
 996 }
 997
 998 /**
 999  * Check a transaction contextually against a set of consensus rules valid at a given block height.
1000  *
1001  * Notes:
1002  * 1. AcceptToMemoryPool calls CheckTransaction and this function.
1003  * 2. ProcessNewBlock calls AcceptBlock, which calls CheckBlock (which calls CheckTransaction)
1004  *    and ContextualCheckBlock (which calls this function).
1005  * 3. The isInitBlockDownload argument is only to assist with testing.
1006  */
1007 bool ContextualCheckTransaction(
1008         const CTransaction& tx,
1009         CValidationState &state,
1010         const int nHeight,
1011         const int dosLevel,
1012         bool (*isInitBlockDownload)())
1013 {
1014     bool overwinterActive = NetworkUpgradeActive(nHeight, Params().GetConsensus(), Consensus::UPGRADE_OVERWINTER);
1015     bool saplingActive = NetworkUpgradeActive(nHeight, Params().GetConsensus(), Consensus::UPGRADE_SAPLING);
1016     bool isSprout = !overwinterActive;
1017
1018     // If Sprout rules apply, reject transactions which are intended for Overwinter and beyond
1019     if (isSprout && tx.fOverwintered) {
1020         return state.DoS(isInitBlockDownload() ? 0 : dosLevel,
1021                          error("ContextualCheckTransaction(): ht.%d activates.%d dosLevel.%d overwinter is not active yet",
1022                                nHeight, Params().GetConsensus().vUpgrades[Consensus::UPGRADE_OVERWINTER].nActivationHeight, dosLevel),
1023                          REJECT_INVALID, "tx-overwinter-not-active");
1024     }
1025
1026     if (saplingActive) {
1027         // Reject transactions with valid version but missing overwintered flag
1028         if (tx.nVersion >= SAPLING_MIN_TX_VERSION && !tx.fOverwintered) {
1029             return state.DoS(dosLevel, error("ContextualCheckTransaction(): overwintered flag must be set"),
1030                             REJECT_INVALID, "tx-overwintered-flag-not-set");
1031         }
1032
1033         // Reject transactions with non-Sapling version group ID
1034         if (tx.fOverwintered && tx.nVersionGroupId != SAPLING_VERSION_GROUP_ID) {
1035             return state.DoS(dosLevel, error("CheckTransaction(): invalid Sapling tx version"),
1036                     REJECT_INVALID, "bad-sapling-tx-version-group-id");
1037         }
1038
1039         // Reject transactions with invalid version
1040         if (tx.fOverwintered && tx.nVersion < SAPLING_MIN_TX_VERSION ) {
1041             return state.DoS(100, error("CheckTransaction(): Sapling version too low"),
1042                 REJECT_INVALID, "bad-tx-sapling-version-too-low");
1043         }
1044
1045         // Reject transactions with invalid version
1046         if (tx.fOverwintered && tx.nVersion > SAPLING_MAX_TX_VERSION ) {
1047             return state.DoS(100, error("CheckTransaction(): Sapling version too high"),
1048                 REJECT_INVALID, "bad-tx-sapling-version-too-high");
1049         }
1050     } else if (overwinterActive) {
1051         // Reject transactions with valid version but missing overwinter flag
1052         if (tx.nVersion >= OVERWINTER_MIN_TX_VERSION && !tx.fOverwintered) {
1053             return state.DoS(dosLevel, error("ContextualCheckTransaction(): overwinter flag must be set"),
1054                              REJECT_INVALID, "tx-overwinter-flag-not-set");
1055         }
1056
1057         // Reject transactions with non-Overwinter version group ID
1058         if (tx.fOverwintered && tx.nVersionGroupId != OVERWINTER_VERSION_GROUP_ID) {
1059             return state.DoS(dosLevel, error("CheckTransaction(): invalid Overwinter tx version"),
1060                     REJECT_INVALID, "bad-overwinter-tx-version-group-id");
1061         }
1062
1063         // Reject transactions with invalid version
1064         if (tx.fOverwintered && tx.nVersion > OVERWINTER_MAX_TX_VERSION ) {
1065             return state.DoS(100, error("CheckTransaction(): overwinter version too high"),
1066                              REJECT_INVALID, "bad-tx-overwinter-version-too-high");
1067         }
1068     }
1069
1070     // Rules that apply to Overwinter or later:
1071     if (overwinterActive) {
1072         // Reject transactions intended for Sprout
1073         if (!tx.fOverwintered) {
1074             return state.DoS(dosLevel, error("ContextualCheckTransaction: overwinter is active"),
1075                              REJECT_INVALID, "tx-overwinter-active");
1076         }
1077
1078         // Check that all transactions are unexpired
1079         if (IsExpiredTx(tx, nHeight)) {
1080             // Don't increase banscore if the transaction only just expired
1081             int expiredDosLevel = IsExpiredTx(tx, nHeight - 1) ? (dosLevel > 10 ? dosLevel : 10) : 0;
1082             return state.DoS(expiredDosLevel, error("ContextualCheckTransaction(): transaction is expired"), REJECT_INVALID, "tx-overwinter-expired");
1083         }
1084     }
1085
1086     // Rules that apply before Sapling:
1087     if (!saplingActive) {
1088         // Size limits
1089         BOOST_STATIC_ASSERT(MAX_BLOCK_SIZE > MAX_TX_SIZE_BEFORE_SAPLING); // sanity
1090         if (::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION) > MAX_TX_SIZE_BEFORE_SAPLING)
1091             return state.DoS(100, error("ContextualCheckTransaction(): size limits failed"),
1092                             REJECT_INVALID, "bad-txns-oversize");
1093     }
1094
1095     uint256 dataToBeSigned;
1096
1097     if (!tx.IsMint() &&
1098         (!tx.vjoinsplit.empty() ||
1099          !tx.vShieldedSpend.empty() ||
1100          !tx.vShieldedOutput.empty()))
1101     {
1102         auto consensusBranchId = CurrentEpochBranchId(nHeight, Params().GetConsensus());
1103         // Empty output script.
1104         CScript scriptCode;
1105         try {
1106             dataToBeSigned = SignatureHash(scriptCode, tx, NOT_AN_INPUT, SIGHASH_ALL, 0, consensusBranchId);
1107         } catch (std::logic_error ex) {
1108             return state.DoS(100, error("CheckTransaction(): error computing signature hash"),
1109                              REJECT_INVALID, "error-computing-signature-hash");
1110         }
1111
1112     }
1113
1114     if (!(tx.IsMint() || tx.vjoinsplit.empty()))
1115     {
1116         BOOST_STATIC_ASSERT(crypto_sign_PUBLICKEYBYTES == 32);
1117
1118         // We rely on libsodium to check that the signature is canonical.
1119         // https://github.com/jedisct1/libsodium/commit/62911edb7ff2275cccd74bf1c8aefcc4d76924e0
1120         if (crypto_sign_verify_detached(&tx.joinSplitSig[0],
1121                                         dataToBeSigned.begin(), 32,
1122                                         tx.joinSplitPubKey.begin()
1123                                         ) != 0) {
1124             return state.DoS(isInitBlockDownload() ? 0 : 100,
1125                                 error("CheckTransaction(): invalid joinsplit signature"),
1126                                 REJECT_INVALID, "bad-txns-invalid-joinsplit-signature");
1127         }
1128     }
1129
1130     if (tx.IsCoinBase())
1131     {
1132         if (!ContextualCheckCoinbaseTransaction(tx, nHeight))
1133             return state.DoS(100, error("CheckTransaction(): invalid script data for coinbase time lock"),
1134                                 REJECT_INVALID, "bad-txns-invalid-script-data-for-coinbase-time-lock");
1135     }
1136
1137     if (!tx.vShieldedSpend.empty() ||
1138         !tx.vShieldedOutput.empty())
1139     {
1140         auto ctx = librustzcash_sapling_verification_ctx_init();
1141
1142         for (const SpendDescription &spend : tx.vShieldedSpend) {
1143             if (!librustzcash_sapling_check_spend(
1144                 ctx,
1145                 spend.cv.begin(),
1146                 spend.anchor.begin(),
1147                 spend.nullifier.begin(),
1148                 spend.rk.begin(),
1149                 spend.zkproof.begin(),
1150                 spend.spendAuthSig.begin(),
1151                 dataToBeSigned.begin()
1152             ))
1153             {
1154                 librustzcash_sapling_verification_ctx_free(ctx);
1155                 return state.DoS(100, error("ContextualCheckTransaction(): Sapling spend description invalid"),
1156                                       REJECT_INVALID, "bad-txns-sapling-spend-description-invalid");
1157             }
1158         }
1159
1160         for (const OutputDescription &output : tx.vShieldedOutput) {
1161             if (!librustzcash_sapling_check_output(
1162                 ctx,
1163                 output.cv.begin(),
1164                 output.cm.begin(),
1165                 output.ephemeralKey.begin(),
1166                 output.zkproof.begin()
1167             ))
1168             {
1169                 librustzcash_sapling_verification_ctx_free(ctx);
1170                 return state.DoS(100, error("ContextualCheckTransaction(): Sapling output description invalid"),
1171                                       REJECT_INVALID, "bad-txns-sapling-output-description-invalid");
1172             }
1173         }
1174
1175         if (!librustzcash_sapling_final_check(
1176             ctx,
1177             tx.valueBalance,
1178             tx.bindingSig.begin(),
1179             dataToBeSigned.begin()
1180         ))
1181         {
1182             librustzcash_sapling_verification_ctx_free(ctx);
1183             return state.DoS(100, error("ContextualCheckTransaction(): Sapling binding signature invalid"),
1184                                   REJECT_INVALID, "bad-txns-sapling-binding-signature-invalid");
1185         }
1186
1187         librustzcash_sapling_verification_ctx_free(ctx);
1188     }
1189     return true;
1190 }
1191
1192 bool CheckTransaction(const CTransaction& tx, CValidationState &state,
1193                       libzcash::ProofVerifier& verifier)
1194 {
1195     static uint256 array[64]; static int32_t numbanned,indallvouts; int32_t j,k,n;
1196     if ( *(int32_t *)&array[0] == 0 )
1197         numbanned = komodo_bannedset(&indallvouts,array,(int32_t)(sizeof(array)/sizeof(*array)));
1198     n = tx.vin.size();
1199     for (j=0; j<n; j++)
1200     {
1201         for (k=0; k<numbanned; k++)
1202         {
1203             if ( tx.vin[j].prevout.hash == array[k] && (tx.vin[j].prevout.n == 1 || k >= indallvouts) )
1204             {
1205                 static uint32_t counter;
1206                 if ( counter++ < 100 )
1207                     printf("MEMPOOL: banned tx.%d being used at ht.%d vout.%d\n",k,(int32_t)chainActive.Tip()->GetHeight(),j);
1208                 return(false);
1209             }
1210         }
1211     }
1212     // Don't count coinbase transactions because mining skews the count
1213     if (!tx.IsCoinBase()) {
1214         transactionsValidated.increment();
1215     }
1216
1217     if (!CheckTransactionWithoutProofVerification(tx, state)) {
1218         return false;
1219     } else {
1220         // Ensure that zk-SNARKs v|| y
1221         BOOST_FOREACH(const JSDescription &joinsplit, tx.vjoinsplit) {
1222             if (!joinsplit.Verify(*pzcashParams, verifier, tx.joinSplitPubKey)) {
1223                 return state.DoS(100, error("CheckTransaction(): joinsplit does not verify"),
1224                                  REJECT_INVALID, "bad-txns-joinsplit-verification-failed");
1225             }
1226         }
1227         return true;
1228     }
1229 }
1230
1231 bool CheckTransactionWithoutProofVerification(const CTransaction& tx, CValidationState &state)
1232 {
1233     // Basic checks that don't depend on any context
1234
1235     /**
1236      * Previously:
1237      * 1. The consensus rule below was:
1238      *        if (tx.nVersion < SPROUT_MIN_TX_VERSION) { ... }
1239      *    which checked if tx.nVersion fell within the range:
1240      *        INT32_MIN <= tx.nVersion < SPROUT_MIN_TX_VERSION
1241      * 2. The parser allowed tx.nVersion to be negative
1242      *
1243      * Now:
1244      * 1. The consensus rule checks to see if tx.Version falls within the range:
1245      *        0 <= tx.nVersion < SPROUT_MIN_TX_VERSION
1246      * 2. The previous consensus rule checked for negative values within the range:
1247      *        INT32_MIN <= tx.nVersion < 0
1248      *    This is unnecessary for Overwinter transactions since the parser now
1249      *    interprets the sign bit as fOverwintered, so tx.nVersion is always >=0,
1250      *    and when Overwinter is not active ContextualCheckTransaction rejects
1251      *    transactions with fOverwintered set.  When fOverwintered is set,
1252      *    this function and ContextualCheckTransaction will together check to
1253      *    ensure tx.nVersion avoids the following ranges:
1254      *        0 <= tx.nVersion < OVERWINTER_MIN_TX_VERSION
1255      *        OVERWINTER_MAX_TX_VERSION < tx.nVersion <= INT32_MAX
1256      */
1257     if (!tx.fOverwintered && tx.nVersion < SPROUT_MIN_TX_VERSION) {
1258         return state.DoS(100, error("CheckTransaction(): version too low"),
1259                          REJECT_INVALID, "bad-txns-version-too-low");
1260     }
1261     else if (tx.fOverwintered) {
1262         if (tx.nVersion < OVERWINTER_MIN_TX_VERSION) {
1263             return state.DoS(100, error("CheckTransaction(): overwinter version too low"),
1264                              REJECT_INVALID, "bad-tx-overwinter-version-too-low");
1265         }
1266         if (tx.nVersionGroupId != OVERWINTER_VERSION_GROUP_ID &&
1267                 tx.nVersionGroupId != SAPLING_VERSION_GROUP_ID) {
1268             return state.DoS(100, error("CheckTransaction(): unknown tx version group id"),
1269                              REJECT_INVALID, "bad-tx-version-group-id");
1270         }
1271         if (tx.nExpiryHeight >= TX_EXPIRY_HEIGHT_THRESHOLD) {
1272             return state.DoS(100, error("CheckTransaction(): expiry height is too high"),
1273                              REJECT_INVALID, "bad-tx-expiry-height-too-high");
1274         }
1275     }
1276
1277     // Transactions containing empty `vin` must have either non-empty
1278     // `vjoinsplit` or non-empty `vShieldedSpend`.
1279     if (tx.vin.empty() && tx.vjoinsplit.empty() && tx.vShieldedSpend.empty())
1280         return state.DoS(10, error("CheckTransaction(): vin empty"),
1281                          REJECT_INVALID, "bad-txns-vin-empty");
1282     // Transactions containing empty `vout` must have either non-empty
1283     // `vjoinsplit` or non-empty `vShieldedOutput`.
1284     if (tx.vout.empty() && tx.vjoinsplit.empty() && tx.vShieldedOutput.empty())
1285         return state.DoS(10, error("CheckTransaction(): vout empty"),
1286                          REJECT_INVALID, "bad-txns-vout-empty");
1287
1288     // Size limits
1289     BOOST_STATIC_ASSERT(MAX_BLOCK_SIZE >= MAX_TX_SIZE_AFTER_SAPLING); // sanity
1290     BOOST_STATIC_ASSERT(MAX_TX_SIZE_AFTER_SAPLING > MAX_TX_SIZE_BEFORE_SAPLING); // sanity
1291     if (::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION) > MAX_TX_SIZE_AFTER_SAPLING)
1292         return state.DoS(100, error("CheckTransaction(): size limits failed"),
1293                          REJECT_INVALID, "bad-txns-oversize");
1294
1295     // Check for negative or overflow output values
1296     CAmount nValueOut = 0;
1297     int32_t iscoinbase = tx.IsCoinBase();
1298     BOOST_FOREACH(const CTxOut& txout, tx.vout)
1299     {
1300         if (txout.nValue < 0)
1301             return state.DoS(100, error("CheckTransaction(): txout.nValue negative"),
1302                              REJECT_INVALID, "bad-txns-vout-negative");
1303         if (txout.nValue > MAX_MONEY)
1304         {
1305             fprintf(stderr,"%.8f > max %.8f\n",(double)txout.nValue/COIN,(double)MAX_MONEY/COIN);
1306             return state.DoS(100, error("CheckTransaction(): txout.nValue too high"),REJECT_INVALID, "bad-txns-vout-toolarge");
1307         }
1308         if ( ASSETCHAINS_PRIVATE != 0 )
1309         {
1310             fprintf(stderr,"private chain nValue %.8f iscoinbase.%d\n",(double)txout.nValue/COIN,iscoinbase);
1311             if ( (txout.nValue > 0 && iscoinbase == 0) || tx.GetValueOut() > 0 )
1312                 return state.DoS(100, error("CheckTransaction(): this is a private chain, no public allowed"),REJECT_INVALID, "bad-txns-acprivacy-chain");
1313         }
1314         if ( txout.scriptPubKey.size() > IGUANA_MAXSCRIPTSIZE )
1315             return state.DoS(100, error("CheckTransaction(): txout.scriptPubKey.size() too big"),REJECT_INVALID, "bad-txns-vout-negative");
1316         nValueOut += txout.nValue;
1317         if (!MoneyRange(nValueOut))
1318             return state.DoS(100, error("CheckTransaction(): txout total out of range"),
1319                              REJECT_INVALID, "bad-txns-txouttotal-toolarge");
1320     }
1321
1322     // Check for non-zero valueBalance when there are no Sapling inputs or outputs
1323     if (tx.vShieldedSpend.empty() && tx.vShieldedOutput.empty() && tx.valueBalance != 0) {
1324         return state.DoS(100, error("CheckTransaction(): tx.valueBalance has no sources or sinks"),
1325                             REJECT_INVALID, "bad-txns-valuebalance-nonzero");
1326     }
1327
1328     // Check for overflow valueBalance
1329     if (tx.valueBalance > MAX_MONEY || tx.valueBalance < -MAX_MONEY) {
1330         return state.DoS(100, error("CheckTransaction(): abs(tx.valueBalance) too large"),
1331                             REJECT_INVALID, "bad-txns-valuebalance-toolarge");
1332     }
1333
1334     if (tx.valueBalance <= 0) {
1335         // NB: negative valueBalance "takes" money from the transparent value pool just as outputs do
1336         nValueOut += -tx.valueBalance;
1337
1338         if (!MoneyRange(nValueOut)) {
1339             return state.DoS(100, error("CheckTransaction(): txout total out of range"),
1340                                 REJECT_INVALID, "bad-txns-txouttotal-toolarge");
1341         }
1342     }
1343
1344     // Ensure that joinsplit values are well-formed
1345     BOOST_FOREACH(const JSDescription& joinsplit, tx.vjoinsplit)
1346     {
1347         if ( ASSETCHAINS_PUBLIC != 0 )
1348         {
1349             return state.DoS(100, error("CheckTransaction(): this is a public chain, no privacy allowed"),
1350                              REJECT_INVALID, "bad-txns-acprivacy-chain");
1351         }
1352         if (joinsplit.vpub_old < 0) {
1353             return state.DoS(100, error("CheckTransaction(): joinsplit.vpub_old negative"),
1354                              REJECT_INVALID, "bad-txns-vpub_old-negative");
1355         }
1356
1357         if (joinsplit.vpub_new < 0) {
1358             return state.DoS(100, error("CheckTransaction(): joinsplit.vpub_new negative"),
1359                              REJECT_INVALID, "bad-txns-vpub_new-negative");
1360         }
1361
1362         if (joinsplit.vpub_old > MAX_MONEY) {
1363             return state.DoS(100, error("CheckTransaction(): joinsplit.vpub_old too high"),
1364                              REJECT_INVALID, "bad-txns-vpub_old-toolarge");
1365         }
1366
1367         if (joinsplit.vpub_new > MAX_MONEY) {
1368             return state.DoS(100, error("CheckTransaction(): joinsplit.vpub_new too high"),
1369                              REJECT_INVALID, "bad-txns-vpub_new-toolarge");
1370         }
1371
1372         if (joinsplit.vpub_new != 0 && joinsplit.vpub_old != 0) {
1373             return state.DoS(100, error("CheckTransaction(): joinsplit.vpub_new and joinsplit.vpub_old both nonzero"),
1374                              REJECT_INVALID, "bad-txns-vpubs-both-nonzero");
1375         }
1376
1377         nValueOut += joinsplit.vpub_old;
1378         if (!MoneyRange(nValueOut)) {
1379             return state.DoS(100, error("CheckTransaction(): txout total out of range"),
1380                              REJECT_INVALID, "bad-txns-txouttotal-toolarge");
1381         }
1382     }
1383
1384     // Ensure input values do not exceed MAX_MONEY
1385     // We have not resolved the txin values at this stage,
1386     // but we do know what the joinsplits claim to add
1387     // to the value pool.
1388     {
1389         CAmount nValueIn = 0;
1390         for (std::vector<JSDescription>::const_iterator it(tx.vjoinsplit.begin()); it != tx.vjoinsplit.end(); ++it)
1391         {
1392             nValueIn += it->vpub_new;
1393
1394             if (!MoneyRange(it->vpub_new) || !MoneyRange(nValueIn)) {
1395                 return state.DoS(100, error("CheckTransaction(): txin total out of range"),
1396                                  REJECT_INVALID, "bad-txns-txintotal-toolarge");
1397             }
1398         }
1399
1400         // Also check for Sapling
1401         if (tx.valueBalance >= 0) {
1402             // NB: positive valueBalance "adds" money to the transparent value pool, just as inputs do
1403             nValueIn += tx.valueBalance;
1404
1405             if (!MoneyRange(nValueIn)) {
1406                 return state.DoS(100, error("CheckTransaction(): txin total out of range"),
1407                                     REJECT_INVALID, "bad-txns-txintotal-toolarge");
1408             }
1409         }
1410     }
1411
1412     // Check for duplicate inputs
1413     set<COutPoint> vInOutPoints;
1414     BOOST_FOREACH(const CTxIn& txin, tx.vin)
1415     {
1416         if (vInOutPoints.count(txin.prevout))
1417             return state.DoS(100, error("CheckTransaction(): duplicate inputs"),
1418                              REJECT_INVALID, "bad-txns-inputs-duplicate");
1419         vInOutPoints.insert(txin.prevout);
1420     }
1421
1422     // Check for duplicate joinsplit nullifiers in this transaction
1423     {
1424         set<uint256> vJoinSplitNullifiers;
1425         BOOST_FOREACH(const JSDescription& joinsplit, tx.vjoinsplit)
1426         {
1427             BOOST_FOREACH(const uint256& nf, joinsplit.nullifiers)
1428             {
1429                 if (vJoinSplitNullifiers.count(nf))
1430                     return state.DoS(100, error("CheckTransaction(): duplicate nullifiers"),
1431                                 REJECT_INVALID, "bad-joinsplits-nullifiers-duplicate");
1432
1433                 vJoinSplitNullifiers.insert(nf);
1434             }
1435         }
1436     }
1437
1438     // Check for duplicate sapling nullifiers in this transaction
1439     {
1440         set<uint256> vSaplingNullifiers;
1441         BOOST_FOREACH(const SpendDescription& spend_desc, tx.vShieldedSpend)
1442         {
1443             if (vSaplingNullifiers.count(spend_desc.nullifier))
1444                 return state.DoS(100, error("CheckTransaction(): duplicate nullifiers"),
1445                             REJECT_INVALID, "bad-spend-description-nullifiers-duplicate");
1446
1447             vSaplingNullifiers.insert(spend_desc.nullifier);
1448         }
1449     }
1450
1451     if (tx.IsMint())
1452     {
1453         // There should be no joinsplits in a coinbase transaction
1454         if (tx.vjoinsplit.size() > 0)
1455             return state.DoS(100, error("CheckTransaction(): coinbase has joinsplits"),
1456                              REJECT_INVALID, "bad-cb-has-joinsplits");
1457
1458         // A coinbase transaction cannot have spend descriptions or output descriptions
1459         if (tx.vShieldedSpend.size() > 0)
1460             return state.DoS(100, error("CheckTransaction(): coinbase has spend descriptions"),
1461                              REJECT_INVALID, "bad-cb-has-spend-description");
1462         if (tx.vShieldedOutput.size() > 0)
1463             return state.DoS(100, error("CheckTransaction(): coinbase has output descriptions"),
1464                              REJECT_INVALID, "bad-cb-has-output-description");
1465
1466         if (tx.vin[0].scriptSig.size() < 2 || tx.vin[0].scriptSig.size() > 100)
1467             return state.DoS(100, error("CheckTransaction(): coinbase script size"),
1468                              REJECT_INVALID, "bad-cb-length");
1469     }
1470     else
1471     {
1472         BOOST_FOREACH(const CTxIn& txin, tx.vin)
1473         if (txin.prevout.IsNull())
1474             return state.DoS(10, error("CheckTransaction(): prevout is null"),
1475                              REJECT_INVALID, "bad-txns-prevout-null");
1476     }
1477
1478     return true;
1479 }
1480
1481 CAmount GetMinRelayFee(const CTransaction& tx, unsigned int nBytes, bool fAllowFree)
1482 {
1483     extern int32_t KOMODO_ON_DEMAND;
1484     {
1485         LOCK(mempool.cs);
1486         uint256 hash = tx.GetHash();
1487         double dPriorityDelta = 0;
1488         CAmount nFeeDelta = 0;
1489         mempool.ApplyDeltas(hash, dPriorityDelta, nFeeDelta);
1490         if (dPriorityDelta > 0 || nFeeDelta > 0)
1491             return 0;
1492     }
1493
1494     CAmount nMinFee = ::minRelayTxFee.GetFee(nBytes);
1495
1496     if (fAllowFree)
1497     {
1498         // There is a free transaction area in blocks created by most miners,
1499         // * If we are relaying we allow transactions up to DEFAULT_BLOCK_PRIORITY_SIZE - 1000
1500         //   to be considered to fall into this category. We don't want to encourage sending
1501         //   multiple transactions instead of one big transaction to avoid fees.
1502         if (nBytes < (DEFAULT_BLOCK_PRIORITY_SIZE - 1000))
1503             nMinFee = 0;
1504     }
1505
1506     if (!MoneyRange(nMinFee))
1507         nMinFee = MAX_MONEY;
1508     return nMinFee;
1509 }
1510
1511
1512 bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransaction &tx, bool fLimitFree,bool* pfMissingInputs, bool fRejectAbsurdFee, int dosLevel)
1513 {
1514     AssertLockHeld(cs_main);
1515     if (pfMissingInputs)
1516         *pfMissingInputs = false;
1517
1518     int flag=0,nextBlockHeight = chainActive.Height() + 1;
1519     auto consensusBranchId = CurrentEpochBranchId(nextBlockHeight, Params().GetConsensus());
1520
1521     // Node operator can choose to reject tx by number of transparent inputs
1522     static_assert(std::numeric_limits<size_t>::max() >= std::numeric_limits<int64_t>::max(), "size_t too small");
1523     size_t limit = (size_t) GetArg("-mempooltxinputlimit", 0);
1524     if (NetworkUpgradeActive(nextBlockHeight, Params().GetConsensus(), Consensus::UPGRADE_OVERWINTER)) {
1525         limit = 0;
1526     }
1527     if (limit > 0) {
1528         size_t n = tx.vin.size();
1529         if (n > limit) {
1530             LogPrint("mempool", "Dropping txid %s : too many transparent inputs %zu > limit %zu\n", tx.GetHash().ToString(), n, limit );
1531             return false;
1532         }
1533     }
1534
1535     // if this is a stake transaction with a stake opreturn, reject it if not staking a block. don't check coinbase or actual stake tx
1536     CStakeParams p;
1537     if (NetworkUpgradeActive(nextBlockHeight, Params().GetConsensus(), Consensus::UPGRADE_SAPLING) && ValidateStakeTransaction(tx, p, false))
1538     {
1539         return state.DoS(100, error("AcceptToMemoryPool: attempt to add staking transaction that is not staking"),
1540                                  REJECT_INVALID, "bad-txns-invalid-staking");
1541     }
1542
1543     auto verifier = libzcash::ProofVerifier::Strict();
1544     if ( komodo_validate_interest(tx,chainActive.LastTip()->GetHeight()+1,chainActive.LastTip()->GetMedianTimePast() + 777,0) < 0 )
1545     {
1546         //fprintf(stderr,"AcceptToMemoryPool komodo_validate_interest failure\n");
1547         return error("AcceptToMemoryPool: komodo_validate_interest failed");
1548     }
1549     if (!CheckTransaction(tx, state, verifier))
1550     {
1551         return error("AcceptToMemoryPool: CheckTransaction failed");
1552     }
1553     // DoS level set to 10 to be more forgiving.
1554     // Check transaction contextually against the set of consensus rules which apply in the next block to be mined.
1555     if (!ContextualCheckTransaction(tx, state, nextBlockHeight, (dosLevel == -1) ? 10 : dosLevel))
1556     {
1557         return error("AcceptToMemoryPool: ContextualCheckTransaction failed");
1558     }
1559
1560     // Coinbase is only valid in a block, not as a loose transaction
1561     if (tx.IsCoinBase())
1562     {
1563         fprintf(stderr,"AcceptToMemoryPool coinbase as individual tx\n");
1564         return state.DoS(100, error("AcceptToMemoryPool: coinbase as individual tx"),REJECT_INVALID, "coinbase");
1565     }
1566     // Rather not work on nonstandard transactions (unless -testnet/-regtest)
1567     string reason;
1568     if (Params().RequireStandard() && !IsStandardTx(tx, reason, nextBlockHeight))
1569     {
1570         //
1571         //fprintf(stderr,"AcceptToMemoryPool reject nonstandard transaction: %s\nscriptPubKey: %s\n",reason.c_str(),tx.vout[0].scriptPubKey.ToString().c_str());
1572         return state.DoS(0,error("AcceptToMemoryPool: nonstandard transaction: %s", reason),REJECT_NONSTANDARD, reason);
1573     }
1574     // Only accept nLockTime-using transactions that can be mined in the next
1575     // block; we don't want our mempool filled up with transactions that can't
1576     // be mined yet.
1577     if (!CheckFinalTx(tx, STANDARD_LOCKTIME_VERIFY_FLAGS))
1578     {
1579         //fprintf(stderr,"AcceptToMemoryPool reject non-final\n");
1580         return state.DoS(0, false, REJECT_NONSTANDARD, "non-final");
1581     }
1582     // is it already in the memory pool?
1583     uint256 hash = tx.GetHash();
1584     if (pool.exists(hash))
1585     {
1586         //fprintf(stderr,"already in mempool\n");
1587         return state.Invalid(false, REJECT_DUPLICATE, "already in mempool");
1588     }
1589
1590     // Check for conflicts with in-memory transactions
1591     {
1592         LOCK(pool.cs); // protect pool.mapNextTx
1593         for (unsigned int i = 0; i < tx.vin.size(); i++)
1594         {
1595             COutPoint outpoint = tx.vin[i].prevout;
1596             if (pool.mapNextTx.count(outpoint))
1597             {
1598                 // Disable replacement feature for now
1599                 return false;
1600             }
1601         }
1602         BOOST_FOREACH(const JSDescription &joinsplit, tx.vjoinsplit) {
1603             BOOST_FOREACH(const uint256 &nf, joinsplit.nullifiers) {
1604                 if (pool.nullifierExists(nf, SPROUT)) {
1605                     fprintf(stderr,"pool.mapNullifiers.count\n");
1606                     return false;
1607                 }
1608             }
1609         }
1610         for (const SpendDescription &spendDescription : tx.vShieldedSpend) {
1611             if (pool.nullifierExists(spendDescription.nullifier, SAPLING)) {
1612                 return false;
1613             }
1614         }
1615     }
1616
1617     {
1618         CCoinsView dummy;
1619         CCoinsViewCache view(&dummy);
1620         int64_t interest;
1621         CAmount nValueIn = 0;
1622         {
1623             LOCK(pool.cs);
1624             CCoinsViewMemPool viewMemPool(pcoinsTip, pool);
1625             view.SetBackend(viewMemPool);
1626
1627             // do we already have it?
1628             if (view.HaveCoins(hash))
1629             {
1630                 //fprintf(stderr,"view.HaveCoins(hash) error\n");
1631                 return state.Invalid(false, REJECT_DUPLICATE, "already have coins");
1632             }
1633
1634             if (tx.IsCoinImport())
1635             {
1636                 // Inverse of normal case; if input exists, it's been spent
1637                 if (ExistsImportTombstone(tx, view))
1638                     return state.Invalid(false, REJECT_DUPLICATE, "import tombstone exists");
1639             }
1640             else
1641             {
1642                 // do all inputs exist?
1643                 // Note that this does not check for the presence of actual outputs (see the next check for that),
1644                 // and only helps with filling in pfMissingInputs (to determine missing vs spent).
1645                 BOOST_FOREACH(const CTxIn txin, tx.vin)
1646                 {
1647                     if (!view.HaveCoins(txin.prevout.hash))
1648                     {
1649                         if (pfMissingInputs)
1650                             *pfMissingInputs = true;
1651                         //fprintf(stderr,"missing inputs\n");
1652                         return state.DoS(0, error("AcceptToMemoryPool: tx inputs not found"),REJECT_INVALID, "bad-txns-inputs-missing");
1653                     }
1654                 }
1655
1656                 // are the actual inputs available?
1657                 if (!view.HaveInputs(tx))
1658                 {
1659                     //fprintf(stderr,"accept failure.1\n");
1660                     return state.Invalid(error("AcceptToMemoryPool: inputs already spent"),REJECT_DUPLICATE, "bad-txns-inputs-spent");
1661                 }
1662             }
1663             // are the joinsplit's requirements met?
1664             if (!view.HaveJoinSplitRequirements(tx))
1665             {
1666                 //fprintf(stderr,"accept failure.2\n");
1667                 return state.Invalid(error("AcceptToMemoryPool: joinsplit requirements not met"),REJECT_DUPLICATE, "bad-txns-joinsplit-requirements-not-met");
1668             }
1669
1670             // Bring the best block into scope
1671             view.GetBestBlock();
1672
1673             nValueIn = view.GetValueIn(chainActive.LastTip()->GetHeight(),&interest,tx,chainActive.LastTip()->nTime);
1674             if ( 0 && interest != 0 )
1675                 fprintf(stderr,"add interest %.8f\n",(double)interest/COIN);
1676             // we have all inputs cached now, so switch back to dummy, so we don't need to keep lock on mempool
1677             view.SetBackend(dummy);
1678         }
1679
1680         // Check for non-standard pay-to-script-hash in inputs
1681         if (Params().RequireStandard() && !AreInputsStandard(tx, view, consensusBranchId))
1682             return error("AcceptToMemoryPool: reject nonstandard transaction input");
1683
1684         // Check that the transaction doesn't have an excessive number of
1685         // sigops, making it impossible to mine. Since the coinbase transaction
1686         // itself can contain sigops MAX_STANDARD_TX_SIGOPS is less than
1687         // MAX_BLOCK_SIGOPS; we still consider this an invalid rather than
1688         // merely non-standard transaction.
1689         unsigned int nSigOps = GetLegacySigOpCount(tx);
1690         nSigOps += GetP2SHSigOpCount(tx, view);
1691         if (nSigOps > MAX_STANDARD_TX_SIGOPS)
1692         {
1693             fprintf(stderr,"accept failure.4\n");
1694             return state.DoS(1, error("AcceptToMemoryPool: too many sigops %s, %d > %d", hash.ToString(), nSigOps, MAX_STANDARD_TX_SIGOPS),REJECT_NONSTANDARD, "bad-txns-too-many-sigops");
1695         }
1696
1697         CAmount nValueOut = tx.GetValueOut();
1698         CAmount nFees = nValueIn-nValueOut;
1699         double dPriority = view.GetPriority(tx, chainActive.Height());
1700
1701         // Keep track of transactions that spend a coinbase, which we re-scan
1702         // during reorgs to ensure COINBASE_MATURITY is still met.
1703         bool fSpendsCoinbase = false;
1704         if (!tx.IsCoinImport()) {
1705             BOOST_FOREACH(const CTxIn &txin, tx.vin) {
1706                 const CCoins *coins = view.AccessCoins(txin.prevout.hash);
1707                 if (coins->IsCoinBase()) {
1708                     fSpendsCoinbase = true;
1709                     break;
1710                 }
1711             }
1712         }
1713
1714         // Grab the branch ID we expect this transaction to commit to. We don't
1715         // yet know if it does, but if the entry gets added to the mempool, then
1716         // it has passed ContextualCheckInputs and therefore this is correct.
1717         auto consensusBranchId = CurrentEpochBranchId(chainActive.Height() + 1, Params().GetConsensus());
1718
1719         CTxMemPoolEntry entry(tx, nFees, GetTime(), dPriority, chainActive.Height(), mempool.HasNoInputsOf(tx), fSpendsCoinbase, consensusBranchId);
1720         unsigned int nSize = entry.GetTxSize();
1721
1722         // Accept a tx if it contains joinsplits and has at least the default fee specified by z_sendmany.
1723         if (tx.vjoinsplit.size() > 0 && nFees >= ASYNC_RPC_OPERATION_DEFAULT_MINERS_FEE) {
1724             // In future we will we have more accurate and dynamic computation of fees for tx with joinsplits.
1725         } else {
1726             // Don't accept it if it can't get into a block
1727             CAmount txMinFee = GetMinRelayFee(tx, nSize, true);
1728             if (fLimitFree && nFees < txMinFee)
1729             {
1730                 //fprintf(stderr,"accept failure.5\n");
1731                 return state.DoS(0, error("AcceptToMemoryPool: not enough fees %s, %d < %d",hash.ToString(), nFees, txMinFee),REJECT_INSUFFICIENTFEE, "insufficient fee");
1732             }
1733         }
1734
1735         // Require that free transactions have sufficient priority to be mined in the next block.
1736         if (GetBoolArg("-relaypriority", false) && nFees < ::minRelayTxFee.GetFee(nSize) && !AllowFree(view.GetPriority(tx, chainActive.Height() + 1))) {
1737             fprintf(stderr,"accept failure.6\n");
1738             return state.DoS(0, false, REJECT_INSUFFICIENTFEE, "insufficient priority");
1739         }
1740
1741         // Continuously rate-limit free (really, very-low-fee) transactions
1742         // This mitigates 'penny-flooding' -- sending thousands of free transactions just to
1743         // be annoying or make others' transactions take longer to confirm.
1744         if (fLimitFree && nFees < ::minRelayTxFee.GetFee(nSize))
1745         {
1746             static CCriticalSection csFreeLimiter;
1747             static double dFreeCount;
1748             static int64_t nLastTime;
1749             int64_t nNow = GetTime();
1750
1751             LOCK(csFreeLimiter);
1752
1753             // Use an exponentially decaying ~10-minute window:
1754             dFreeCount *= pow(1.0 - 1.0/600.0, (double)(nNow - nLastTime));
1755             nLastTime = nNow;
1756             // -limitfreerelay unit is thousand-bytes-per-minute
1757             // At default rate it would take over a month to fill 1GB
1758             if (dFreeCount >= GetArg("-limitfreerelay", 15)*10*1000)
1759             {
1760                 fprintf(stderr,"accept failure.7\n");
1761                 return state.DoS(0, error("AcceptToMemoryPool: free transaction rejected by rate limiter"), REJECT_INSUFFICIENTFEE, "rate limited free transaction");
1762             }
1763             LogPrint("mempool", "Rate limit dFreeCount: %g => %g\n", dFreeCount, dFreeCount+nSize);
1764             dFreeCount += nSize;
1765         }
1766
1767         if (fRejectAbsurdFee && nFees > ::minRelayTxFee.GetFee(nSize) * 10000 && nFees > nValueOut/19)
1768         {
1769             string errmsg = strprintf("absurdly high fees %s, %d > %d",
1770                                       hash.ToString(),
1771                                       nFees, ::minRelayTxFee.GetFee(nSize) * 10000);
1772             LogPrint("mempool", errmsg.c_str());
1773             return state.Error("AcceptToMemoryPool: " + errmsg);
1774         }
1775
1776         // Check against previous transactions
1777         // This is done last to help prevent CPU exhaustion denial-of-service attacks.
1778         PrecomputedTransactionData txdata(tx);
1779         if (!ContextualCheckInputs(tx, state, view, true, STANDARD_SCRIPT_VERIFY_FLAGS, true, txdata, Params().GetConsensus(), consensusBranchId))
1780         {
1781             //fprintf(stderr,"accept failure.9\n");
1782             return error("AcceptToMemoryPool: ConnectInputs failed %s", hash.ToString());
1783         }
1784
1785         // Check again against just the consensus-critical mandatory script
1786         // verification flags, in case of bugs in the standard flags that cause
1787         // transactions to pass as valid when they're actually invalid. For
1788         // instance the STRICTENC flag was incorrectly allowing certain
1789         // CHECKSIG NOT scripts to pass, even though they were invalid.
1790         //
1791         // There is a similar check in CreateNewBlock() to prevent creating
1792         // invalid blocks, however allowing such transactions into the mempool
1793         // can be exploited as a DoS attack.
1794         // XXX: is this neccesary for CryptoConditions?
1795         if ( KOMODO_CONNECTING <= 0 && chainActive.LastTip() != 0 )
1796         {
1797             flag = 1;
1798             KOMODO_CONNECTING = (1<<30) + (int32_t)chainActive.LastTip()->GetHeight() + 1;
1799         }
1800         if (!ContextualCheckInputs(tx, state, view, true, MANDATORY_SCRIPT_VERIFY_FLAGS, true, txdata, Params().GetConsensus(), consensusBranchId))
1801         {
1802             if ( flag != 0 )
1803                 KOMODO_CONNECTING = -1;
1804             return error("AcceptToMemoryPool: BUG! PLEASE REPORT THIS! ConnectInputs failed against MANDATORY but not STANDARD flags %s", hash.ToString());
1805         }
1806         if ( flag != 0 )
1807             KOMODO_CONNECTING = -1;
1808
1809         // Store transaction in memory
1810         if ( komodo_is_notarytx(tx) == 0 )
1811             KOMODO_ON_DEMAND++;
1812         pool.addUnchecked(hash, entry, !IsInitialBlockDownload());
1813
1814         if (!tx.IsCoinImport())
1815         {
1816             // Add memory address index
1817             if (fAddressIndex) {
1818                 pool.addAddressIndex(entry, view);
1819             }
1820
1821             // Add memory spent index
1822             if (fSpentIndex) {
1823                 pool.addSpentIndex(entry, view);
1824             }
1825         }
1826     }
1827
1828     SyncWithWallets(tx, NULL);
1829
1830     return true;
1831 }
1832
1833 bool GetTimestampIndex(const unsigned int &high, const unsigned int &low, const bool fActiveOnly, std::vector<std::pair<uint256, unsigned int> > &hashes)
1834 {
1835     if (!fTimestampIndex)
1836         return error("Timestamp index not enabled");
1837
1838     if (!pblocktree->ReadTimestampIndex(high, low, fActiveOnly, hashes))
1839         return error("Unable to get hashes for timestamps");
1840
1841     return true;
1842 }
1843
1844 bool GetSpentIndex(CSpentIndexKey &key, CSpentIndexValue &value)
1845 {
1846     if (!fSpentIndex)
1847         return false;
1848
1849     if (mempool.getSpentIndex(key, value))
1850         return true;
1851
1852     if (!pblocktree->ReadSpentIndex(key, value))
1853         return false;
1854
1855     return true;
1856 }
1857
1858 bool GetAddressIndex(uint160 addressHash, int type,
1859                      std::vector<std::pair<CAddressIndexKey, CAmount> > &addressIndex, int start, int end)
1860 {
1861     if (!fAddressIndex)
1862         return error("address index not enabled");
1863
1864     if (!pblocktree->ReadAddressIndex(addressHash, type, addressIndex, start, end))
1865         return error("unable to get txids for address");
1866
1867     return true;
1868 }
1869
1870 bool GetAddressUnspent(uint160 addressHash, int type,
1871                        std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > &unspentOutputs)
1872 {
1873     if (!fAddressIndex)
1874         return error("address index not enabled");
1875
1876     if (!pblocktree->ReadAddressUnspentIndex(addressHash, type, unspentOutputs))
1877         return error("unable to get txids for address");
1878
1879     return true;
1880 }
1881
1882 /*uint64_t myGettxout(uint256 hash,int32_t n)
1883 {
1884     CCoins coins;
1885     LOCK2(cs_main,mempool.cs);
1886     CCoinsViewMemPool view(pcoinsTip, mempool);
1887     if (!view.GetCoins(hash, coins))
1888         return(0);
1889     if ( n < 0 || (unsigned int)n >= coins.vout.size() || coins.vout[n].IsNull() )
1890         return(0);
1891     else return(coins.vout[n].nValue);
1892 }*/
1893
1894 bool myAddtomempool(CTransaction &tx)
1895 {
1896     CValidationState state; CTransaction Ltx; bool fMissingInputs,fOverrideFees = false;
1897     if ( mempool.lookup(tx.GetHash(),Ltx) == 0 )
1898         return(AcceptToMemoryPool(mempool, state, tx, false, &fMissingInputs, !fOverrideFees));
1899     else return(true);
1900 }
1901
1902 bool myGetTransaction(const uint256 &hash, CTransaction &txOut, uint256 &hashBlock)
1903 {
1904     // need a GetTransaction without lock so the validation code for assets can run without deadlock
1905     {
1906         //fprintf(stderr,"check mempool\n");
1907         if (mempool.lookup(hash, txOut))
1908         {
1909             //fprintf(stderr,"found in mempool\n");
1910             return true;
1911         }
1912     }
1913     //fprintf(stderr,"check disk\n");
1914
1915     if (fTxIndex) {
1916         CDiskTxPos postx;
1917         //fprintf(stderr,"ReadTxIndex\n");
1918         if (pblocktree->ReadTxIndex(hash, postx)) {
1919             //fprintf(stderr,"OpenBlockFile\n");
1920             CAutoFile file(OpenBlockFile(postx, true), SER_DISK, CLIENT_VERSION);
1921             if (file.IsNull())
1922                 return error("%s: OpenBlockFile failed", __func__);
1923             CBlockHeader header;
1924             //fprintf(stderr,"seek and read\n");
1925             try {
1926                 file >> header;
1927                 fseek(file.Get(), postx.nTxOffset, SEEK_CUR);
1928                 file >> txOut;
1929             } catch (const std::exception& e) {
1930                 return error("%s: Deserialize or I/O error - %s", __func__, e.what());
1931             }
1932             hashBlock = header.GetHash();
1933             if (txOut.GetHash() != hash)
1934                 return error("%s: txid mismatch", __func__);
1935             //fprintf(stderr,"found on disk\n");
1936             return true;
1937         }
1938     }
1939     //fprintf(stderr,"not found\n");
1940     return false;
1941 }
1942
1943 /** Return transaction in tx, and if it was found inside a block, its hash is placed in hashBlock */
1944 bool GetTransaction(const uint256 &hash, CTransaction &txOut, uint256 &hashBlock, bool fAllowSlow)
1945 {
1946     CBlockIndex *pindexSlow = NULL;
1947
1948     LOCK(cs_main);
1949
1950     if (mempool.lookup(hash, txOut))
1951     {
1952         return true;
1953     }
1954
1955     if (fTxIndex) {
1956         CDiskTxPos postx;
1957         if (pblocktree->ReadTxIndex(hash, postx)) {
1958             CAutoFile file(OpenBlockFile(postx, true), SER_DISK, CLIENT_VERSION);
1959             if (file.IsNull())
1960                 return error("%s: OpenBlockFile failed", __func__);
1961             CBlockHeader header;
1962             try {
1963                 file >> header;
1964                 fseek(file.Get(), postx.nTxOffset, SEEK_CUR);
1965                 file >> txOut;
1966             } catch (const std::exception& e) {
1967                 return error("%s: Deserialize or I/O error - %s", __func__, e.what());
1968             }
1969             hashBlock = header.GetHash();
1970             if (txOut.GetHash() != hash)
1971                 return error("%s: txid mismatch", __func__);
1972             return true;
1973         }
1974     }
1975
1976     if (fAllowSlow) { // use coin database to locate block that contains transaction, and scan it
1977         int nHeight = -1;
1978         {
1979             CCoinsViewCache &view = *pcoinsTip;
1980             const CCoins* coins = view.AccessCoins(hash);
1981             if (coins)
1982                 nHeight = coins->nHeight;
1983         }
1984         if (nHeight > 0)
1985             pindexSlow = chainActive[nHeight];
1986     }
1987
1988     if (pindexSlow) {
1989         CBlock block;
1990         if (ReadBlockFromDisk(block, pindexSlow,1)) {
1991             BOOST_FOREACH(const CTransaction &tx, block.vtx) {
1992                 if (tx.GetHash() == hash) {
1993                     txOut = tx;
1994                     hashBlock = pindexSlow->GetBlockHash();
1995                     return true;
1996                 }
1997             }
1998         }
1999     }
2000
2001     return false;
2002 }
2003
2004 /*char *komodo_getspendscript(uint256 hash,int32_t n)
2005  {
2006  CTransaction tx; uint256 hashBlock;
2007  if ( !GetTransaction(hash,tx,hashBlock,true) )
2008  {
2009  printf("null GetTransaction\n");
2010  return(0);
2011  }
2012  if ( n >= 0 && n < tx.vout.size() )
2013  return((char *)tx.vout[n].scriptPubKey.ToString().c_str());
2014  else printf("getspendscript illegal n.%d\n",n);
2015  return(0);
2016  }*/
2017
2018
2019 //////////////////////////////////////////////////////////////////////////////
2020 //
2021 // CBlock and CBlockIndex
2022 //
2023
2024 bool WriteBlockToDisk(CBlock& block, CDiskBlockPos& pos, const CMessageHeader::MessageStartChars& messageStart)
2025 {
2026     // Open history file to append
2027     CAutoFile fileout(OpenBlockFile(pos), SER_DISK, CLIENT_VERSION);
2028     if (fileout.IsNull())
2029         return error("WriteBlockToDisk: OpenBlockFile failed");
2030
2031     // Write index header
2032     unsigned int nSize = GetSerializeSize(fileout, block);
2033     fileout << FLATDATA(messageStart) << nSize;
2034
2035     // Write block
2036     long fileOutPos = ftell(fileout.Get());
2037     if (fileOutPos < 0)
2038         return error("WriteBlockToDisk: ftell failed");
2039     pos.nPos = (unsigned int)fileOutPos;
2040     fileout << block;
2041
2042     return true;
2043 }
2044
2045 bool ReadBlockFromDisk(int32_t height,CBlock& block, const CDiskBlockPos& pos,bool checkPOW)
2046 {
2047     uint8_t pubkey33[33];
2048     block.SetNull();
2049
2050     // Open history file to read
2051     CAutoFile filein(OpenBlockFile(pos, true), SER_DISK, CLIENT_VERSION);
2052     if (filein.IsNull())
2053     {
2054         //fprintf(stderr,"readblockfromdisk err A\n");
2055         return error("ReadBlockFromDisk: OpenBlockFile failed for %s", pos.ToString());
2056     }
2057
2058     // Read block
2059     try {
2060         filein >> block;
2061     }
2062     catch (const std::exception& e) {
2063         fprintf(stderr,"readblockfromdisk err B\n");
2064         return error("%s: Deserialize or I/O error - %s at %s", __func__, e.what(), pos.ToString());
2065     }
2066     // Check the header
2067     if ( 0 && checkPOW != 0 )
2068     {
2069         komodo_block2pubkey33(pubkey33,(CBlock *)&block);
2070         if (!(CheckEquihashSolution(&block, Params()) && CheckProofOfWork(block, pubkey33, height, Params().GetConsensus())))
2071         {
2072             int32_t i; for (i=0; i<33; i++)
2073                 fprintf(stderr,"%02x",pubkey33[i]);
2074             fprintf(stderr," warning unexpected diff at ht.%d\n",height);
2075
2076             return error("ReadBlockFromDisk: Errors in block header at %s", pos.ToString());
2077         }
2078     }
2079     return true;
2080 }
2081
2082 bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex,bool checkPOW)
2083 {
2084     if ( pindex == 0 )
2085         return false;
2086     if (!ReadBlockFromDisk(pindex->GetHeight(),block, pindex->GetBlockPos(),checkPOW))
2087         return false;
2088     if (block.GetHash() != pindex->GetBlockHash())
2089         return error("ReadBlockFromDisk(CBlock&, CBlockIndex*): GetHash() doesn't match index for %s at %s",
2090                      pindex->ToString(), pindex->GetBlockPos().ToString());
2091     return true;
2092 }
2093
2094 //uint64_t komodo_moneysupply(int32_t height);
2095 extern char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN];
2096 extern uint64_t ASSETCHAINS_ENDSUBSIDY[ASSETCHAINS_MAX_ERAS], ASSETCHAINS_REWARD[ASSETCHAINS_MAX_ERAS], ASSETCHAINS_HALVING[ASSETCHAINS_MAX_ERAS];
2097 extern uint32_t ASSETCHAINS_MAGIC;
2098 extern uint64_t ASSETCHAINS_STAKED,ASSETCHAINS_LINEAR,ASSETCHAINS_COMMISSION,ASSETCHAINS_SUPPLY;
2099 extern uint8_t ASSETCHAINS_PUBLIC,ASSETCHAINS_PRIVATE;
2100
2101 CAmount GetBlockSubsidy(int nHeight, const Consensus::Params& consensusParams)
2102 {
2103     int32_t numhalvings,i; uint64_t numerator; CAmount nSubsidy = 3 * COIN;
2104     if ( ASSETCHAINS_SYMBOL[0] == 0 )
2105     {
2106         if ( nHeight == 1 )
2107             return(100000000 * COIN); // ICO allocation
2108         else if ( nHeight < KOMODO_ENDOFERA ) //komodo_moneysupply(nHeight) < MAX_MONEY )
2109             return(3 * COIN);
2110         else return(0);
2111     }
2112     else
2113     {
2114         return(komodo_ac_block_subsidy(nHeight));
2115     }
2116     /*
2117      // Mining slow start
2118      // The subsidy is ramped up linearly, skipping the middle payout of
2119      // MAX_SUBSIDY/2 to keep the monetary curve consistent with no slow start.
2120      if (nHeight < consensusParams.nSubsidySlowStartInterval / 2) {
2121      nSubsidy /= consensusParams.nSubsidySlowStartInterval;
2122      nSubsidy *= nHeight;
2123      return nSubsidy;
2124      } else if (nHeight < consensusParams.nSubsidySlowStartInterval) {
2125      nSubsidy /= consensusParams.nSubsidySlowStartInterval;
2126      nSubsidy *= (nHeight+1);
2127      return nSubsidy;
2128      }
2129
2130      assert(nHeight > consensusParams.SubsidySlowStartShift());
2131      int halvings = (nHeight - consensusParams.SubsidySlowStartShift()) / consensusParams.nSubsidyHalvingInterval;*/
2132     // Force block reward to zero when right shift is undefined.
2133     //int halvings = nHeight / consensusParams.nSubsidyHalvingInterval;
2134     //if (halvings >= 64)
2135     //    return 0;
2136
2137     // Subsidy is cut in half every 840,000 blocks which will occur approximately every 4 years.
2138     //nSubsidy >>= halvings;
2139     //return nSubsidy;
2140 }
2141
2142 bool IsInitialBlockDownload()
2143 {
2144     const CChainParams& chainParams = Params();
2145
2146     // Once this function has returned false, it must remain false.
2147     static std::atomic<bool> latchToFalse{false};
2148     // Optimization: pre-test latch before taking the lock.
2149     if (latchToFalse.load(std::memory_order_relaxed))
2150         return false;
2151
2152     LOCK(cs_main);
2153     if (latchToFalse.load(std::memory_order_relaxed))
2154         return false;
2155
2156     if (fImporting || fReindex)
2157     {
2158         //fprintf(stderr,"IsInitialBlockDownload: fImporting %d || %d fReindex\n",(int32_t)fImporting,(int32_t)fReindex);
2159         return true;
2160     }
2161
2162     if (fCheckpointsEnabled && chainActive.Height() < Checkpoints::GetTotalBlocksEstimate(chainParams.Checkpoints()))
2163     {
2164         //fprintf(stderr,"IsInitialBlockDownload: checkpoint -> initialdownload - %d blocks\n", Checkpoints::GetTotalBlocksEstimate(chainParams.Checkpoints()));
2165         return true;
2166     }
2167
2168     bool state;
2169     arith_uint256 bigZero = arith_uint256();
2170     arith_uint256 minWork = UintToArith256(chainParams.GetConsensus().nMinimumChainWork);
2171     CBlockIndex *ptr = chainActive.Tip();
2172
2173     if (ptr == NULL)
2174         return true;
2175     if (ptr->chainPower < CChainPower(ptr, bigZero, minWork))
2176         return true;
2177
2178     state = ((chainActive.Height() < ptr->GetHeight() - 24*60) ||
2179              ptr->GetBlockTime() < (GetTime() - nMaxTipAge));
2180
2181     //fprintf(stderr,"state.%d  ht.%d vs %d, t.%u %u\n",state,(int32_t)chainActive.Height(),(uint32_t)ptr->GetHeight(),(int32_t)ptr->GetBlockTime(),(uint32_t)(GetTime() - chainParams.MaxTipAge()));
2182     if (!state)
2183     {
2184         LogPrintf("Leaving InitialBlockDownload (latching to false)\n");
2185         latchToFalse.store(true, std::memory_order_relaxed);
2186     }
2187     return state;
2188 }
2189
2190 // determine if we are in sync with the best chain
2191 int IsNotInSync()
2192 {
2193     const CChainParams& chainParams = Params();
2194
2195     LOCK(cs_main);
2196     if (fImporting || fReindex)
2197     {
2198         //fprintf(stderr,"IsNotInSync: fImporting %d || %d fReindex\n",(int32_t)fImporting,(int32_t)fReindex);
2199         return true;
2200     }
2201     if (fCheckpointsEnabled)
2202     {
2203         if (fCheckpointsEnabled && chainActive.Height() < Checkpoints::GetTotalBlocksEstimate(chainParams.Checkpoints()))
2204         {
2205             //fprintf(stderr,"IsNotInSync: checkpoint -> initialdownload chainActive.Height().%d GetTotalBlocksEstimate(chainParams.Checkpoints().%d\n", chainActive.Height(), Checkpoints::GetTotalBlocksEstimate(chainParams.Checkpoints()));
2206             return true;
2207         }
2208     }
2209
2210     CBlockIndex *pbi = chainActive.Tip();
2211     int longestchain = komodo_longestchain();
2212     if ( !pbi ||
2213          (pindexBestHeader == 0) ||
2214          ((pindexBestHeader->GetHeight() - 1) > pbi->GetHeight()) ||
2215          (longestchain != 0 && longestchain > pbi->GetHeight()) )
2216     {
2217         return (pbi && pindexBestHeader && (pindexBestHeader->GetHeight() - 1) > pbi->GetHeight()) ?
2218                 pindexBestHeader->GetHeight() - pbi->GetHeight() :
2219                 true;
2220     }
2221
2222     return false;
2223 }
2224
2225 static bool fLargeWorkForkFound = false;
2226 static bool fLargeWorkInvalidChainFound = false;
2227 static CBlockIndex *pindexBestForkTip = NULL;
2228 static CBlockIndex *pindexBestForkBase = NULL;
2229
2230 void CheckForkWarningConditions()
2231 {
2232     AssertLockHeld(cs_main);
2233     // Before we get past initial download, we cannot reliably alert about forks
2234     // (we assume we don't get stuck on a fork before finishing our initial sync)
2235     if (IsInitialBlockDownload())
2236         return;
2237
2238     // If our best fork is no longer within 288 blocks (+/- 12 hours if no one mines it)
2239     // of our head, drop it
2240     if (pindexBestForkTip && chainActive.Height() - pindexBestForkTip->GetHeight() >= 288)
2241         pindexBestForkTip = NULL;
2242
2243     if (pindexBestForkTip || (pindexBestInvalid && pindexBestInvalid->chainPower > (chainActive.LastTip()->chainPower + (GetBlockProof(*chainActive.LastTip()) * 6))))
2244     {
2245         if (!fLargeWorkForkFound && pindexBestForkBase)
2246         {
2247             std::string warning = std::string("'Warning: Large-work fork detected, forking after block ") +
2248             pindexBestForkBase->phashBlock->ToString() + std::string("'");
2249             CAlert::Notify(warning, true);
2250         }
2251         if (pindexBestForkTip && pindexBestForkBase)
2252         {
2253             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__,
2254                       pindexBestForkBase->GetHeight(), pindexBestForkBase->phashBlock->ToString(),
2255                       pindexBestForkTip->GetHeight(), pindexBestForkTip->phashBlock->ToString());
2256             fLargeWorkForkFound = true;
2257         }
2258         else
2259         {
2260             std::string warning = std::string("Warning: Found invalid chain at least ~6 blocks longer than our best chain.\nChain state database corruption likely.");
2261             LogPrintf("%s: %s\n", warning.c_str(), __func__);
2262             CAlert::Notify(warning, true);
2263             fLargeWorkInvalidChainFound = true;
2264         }
2265     }
2266     else
2267     {
2268         fLargeWorkForkFound = false;
2269         fLargeWorkInvalidChainFound = false;
2270     }
2271 }
2272
2273 void CheckForkWarningConditionsOnNewFork(CBlockIndex* pindexNewForkTip)
2274 {
2275     AssertLockHeld(cs_main);
2276     // If we are on a fork that is sufficiently large, set a warning flag
2277     CBlockIndex* pfork = pindexNewForkTip;
2278     CBlockIndex* plonger = chainActive.LastTip();
2279     while (pfork && pfork != plonger)
2280     {
2281         while (plonger && plonger->GetHeight() > pfork->GetHeight())
2282             plonger = plonger->pprev;
2283         if (pfork == plonger)
2284             break;
2285         pfork = pfork->pprev;
2286     }
2287
2288     // We define a condition where we should warn the user about as a fork of at least 7 blocks
2289     // with a tip within 72 blocks (+/- 3 hours if no one mines it) of ours
2290     // We use 7 blocks rather arbitrarily as it represents just under 10% of sustained network
2291     // hash rate operating on the fork.
2292     // or a chain that is entirely longer than ours and invalid (note that this should be detected by both)
2293     // We define it this way because it allows us to only store the highest fork tip (+ base) which meets
2294     // the 7-block condition and from this always have the most-likely-to-cause-warning fork
2295     if (pfork && (!pindexBestForkTip || (pindexBestForkTip && pindexNewForkTip->GetHeight() > pindexBestForkTip->GetHeight())) &&
2296         pindexNewForkTip->chainPower - pfork->chainPower > (GetBlockProof(*pfork) * 7) &&
2297         chainActive.Height() - pindexNewForkTip->GetHeight() < 72)
2298     {
2299         pindexBestForkTip = pindexNewForkTip;
2300         pindexBestForkBase = pfork;
2301     }
2302
2303     CheckForkWarningConditions();
2304 }
2305
2306 // Requires cs_main.
2307 void Misbehaving(NodeId pnode, int howmuch)
2308 {
2309     if (howmuch == 0)
2310         return;
2311
2312     CNodeState *state = State(pnode);
2313     if (state == NULL)
2314         return;
2315
2316     state->nMisbehavior += howmuch;
2317     int banscore = GetArg("-banscore", 101);
2318     if (state->nMisbehavior >= banscore && state->nMisbehavior - howmuch < banscore)
2319     {
2320         LogPrintf("%s: %s (%d -> %d) BAN THRESHOLD EXCEEDED\n", __func__, state->name, state->nMisbehavior-howmuch, state->nMisbehavior);
2321         state->fShouldBan = true;
2322     } else
2323         LogPrintf("%s: %s (%d -> %d)\n", __func__, state->name, state->nMisbehavior-howmuch, state->nMisbehavior);
2324 }
2325
2326 void static InvalidChainFound(CBlockIndex* pindexNew)
2327 {
2328     if (!pindexBestInvalid || pindexNew->chainPower > pindexBestInvalid->chainPower)
2329         pindexBestInvalid = pindexNew;
2330
2331     LogPrintf("%s: invalid block=%s  height=%d  log2_work=%.8g  log2_stake=%.8g  date=%s\n", __func__,
2332               pindexNew->GetBlockHash().ToString(), pindexNew->GetHeight(),
2333               log(pindexNew->chainPower.chainWork.getdouble())/log(2.0),
2334               log(pindexNew->chainPower.chainStake.getdouble())/log(2.0),
2335               DateTimeStrFormat("%Y-%m-%d %H:%M:%S", pindexNew->GetBlockTime()));
2336     CBlockIndex *tip = chainActive.LastTip();
2337     assert (tip);
2338     LogPrintf("%s:  current best=%s  height=%d  log2_work=%.8g  log2_stake=%.8g  date=%s\n", __func__,
2339               tip->GetBlockHash().ToString(), chainActive.Height(),
2340               log(tip->chainPower.chainWork.getdouble())/log(2.0),
2341               log(tip->chainPower.chainStake.getdouble())/log(2.0),
2342               DateTimeStrFormat("%Y-%m-%d %H:%M:%S", tip->GetBlockTime()));
2343     CheckForkWarningConditions();
2344 }
2345
2346 void static InvalidBlockFound(CBlockIndex *pindex, const CValidationState &state) {
2347     int nDoS = 0;
2348     if (state.IsInvalid(nDoS)) {
2349         std::map<uint256, NodeId>::iterator it = mapBlockSource.find(pindex->GetBlockHash());
2350         if (it != mapBlockSource.end() && State(it->second)) {
2351             CBlockReject reject = {state.GetRejectCode(), state.GetRejectReason().substr(0, MAX_REJECT_MESSAGE_LENGTH), pindex->GetBlockHash()};
2352             State(it->second)->rejects.push_back(reject);
2353             if (nDoS > 0)
2354                 Misbehaving(it->second, nDoS);
2355         }
2356     }
2357     if (!state.CorruptionPossible()) {
2358         pindex->nStatus |= BLOCK_FAILED_VALID;
2359         setDirtyBlockIndex.insert(pindex);
2360         setBlockIndexCandidates.erase(pindex);
2361         InvalidChainFound(pindex);
2362     }
2363 }
2364
2365 void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, CTxUndo &txundo, int nHeight)
2366 {
2367     if (!tx.IsMint()) // mark inputs spent
2368     {
2369         txundo.vprevout.reserve(tx.vin.size());
2370         BOOST_FOREACH(const CTxIn &txin, tx.vin) {
2371             CCoinsModifier coins = inputs.ModifyCoins(txin.prevout.hash);
2372             unsigned nPos = txin.prevout.n;
2373
2374             if (nPos >= coins->vout.size() || coins->vout[nPos].IsNull())
2375                 assert(false);
2376             // mark an outpoint spent, and construct undo information
2377             txundo.vprevout.push_back(CTxInUndo(coins->vout[nPos]));
2378             coins->Spend(nPos);
2379             if (coins->vout.size() == 0) {
2380                 CTxInUndo& undo = txundo.vprevout.back();
2381                 undo.nHeight = coins->nHeight;
2382                 undo.fCoinBase = coins->fCoinBase;
2383                 undo.nVersion = coins->nVersion;
2384             }
2385         }
2386     }
2387
2388     // spend nullifiers
2389     inputs.SetNullifiers(tx, true);
2390
2391     inputs.ModifyCoins(tx.GetHash())->FromTx(tx, nHeight); // add outputs
2392
2393     // Unorthodox state
2394     if (tx.IsCoinImport()) {
2395         // add a tombstone for the burnTx
2396         AddImportTombstone(tx, inputs, nHeight);
2397     }
2398 }
2399
2400 void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, int nHeight)
2401 {
2402     CTxUndo txundo;
2403     UpdateCoins(tx, inputs, txundo, nHeight);
2404 }
2405
2406 bool CScriptCheck::operator()() {
2407     const CScript &scriptSig = ptxTo->vin[nIn].scriptSig;
2408     ServerTransactionSignatureChecker checker(ptxTo, nIn, amount, cacheStore, *txdata);
2409     if (!VerifyScript(scriptSig, scriptPubKey, nFlags, checker, consensusBranchId, &error)) {
2410         return ::error("CScriptCheck(): %s:%d VerifySignature failed: %s", ptxTo->GetHash().ToString(), nIn, ScriptErrorString(error));
2411     }
2412     return true;
2413 }
2414
2415 int GetSpendHeight(const CCoinsViewCache& inputs)
2416 {
2417     LOCK(cs_main);
2418     CBlockIndex* pindexPrev = mapBlockIndex.find(inputs.GetBestBlock())->second;
2419     return pindexPrev->GetHeight() + 1;
2420 }
2421
2422 namespace Consensus {
2423     bool CheckTxInputs(const CTransaction& tx, CValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, const Consensus::Params& consensusParams)
2424     {
2425         // This doesn't trigger the DoS code on purpose; if it did, it would make it easier
2426         // for an attacker to attempt to split the network.
2427         if (!inputs.HaveInputs(tx))
2428             return state.Invalid(error("CheckInputs(): %s inputs unavailable", tx.GetHash().ToString()));
2429
2430         // are the JoinSplit's requirements met?
2431         if (!inputs.HaveJoinSplitRequirements(tx))
2432             return state.Invalid(error("CheckInputs(): %s JoinSplit requirements not met", tx.GetHash().ToString()));
2433
2434         CAmount nValueIn = 0;
2435         CAmount nFees = 0;
2436         for (unsigned int i = 0; i < tx.vin.size(); i++)
2437         {
2438             const COutPoint &prevout = tx.vin[i].prevout;
2439             const CCoins *coins = inputs.AccessCoins(prevout.hash);
2440             assert(coins);
2441
2442             if (coins->IsCoinBase()) {
2443                 // ensure that output of coinbases are not still time locked
2444                 if (coins->TotalTxValue() >= ASSETCHAINS_TIMELOCKGTE)
2445                 {
2446                     uint64_t unlockTime = komodo_block_unlocktime(coins->nHeight);
2447                     if (nSpendHeight < unlockTime) {
2448                         return state.DoS(10,
2449                                         error("CheckInputs(): tried to spend coinbase that is timelocked until block %d", unlockTime),
2450                                         REJECT_INVALID, "bad-txns-premature-spend-of-coinbase");
2451                     }
2452                 }
2453
2454                 // Ensure that coinbases are matured, no DoS as retry may work later
2455                 if (nSpendHeight - coins->nHeight < COINBASE_MATURITY) {
2456                     return state.DoS(0,
2457                                      error("CheckInputs(): tried to spend coinbase at depth %d", nSpendHeight - coins->nHeight),
2458                                      REJECT_INVALID, "bad-txns-premature-spend-of-coinbase");
2459                 }
2460
2461                 // Ensure that coinbases cannot be spent to transparent outputs
2462                 // Disabled on regtest
2463                 if (fCoinbaseEnforcedProtectionEnabled &&
2464                     consensusParams.fCoinbaseMustBeProtected &&
2465                     !(tx.vout.size() == 0 || (tx.vout.size() == 1 && tx.vout[0].nValue == 0)) &&
2466                     (strcmp(ASSETCHAINS_SYMBOL, "VRSC") != 0 || (nSpendHeight >= 12800 && coins->nHeight >= 12800))) {
2467                     return state.DoS(100,
2468                                      error("CheckInputs(): tried to spend coinbase with transparent outputs"),
2469                                      REJECT_INVALID, "bad-txns-coinbase-spend-has-transparent-outputs");
2470                 }
2471             }
2472
2473             // Check for negative or overflow input values
2474             nValueIn += coins->vout[prevout.n].nValue;
2475 #ifdef KOMODO_ENABLE_INTEREST
2476             if ( ASSETCHAINS_SYMBOL[0] == 0 && nSpendHeight > 60000 )//chainActive.LastTip() != 0 && chainActive.LastTip()->GetHeight() >= 60000 )
2477             {
2478                 if ( coins->vout[prevout.n].nValue >= 10*COIN )
2479                 {
2480                     int64_t interest; int32_t txheight; uint32_t locktime;
2481                     if ( (interest= komodo_accrued_interest(&txheight,&locktime,prevout.hash,prevout.n,0,coins->vout[prevout.n].nValue,(int32_t)nSpendHeight-1)) != 0 )
2482                     {
2483                         //fprintf(stderr,"checkResult %.8f += val %.8f interest %.8f ht.%d lock.%u tip.%u\n",(double)nValueIn/COIN,(double)coins->vout[prevout.n].nValue/COIN,(double)interest/COIN,txheight,locktime,chainActive.LastTip()->nTime);
2484                         nValueIn += interest;
2485                     }
2486                 }
2487             }
2488 #endif
2489             if (!MoneyRange(coins->vout[prevout.n].nValue) || !MoneyRange(nValueIn))
2490                 return state.DoS(100, error("CheckInputs(): txin values out of range"),
2491                                  REJECT_INVALID, "bad-txns-inputvalues-outofrange");
2492
2493         }
2494
2495         nValueIn += tx.GetShieldedValueIn();
2496         if (!MoneyRange(nValueIn))
2497             return state.DoS(100, error("CheckInputs(): shielded input to transparent value pool out of range"),
2498                              REJECT_INVALID, "bad-txns-inputvalues-outofrange");
2499
2500         if (nValueIn < tx.GetValueOut())
2501         {
2502             fprintf(stderr,"spentheight.%d valuein %s vs %s error\n",nSpendHeight,FormatMoney(nValueIn).c_str(), FormatMoney(tx.GetValueOut()).c_str());
2503             return state.DoS(100, error("CheckInputs(): %s value in (%s) < value out (%s) diff %.8f",
2504                                         tx.GetHash().ToString(), FormatMoney(nValueIn), FormatMoney(tx.GetValueOut()),((double)nValueIn - tx.GetValueOut())/COIN),REJECT_INVALID, "bad-txns-in-belowout");
2505         }
2506         // Tally transaction fees
2507         CAmount nTxFee = nValueIn - tx.GetValueOut();
2508         if (nTxFee < 0)
2509             return state.DoS(100, error("CheckInputs(): %s nTxFee < 0", tx.GetHash().ToString()),
2510                              REJECT_INVALID, "bad-txns-fee-negative");
2511         nFees += nTxFee;
2512         if (!MoneyRange(nFees))
2513             return state.DoS(100, error("CheckInputs(): nFees out of range"),
2514                              REJECT_INVALID, "bad-txns-fee-outofrange");
2515         return true;
2516     }
2517 }// namespace Consensus
2518
2519 bool ContextualCheckInputs(
2520                            const CTransaction& tx,
2521                            CValidationState &state,
2522                            const CCoinsViewCache &inputs,
2523                            bool fScriptChecks,
2524                            unsigned int flags,
2525                            bool cacheStore,
2526                            PrecomputedTransactionData& txdata,
2527                            const Consensus::Params& consensusParams,
2528                            uint32_t consensusBranchId,
2529                            std::vector<CScriptCheck> *pvChecks)
2530 {
2531     if (!tx.IsMint())
2532     {
2533         if (!Consensus::CheckTxInputs(tx, state, inputs, GetSpendHeight(inputs), consensusParams)) {
2534             return false;
2535         }
2536
2537         if (pvChecks)
2538             pvChecks->reserve(tx.vin.size());
2539
2540         // The first loop above does all the inexpensive checks.
2541         // Only if ALL inputs pass do we perform expensive ECDSA signature checks.
2542         // Helps prevent CPU exhaustion attacks.
2543
2544         // Skip ECDSA signature verification when connecting blocks
2545         // before the last block chain checkpoint. This is safe because block merkle hashes are
2546         // still computed and checked, and any change will be caught at the next checkpoint.
2547         if (fScriptChecks) {
2548             for (unsigned int i = 0; i < tx.vin.size(); i++) {
2549                 const COutPoint &prevout = tx.vin[i].prevout;
2550                 const CCoins* coins = inputs.AccessCoins(prevout.hash);
2551                 assert(coins);
2552
2553                 // Verify signature
2554                 CScriptCheck check(*coins, tx, i, flags, cacheStore, consensusBranchId, &txdata);
2555                 if (pvChecks) {
2556                     pvChecks->push_back(CScriptCheck());
2557                     check.swap(pvChecks->back());
2558                 } else if (!check()) {
2559                     if (flags & STANDARD_NOT_MANDATORY_VERIFY_FLAGS) {
2560                         // Check whether the failure was caused by a
2561                         // non-mandatory script verification check, such as
2562                         // non-standard DER encodings or non-null dummy
2563                         // arguments; if so, don't trigger DoS protection to
2564                         // avoid splitting the network between upgraded and
2565                         // non-upgraded nodes.
2566                         CScriptCheck check2(*coins, tx, i,
2567                                             flags & ~STANDARD_NOT_MANDATORY_VERIFY_FLAGS, cacheStore, consensusBranchId, &txdata);
2568                         if (check2())
2569                             return state.Invalid(false, REJECT_NONSTANDARD, strprintf("non-mandatory-script-verify-flag (%s)", ScriptErrorString(check.GetScriptError())));
2570                     }
2571                     // Failures of other flags indicate a transaction that is
2572                     // invalid in new blocks, e.g. a invalid P2SH. We DoS ban
2573                     // such nodes as they are not following the protocol. That
2574                     // said during an upgrade careful thought should be taken
2575                     // as to the correct behavior - we may want to continue
2576                     // peering with non-upgraded nodes even after a soft-fork
2577                     // super-majority vote has passed.
2578                     return state.DoS(100,false, REJECT_INVALID, strprintf("mandatory-script-verify-flag-failed (%s)", ScriptErrorString(check.GetScriptError())));
2579                 }
2580             }
2581         }
2582     }
2583
2584     if (tx.IsCoinImport())
2585     {
2586         ServerTransactionSignatureChecker checker(&tx, 0, 0, false, txdata);
2587         return VerifyCoinImport(tx.vin[0].scriptSig, checker, state);
2588     }
2589
2590     return true;
2591 }
2592
2593
2594 /*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)
2595  {
2596  if (!NonContextualCheckInputs(tx, state, inputs, fScriptChecks, flags, cacheStore, consensusParams, pvChecks)) {
2597  fprintf(stderr,"ContextualCheckInputs failure.0\n");
2598  return false;
2599  }
2600
2601  if (!tx.IsCoinBase())
2602  {
2603  // While checking, GetBestBlock() refers to the parent block.
2604  // This is also true for mempool checks.
2605  CBlockIndex *pindexPrev = mapBlockIndex.find(inputs.GetBestBlock())->second;
2606  int nSpendHeight = pindexPrev->GetHeight() + 1;
2607  for (unsigned int i = 0; i < tx.vin.size(); i++)
2608  {
2609  const COutPoint &prevout = tx.vin[i].prevout;
2610  const CCoins *coins = inputs.AccessCoins(prevout.hash);
2611  // Assertion is okay because NonContextualCheckInputs ensures the inputs
2612  // are available.
2613  assert(coins);
2614
2615  // If prev is coinbase, check that it's matured
2616  if (coins->IsCoinBase()) {
2617  if ( ASSETCHAINS_SYMBOL[0] == 0 )
2618  COINBASE_MATURITY = _COINBASE_MATURITY;
2619  if (nSpendHeight - coins->nHeight < COINBASE_MATURITY) {
2620  fprintf(stderr,"ContextualCheckInputs failure.1 i.%d of %d\n",i,(int32_t)tx.vin.size());
2621
2622  return state.Invalid(
2623  error("CheckInputs(): tried to spend coinbase at depth %d", nSpendHeight - coins->nHeight),REJECT_INVALID, "bad-txns-premature-spend-of-coinbase");
2624  }
2625  }
2626  }
2627  }
2628
2629  return true;
2630  }*/
2631
2632 namespace {
2633
2634     bool UndoWriteToDisk(const CBlockUndo& blockundo, CDiskBlockPos& pos, const uint256& hashBlock, const CMessageHeader::MessageStartChars& messageStart)
2635     {
2636         // Open history file to append
2637         CAutoFile fileout(OpenUndoFile(pos), SER_DISK, CLIENT_VERSION);
2638         if (fileout.IsNull())
2639             return error("%s: OpenUndoFile failed", __func__);
2640
2641         // Write index header
2642         unsigned int nSize = GetSerializeSize(fileout, blockundo);
2643         fileout << FLATDATA(messageStart) << nSize;
2644
2645         // Write undo data
2646         long fileOutPos = ftell(fileout.Get());
2647         if (fileOutPos < 0)
2648             return error("%s: ftell failed", __func__);
2649         pos.nPos = (unsigned int)fileOutPos;
2650         fileout << blockundo;
2651
2652         // calculate & write checksum
2653         CHashWriter hasher(SER_GETHASH, PROTOCOL_VERSION);
2654         hasher << hashBlock;
2655         hasher << blockundo;
2656         fileout << hasher.GetHash();
2657
2658         return true;
2659     }
2660
2661     bool UndoReadFromDisk(CBlockUndo& blockundo, const CDiskBlockPos& pos, const uint256& hashBlock)
2662     {
2663         // Open history file to read
2664         CAutoFile filein(OpenUndoFile(pos, true), SER_DISK, CLIENT_VERSION);
2665         if (filein.IsNull())
2666             return error("%s: OpenBlockFile failed", __func__);
2667
2668         // Read block
2669         uint256 hashChecksum;
2670         try {
2671             filein >> blockundo;
2672             filein >> hashChecksum;
2673         }
2674         catch (const std::exception& e) {
2675             return error("%s: Deserialize or I/O error - %s", __func__, e.what());
2676         }
2677         // Verify checksum
2678         CHashWriter hasher(SER_GETHASH, PROTOCOL_VERSION);
2679         hasher << hashBlock;
2680         hasher << blockundo;
2681         if (hashChecksum != hasher.GetHash())
2682             return error("%s: Checksum mismatch", __func__);
2683
2684         return true;
2685     }
2686
2687     /** Abort with a message */
2688     bool AbortNode(const std::string& strMessage, const std::string& userMessage="")
2689     {
2690         strMiscWarning = strMessage;
2691         LogPrintf("*** %s\n", strMessage);
2692         uiInterface.ThreadSafeMessageBox(
2693                                          userMessage.empty() ? _("Error: A fatal internal error occurred, see debug.log for details") : userMessage,
2694                                          "", CClientUIInterface::MSG_ERROR);
2695         StartShutdown();
2696         return false;
2697     }
2698
2699     bool AbortNode(CValidationState& state, const std::string& strMessage, const std::string& userMessage="")
2700     {
2701         AbortNode(strMessage, userMessage);
2702         return state.Error(strMessage);
2703     }
2704
2705 } // anon namespace
2706
2707 /**
2708  * Apply the undo operation of a CTxInUndo to the given chain state.
2709  * @param undo The undo object.
2710  * @param view The coins view to which to apply the changes.
2711  * @param out The out point that corresponds to the tx input.
2712  * @return True on success.
2713  */
2714 static bool ApplyTxInUndo(const CTxInUndo& undo, CCoinsViewCache& view, const COutPoint& out)
2715 {
2716     bool fClean = true;
2717
2718     CCoinsModifier coins = view.ModifyCoins(out.hash);
2719     if (undo.nHeight != 0) {
2720         // undo data contains height: this is the last output of the prevout tx being spent
2721         if (!coins->IsPruned())
2722             fClean = fClean && error("%s: undo data overwriting existing transaction", __func__);
2723         coins->Clear();
2724         coins->fCoinBase = undo.fCoinBase;
2725         coins->nHeight = undo.nHeight;
2726         coins->nVersion = undo.nVersion;
2727     } else {
2728         if (coins->IsPruned())
2729             fClean = fClean && error("%s: undo data adding output to missing transaction", __func__);
2730     }
2731     if (coins->IsAvailable(out.n))
2732         fClean = fClean && error("%s: undo data overwriting existing output", __func__);
2733     if (coins->vout.size() < out.n+1)
2734         coins->vout.resize(out.n+1);
2735     coins->vout[out.n] = undo.txout;
2736
2737     return fClean;
2738 }
2739
2740
2741 void ConnectNotarisations(const CBlock &block, int height)
2742 {
2743     // Record Notarisations
2744     NotarisationsInBlock notarisations = ScanBlockNotarisations(block, height);
2745     if (notarisations.size() > 0) {
2746         CDBBatch batch = CDBBatch(*pnotarisations);
2747         batch.Write(block.GetHash(), notarisations);
2748         WriteBackNotarisations(notarisations, batch);
2749         pnotarisations->WriteBatch(batch, true);
2750         LogPrintf("ConnectBlock: wrote %i block notarisations in block: %s\n",
2751                 notarisations.size(), block.GetHash().GetHex().data());
2752     }
2753 }
2754
2755
2756 void DisconnectNotarisations(const CBlock &block)
2757 {
2758     // Delete from notarisations cache
2759     NotarisationsInBlock nibs;
2760     if (GetBlockNotarisations(block.GetHash(), nibs)) {
2761         CDBBatch batch = CDBBatch(*pnotarisations);
2762         batch.Erase(block.GetHash());
2763         EraseBackNotarisations(nibs, batch);
2764         pnotarisations->WriteBatch(batch, true);
2765         LogPrintf("DisconnectTip: deleted %i block notarisations in block: %s\n",
2766             nibs.size(), block.GetHash().GetHex().data());
2767     }
2768 }
2769
2770
2771 bool DisconnectBlock(CBlock& block, CValidationState& state, CBlockIndex* pindex, CCoinsViewCache& view, bool* pfClean)
2772 {
2773     assert(pindex->GetBlockHash() == view.GetBestBlock());
2774
2775     if (pfClean)
2776         *pfClean = false;
2777
2778     bool fClean = true;
2779     komodo_disconnect(pindex,block);
2780     CBlockUndo blockUndo;
2781     CDiskBlockPos pos = pindex->GetUndoPos();
2782     if (pos.IsNull())
2783         return error("DisconnectBlock(): no undo data available");
2784     if (!UndoReadFromDisk(blockUndo, pos, pindex->pprev->GetBlockHash()))
2785         return error("DisconnectBlock(): failure reading undo data");
2786
2787     if (blockUndo.vtxundo.size() + 1 != block.vtx.size())
2788         return error("DisconnectBlock(): block and undo data inconsistent");
2789     std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex;
2790     std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > addressUnspentIndex;
2791     std::vector<std::pair<CSpentIndexKey, CSpentIndexValue> > spentIndex;
2792
2793     // undo transactions in reverse order
2794     for (int i = block.vtx.size() - 1; i >= 0; i--) {
2795         const CTransaction &tx = block.vtx[i];
2796         uint256 hash = tx.GetHash();
2797         if (fAddressIndex) {
2798
2799             for (unsigned int k = tx.vout.size(); k-- > 0;) {
2800                 const CTxOut &out = tx.vout[k];
2801
2802                 if (out.scriptPubKey.IsPayToScriptHash()) {
2803                     vector<unsigned char> hashBytes(out.scriptPubKey.begin()+2, out.scriptPubKey.begin()+22);
2804
2805                     // undo receiving activity
2806                     addressIndex.push_back(make_pair(CAddressIndexKey(2, uint160(hashBytes), pindex->GetHeight(), i, hash, k, false), out.nValue));
2807
2808                     // undo unspent index
2809                     addressUnspentIndex.push_back(make_pair(CAddressUnspentKey(2, uint160(hashBytes), hash, k), CAddressUnspentValue()));
2810
2811                 }
2812                 else if (out.scriptPubKey.IsPayToPublicKeyHash()) {
2813                     vector<unsigned char> hashBytes(out.scriptPubKey.begin()+3, out.scriptPubKey.begin()+23);
2814
2815                     // undo receiving activity
2816                     addressIndex.push_back(make_pair(CAddressIndexKey(1, uint160(hashBytes), pindex->GetHeight(), i, hash, k, false), out.nValue));
2817
2818                     // undo unspent index
2819                     addressUnspentIndex.push_back(make_pair(CAddressUnspentKey(1, uint160(hashBytes), hash, k), CAddressUnspentValue()));
2820
2821                 }
2822                 else if (out.scriptPubKey.IsPayToPublicKey()) {
2823                     vector<unsigned char> hashBytes(out.scriptPubKey.begin()+1, out.scriptPubKey.begin()+34);
2824
2825                     // undo receiving activity
2826                     addressIndex.push_back(make_pair(CAddressIndexKey(1, Hash160(hashBytes), pindex->GetHeight(), i, hash, k, false), out.nValue));
2827
2828                     // undo unspent index
2829                     addressUnspentIndex.push_back(make_pair(CAddressUnspentKey(1, Hash160(hashBytes), hash, k), CAddressUnspentValue()));
2830
2831                 }
2832                 else if (out.scriptPubKey.IsPayToCryptoCondition()) {
2833                     vector<unsigned char> hashBytes(out.scriptPubKey.begin(), out.scriptPubKey.end());
2834
2835                     // undo receiving activity
2836                     addressIndex.push_back(make_pair(CAddressIndexKey(1, Hash160(hashBytes), pindex->GetHeight(), i, hash, k, false), out.nValue));
2837
2838                     // undo unspent index
2839                     addressUnspentIndex.push_back(make_pair(CAddressUnspentKey(1, Hash160(hashBytes), hash, k), CAddressUnspentValue()));
2840
2841                 }
2842                 else {
2843                     continue;
2844                 }
2845
2846             }
2847
2848         }
2849
2850         // Check that all outputs are available and match the outputs in the block itself
2851         // exactly.
2852         {
2853             CCoinsModifier outs = view.ModifyCoins(hash);
2854             outs->ClearUnspendable();
2855
2856             CCoins outsBlock(tx, pindex->GetHeight());
2857             // The CCoins serialization does not serialize negative numbers.
2858             // No network rules currently depend on the version here, so an inconsistency is harmless
2859             // but it must be corrected before txout nversion ever influences a network rule.
2860             if (outsBlock.nVersion < 0)
2861                 outs->nVersion = outsBlock.nVersion;
2862             if (*outs != outsBlock)
2863                 fClean = fClean && error("DisconnectBlock(): added transaction mismatch? database corrupted");
2864
2865             // remove outputs
2866             outs->Clear();
2867         }
2868
2869         // unspend nullifiers
2870         view.SetNullifiers(tx, false);
2871
2872         // restore inputs
2873         if (!tx.IsMint()) {
2874             const CTxUndo &txundo = blockUndo.vtxundo[i-1];
2875             if (txundo.vprevout.size() != tx.vin.size())
2876                 return error("DisconnectBlock(): transaction and undo data inconsistent");
2877             for (unsigned int j = tx.vin.size(); j-- > 0;) {
2878                 const COutPoint &out = tx.vin[j].prevout;
2879                 const CTxInUndo &undo = txundo.vprevout[j];
2880                 if (!ApplyTxInUndo(undo, view, out))
2881                     fClean = false;
2882
2883                 const CTxIn input = tx.vin[j];
2884
2885                 if (fSpentIndex) {
2886                     // undo and delete the spent index
2887                     spentIndex.push_back(make_pair(CSpentIndexKey(input.prevout.hash, input.prevout.n), CSpentIndexValue()));
2888                 }
2889
2890                 if (fAddressIndex) {
2891                     const CTxOut &prevout = view.GetOutputFor(tx.vin[j]);
2892                     if (prevout.scriptPubKey.IsPayToScriptHash()) {
2893                         vector<unsigned char> hashBytes(prevout.scriptPubKey.begin()+2, prevout.scriptPubKey.begin()+22);
2894
2895                         // undo spending activity
2896                         addressIndex.push_back(make_pair(CAddressIndexKey(2, uint160(hashBytes), pindex->GetHeight(), i, hash, j, true), prevout.nValue * -1));
2897
2898                         // restore unspent index
2899                         addressUnspentIndex.push_back(make_pair(CAddressUnspentKey(2, uint160(hashBytes), input.prevout.hash, input.prevout.n), CAddressUnspentValue(prevout.nValue, prevout.scriptPubKey, undo.nHeight)));
2900
2901
2902                     }
2903                     else if (prevout.scriptPubKey.IsPayToPublicKeyHash()) {
2904                         vector<unsigned char> hashBytes(prevout.scriptPubKey.begin()+3, prevout.scriptPubKey.begin()+23);
2905
2906                         // undo spending activity
2907                         addressIndex.push_back(make_pair(CAddressIndexKey(1, uint160(hashBytes), pindex->GetHeight(), i, hash, j, true), prevout.nValue * -1));
2908
2909                         // restore unspent index
2910                         addressUnspentIndex.push_back(make_pair(CAddressUnspentKey(1, uint160(hashBytes), input.prevout.hash, input.prevout.n), CAddressUnspentValue(prevout.nValue, prevout.scriptPubKey, undo.nHeight)));
2911
2912                     }
2913                     else if (prevout.scriptPubKey.IsPayToPublicKey()) {
2914                         vector<unsigned char> hashBytes(prevout.scriptPubKey.begin()+1, prevout.scriptPubKey.begin()+34);
2915
2916                         // undo spending activity
2917                         addressIndex.push_back(make_pair(CAddressIndexKey(1, Hash160(hashBytes), pindex->GetHeight(), i, hash, j, true), prevout.nValue * -1));
2918
2919                         // restore unspent index
2920                         addressUnspentIndex.push_back(make_pair(CAddressUnspentKey(1, Hash160(hashBytes), input.prevout.hash, input.prevout.n), CAddressUnspentValue(prevout.nValue, prevout.scriptPubKey, undo.nHeight)));
2921
2922                     }
2923                     else if (prevout.scriptPubKey.IsPayToCryptoCondition()) {
2924                         vector<unsigned char> hashBytes(prevout.scriptPubKey.begin(), prevout.scriptPubKey.end());
2925
2926                         // undo spending activity
2927                         addressIndex.push_back(make_pair(CAddressIndexKey(1, Hash160(hashBytes), pindex->GetHeight(), i, hash, j, true), prevout.nValue * -1));
2928
2929                         // restore unspent index
2930                         addressUnspentIndex.push_back(make_pair(CAddressUnspentKey(1, Hash160(hashBytes), input.prevout.hash, input.prevout.n), CAddressUnspentValue(prevout.nValue, prevout.scriptPubKey, undo.nHeight)));
2931
2932                     }
2933                     else {
2934                         continue;
2935                     }
2936                 }
2937             }
2938         }
2939         else if (tx.IsCoinImport())
2940         {
2941             RemoveImportTombstone(tx, view);
2942         }
2943     }
2944
2945     // set the old best Sprout anchor back
2946     view.PopAnchor(blockUndo.old_sprout_tree_root, SPROUT);
2947
2948     // set the old best Sapling anchor back
2949     // We can get this from the `hashFinalSaplingRoot` of the last block
2950     // However, this is only reliable if the last block was on or after
2951     // the Sapling activation height. Otherwise, the last anchor was the
2952     // empty root.
2953     if (NetworkUpgradeActive(pindex->pprev->GetHeight(), Params().GetConsensus(), Consensus::UPGRADE_SAPLING)) {
2954         view.PopAnchor(pindex->pprev->hashFinalSaplingRoot, SAPLING);
2955     } else {
2956         view.PopAnchor(SaplingMerkleTree::empty_root(), SAPLING);
2957     }
2958
2959     // move best block pointer to prevout block
2960     view.SetBestBlock(pindex->pprev->GetBlockHash());
2961
2962     if (pfClean) {
2963         *pfClean = fClean;
2964         return true;
2965     }
2966
2967     if (fAddressIndex) {
2968         if (!pblocktree->EraseAddressIndex(addressIndex)) {
2969             return AbortNode(state, "Failed to delete address index");
2970         }
2971         if (!pblocktree->UpdateAddressUnspentIndex(addressUnspentIndex)) {
2972             return AbortNode(state, "Failed to write address unspent index");
2973         }
2974     }
2975
2976     return fClean;
2977 }
2978
2979 void static FlushBlockFile(bool fFinalize = false)
2980 {
2981     LOCK(cs_LastBlockFile);
2982
2983     CDiskBlockPos posOld(nLastBlockFile, 0);
2984
2985     FILE *fileOld = OpenBlockFile(posOld);
2986     if (fileOld) {
2987         if (fFinalize)
2988             TruncateFile(fileOld, vinfoBlockFile[nLastBlockFile].nSize);
2989         FileCommit(fileOld);
2990         fclose(fileOld);
2991     }
2992
2993     fileOld = OpenUndoFile(posOld);
2994     if (fileOld) {
2995         if (fFinalize)
2996             TruncateFile(fileOld, vinfoBlockFile[nLastBlockFile].nUndoSize);
2997         FileCommit(fileOld);
2998         fclose(fileOld);
2999     }
3000 }
3001
3002 bool FindUndoPos(CValidationState &state, int nFile, CDiskBlockPos &pos, unsigned int nAddSize);
3003
3004 static CCheckQueue<CScriptCheck> scriptcheckqueue(128);
3005
3006 void ThreadScriptCheck() {
3007     RenameThread("zcash-scriptch");
3008     scriptcheckqueue.Thread();
3009 }
3010
3011 //
3012 // Called periodically asynchronously; alerts if it smells like
3013 // we're being fed a bad chain (blocks being generated much
3014 // too slowly or too quickly).
3015 //
3016 void PartitionCheck(bool (*initialDownloadCheck)(), CCriticalSection& cs, const CBlockIndex *const &bestHeader,
3017                     int64_t nPowTargetSpacing)
3018 {
3019     if (bestHeader == NULL || initialDownloadCheck()) return;
3020
3021     static int64_t lastAlertTime = 0;
3022     int64_t now = GetAdjustedTime();
3023     if (lastAlertTime > now-60*60*24) return; // Alert at most once per day
3024
3025     const int SPAN_HOURS=4;
3026     const int SPAN_SECONDS=SPAN_HOURS*60*60;
3027     int BLOCKS_EXPECTED = SPAN_SECONDS / nPowTargetSpacing;
3028
3029     boost::math::poisson_distribution<double> poisson(BLOCKS_EXPECTED);
3030
3031     std::string strWarning;
3032     int64_t startTime = GetAdjustedTime()-SPAN_SECONDS;
3033
3034     LOCK(cs);
3035     const CBlockIndex* i = bestHeader;
3036     int nBlocks = 0;
3037     while (i->GetBlockTime() >= startTime) {
3038         ++nBlocks;
3039         i = i->pprev;
3040         if (i == NULL) return; // Ran out of chain, we must not be fully synced
3041     }
3042
3043     // How likely is it to find that many by chance?
3044     double p = boost::math::pdf(poisson, nBlocks);
3045
3046     LogPrint("partitioncheck", "%s : Found %d blocks in the last %d hours\n", __func__, nBlocks, SPAN_HOURS);
3047     LogPrint("partitioncheck", "%s : likelihood: %g\n", __func__, p);
3048
3049     // Aim for one false-positive about every fifty years of normal running:
3050     const int FIFTY_YEARS = 50*365*24*60*60;
3051     double alertThreshold = 1.0 / (FIFTY_YEARS / SPAN_SECONDS);
3052
3053     if (bestHeader->GetHeight() > BLOCKS_EXPECTED)
3054     {
3055         if (p <= alertThreshold && nBlocks < BLOCKS_EXPECTED)
3056         {
3057             // Many fewer blocks than expected: alert!
3058             strWarning = strprintf(_("WARNING: check your network connection, %d blocks received in the last %d hours (%d expected)"),
3059                                 nBlocks, SPAN_HOURS, BLOCKS_EXPECTED);
3060         }
3061         else if (p <= alertThreshold && nBlocks > BLOCKS_EXPECTED)
3062         {
3063             // Many more blocks than expected: alert!
3064             strWarning = strprintf(_("WARNING: abnormally high number of blocks generated, %d blocks received in the last %d hours (%d expected)"),
3065                                 nBlocks, SPAN_HOURS, BLOCKS_EXPECTED);
3066         }
3067     }
3068     if (!strWarning.empty())
3069     {
3070         strMiscWarning = strWarning;
3071         CAlert::Notify(strWarning, true);
3072         lastAlertTime = now;
3073     }
3074 }
3075
3076
3077 static int64_t nTimeVerify = 0;
3078 static int64_t nTimeConnect = 0;
3079 static int64_t nTimeIndex = 0;
3080 static int64_t nTimeCallbacks = 0;
3081 static int64_t nTimeTotal = 0;
3082
3083 bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pindex, CCoinsViewCache& view, bool fJustCheck,bool fCheckPOW)
3084 {
3085     const CChainParams& chainparams = Params();
3086     if ( KOMODO_STOPAT != 0 && pindex->GetHeight() > KOMODO_STOPAT )
3087         return(false);
3088     //fprintf(stderr,"connectblock ht.%d\n",(int32_t)pindex->GetHeight());
3089     AssertLockHeld(cs_main);
3090     bool fExpensiveChecks = true;
3091     if (fCheckpointsEnabled) {
3092         CBlockIndex *pindexLastCheckpoint = Checkpoints::GetLastCheckpoint(chainparams.Checkpoints());
3093         if (pindexLastCheckpoint && pindexLastCheckpoint->GetAncestor(pindex->GetHeight()) == pindex) {
3094             // This block is an ancestor of a checkpoint: disable script checks
3095             fExpensiveChecks = false;
3096         }
3097     }
3098     auto verifier = libzcash::ProofVerifier::Strict();
3099     auto disabledVerifier = libzcash::ProofVerifier::Disabled();
3100     int32_t futureblock;
3101     // Check it again to verify JoinSplit proofs, and in case a previous version let a bad block in
3102     if (!CheckBlock(&futureblock,pindex->GetHeight(),pindex,block, state, fExpensiveChecks ? verifier : disabledVerifier, fCheckPOW, !fJustCheck) || futureblock != 0 )
3103     {
3104         //fprintf(stderr,"checkblock failure in connectblock futureblock.%d\n",futureblock);
3105         return false;
3106     }
3107
3108     // verify that the view's current state corresponds to the previous block
3109     uint256 hashPrevBlock = pindex->pprev == NULL ? uint256() : pindex->pprev->GetBlockHash();
3110     if ( hashPrevBlock != view.GetBestBlock() )
3111     {
3112         fprintf(stderr,"ConnectBlock(): hashPrevBlock != view.GetBestBlock()\n");
3113         return state.DoS(1, error("ConnectBlock(): hashPrevBlock != view.GetBestBlock()"),
3114                          REJECT_INVALID, "hashPrevBlock-not-bestblock");
3115     }
3116     assert(hashPrevBlock == view.GetBestBlock());
3117
3118     // Special case for the genesis block, skipping connection of its transactions
3119     // (its coinbase is unspendable)
3120     if (block.GetHash() == chainparams.GetConsensus().hashGenesisBlock) {
3121         if (!fJustCheck) {
3122             view.SetBestBlock(pindex->GetBlockHash());
3123             // Before the genesis block, there was an empty tree
3124             SproutMerkleTree tree;
3125             pindex->hashSproutAnchor = tree.root();
3126             // The genesis block contained no JoinSplits
3127             pindex->hashFinalSproutRoot = pindex->hashSproutAnchor;
3128         }
3129         return true;
3130     }
3131
3132     bool fScriptChecks = (!fCheckpointsEnabled || pindex->GetHeight() >= Checkpoints::GetTotalBlocksEstimate(chainparams.Checkpoints()));
3133     //if ( KOMODO_TESTNET_EXPIRATION != 0 && pindex->GetHeight() > KOMODO_TESTNET_EXPIRATION ) // "testnet"
3134     //    return(false);
3135     // Do not allow blocks that contain transactions which 'overwrite' older transactions,
3136     // unless those are already completely spent.
3137     BOOST_FOREACH(const CTransaction& tx, block.vtx) {
3138         const CCoins* coins = view.AccessCoins(tx.GetHash());
3139         if (coins && !coins->IsPruned())
3140             return state.DoS(100, error("ConnectBlock(): tried to overwrite transaction"),
3141                              REJECT_INVALID, "bad-txns-BIP30");
3142     }
3143
3144     unsigned int flags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY;
3145
3146     // DERSIG (BIP66) is also always enforced, but does not have a flag.
3147
3148     CBlockUndo blockundo;
3149
3150     if ( ASSETCHAINS_CC != 0 )
3151     {
3152         if ( scriptcheckqueue.IsIdle() == 0 )
3153         {
3154             fprintf(stderr,"scriptcheckqueue isnt idle\n");
3155             sleep(1);
3156         }
3157     }
3158     CCheckQueueControl<CScriptCheck> control(fExpensiveChecks && nScriptCheckThreads ? &scriptcheckqueue : NULL);
3159
3160     int64_t nTimeStart = GetTimeMicros();
3161     CAmount nFees = 0;
3162     int nInputs = 0;
3163     int64_t interest,sum = 0;
3164     unsigned int nSigOps = 0;
3165     CDiskTxPos pos(pindex->GetBlockPos(), GetSizeOfCompactSize(block.vtx.size()));
3166     std::vector<std::pair<uint256, CDiskTxPos> > vPos;
3167     vPos.reserve(block.vtx.size());
3168     blockundo.vtxundo.reserve(block.vtx.size() - 1);
3169     std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex;
3170     std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > addressUnspentIndex;
3171     std::vector<std::pair<CSpentIndexKey, CSpentIndexValue> > spentIndex;
3172     // Construct the incremental merkle tree at the current
3173     // block position,
3174     auto old_sprout_tree_root = view.GetBestAnchor(SPROUT);
3175     // saving the top anchor in the block index as we go.
3176     if (!fJustCheck) {
3177         pindex->hashSproutAnchor = old_sprout_tree_root;
3178     }
3179
3180     SproutMerkleTree sprout_tree;
3181
3182     // This should never fail: we should always be able to get the root
3183     // that is on the tip of our chain
3184     assert(view.GetSproutAnchorAt(old_sprout_tree_root, sprout_tree));
3185
3186     {
3187         // Consistency check: the root of the tree we're given should
3188         // match what we asked for.
3189         assert(sprout_tree.root() == old_sprout_tree_root);
3190     }
3191
3192     SaplingMerkleTree sapling_tree;
3193     assert(view.GetSaplingAnchorAt(view.GetBestAnchor(SAPLING), sapling_tree));
3194
3195     // Grab the consensus branch ID for the block's height
3196     auto consensusBranchId = CurrentEpochBranchId(pindex->GetHeight(), Params().GetConsensus());
3197
3198     std::vector<PrecomputedTransactionData> txdata;
3199     txdata.reserve(block.vtx.size()); // Required so that pointers to individual PrecomputedTransactionData don't get invalidated
3200     for (unsigned int i = 0; i < block.vtx.size(); i++)
3201     {
3202         const CTransaction &tx = block.vtx[i];
3203         const uint256 txhash = tx.GetHash();
3204         nInputs += tx.vin.size();
3205         nSigOps += GetLegacySigOpCount(tx);
3206         if (nSigOps > MAX_BLOCK_SIGOPS)
3207             return state.DoS(100, error("ConnectBlock(): too many sigops"),
3208                              REJECT_INVALID, "bad-blk-sigops");
3209         //fprintf(stderr,"ht.%d vout0 t%u\n",pindex->GetHeight(),tx.nLockTime);
3210         if (!tx.IsMint())
3211         {
3212             if (!view.HaveInputs(tx))
3213             {
3214                 return state.DoS(100, error("ConnectBlock(): inputs missing/spent"),
3215                                  REJECT_INVALID, "bad-txns-inputs-missingorspent");
3216             }
3217             // are the JoinSplit's requirements met?
3218             if (!view.HaveJoinSplitRequirements(tx))
3219                 return state.DoS(100, error("ConnectBlock(): JoinSplit requirements not met"),
3220                                  REJECT_INVALID, "bad-txns-joinsplit-requirements-not-met");
3221             if (fAddressIndex || fSpentIndex)
3222             {
3223                 for (size_t j = 0; j < tx.vin.size(); j++) {
3224
3225                     const CTxIn input = tx.vin[j];
3226                     const CTxOut &prevout = view.GetOutputFor(tx.vin[j]);
3227                     uint160 hashBytes;
3228                     int addressType;
3229
3230                     if (prevout.scriptPubKey.IsPayToScriptHash()) {
3231                         hashBytes = uint160(vector <unsigned char>(prevout.scriptPubKey.begin()+2, prevout.scriptPubKey.begin()+22));
3232                         addressType = 2;
3233                     }
3234                     else if (prevout.scriptPubKey.IsPayToPublicKeyHash()) {
3235                         hashBytes = uint160(vector <unsigned char>(prevout.scriptPubKey.begin()+3, prevout.scriptPubKey.begin()+23));
3236                         addressType = 1;
3237                     }
3238                     else if (prevout.scriptPubKey.IsPayToPublicKey()) {
3239                         hashBytes = Hash160(vector <unsigned char>(prevout.scriptPubKey.begin()+1, prevout.scriptPubKey.begin()+34));
3240                         addressType = 1;
3241                     }
3242                     else if (prevout.scriptPubKey.IsPayToCryptoCondition()) {
3243                         hashBytes = Hash160(vector <unsigned char>(prevout.scriptPubKey.begin(), prevout.scriptPubKey.end()));
3244                         addressType = 1;
3245                     }
3246                     else {
3247                         hashBytes.SetNull();
3248                         addressType = 0;
3249                     }
3250
3251                     if (fAddressIndex && addressType > 0) {
3252                         // record spending activity
3253                         addressIndex.push_back(make_pair(CAddressIndexKey(addressType, hashBytes, pindex->GetHeight(), i, txhash, j, true), prevout.nValue * -1));
3254
3255                         // remove address from unspent index
3256                         addressUnspentIndex.push_back(make_pair(CAddressUnspentKey(addressType, hashBytes, input.prevout.hash, input.prevout.n), CAddressUnspentValue()));
3257                     }
3258
3259                     if (fSpentIndex) {
3260                         // add the spent index to determine the txid and input that spent an output
3261                         // and to find the amount and address from an input
3262                         spentIndex.push_back(make_pair(CSpentIndexKey(input.prevout.hash, input.prevout.n), CSpentIndexValue(txhash, j, pindex->GetHeight(), prevout.nValue, addressType, hashBytes)));
3263                     }
3264                 }
3265
3266             }
3267             // Add in sigops done by pay-to-script-hash inputs;
3268             // this is to prevent a "rogue miner" from creating
3269             // an incredibly-expensive-to-validate block.
3270             nSigOps += GetP2SHSigOpCount(tx, view);
3271             if (nSigOps > MAX_BLOCK_SIGOPS)
3272                 return state.DoS(100, error("ConnectBlock(): too many sigops"),
3273                                  REJECT_INVALID, "bad-blk-sigops");
3274         }
3275
3276         txdata.emplace_back(tx);
3277
3278         if (!tx.IsCoinBase())
3279         {
3280             nFees += view.GetValueIn(chainActive.LastTip()->GetHeight(),&interest,tx,chainActive.LastTip()->nTime) - tx.GetValueOut();
3281             sum += interest;
3282
3283             std::vector<CScriptCheck> vChecks;
3284             if (!ContextualCheckInputs(tx, state, view, fExpensiveChecks, flags, false, txdata[i], chainparams.GetConsensus(), consensusBranchId, nScriptCheckThreads ? &vChecks : NULL))
3285                 return false;
3286             control.Add(vChecks);
3287         }
3288
3289         if (fAddressIndex) {
3290             for (unsigned int k = 0; k < tx.vout.size(); k++) {
3291                 const CTxOut &out = tx.vout[k];
3292 //fprintf(stderr,"add %d vouts\n",(int32_t)tx.vout.size());
3293                 if (out.scriptPubKey.IsPayToScriptHash()) {
3294                     vector<unsigned char> hashBytes(out.scriptPubKey.begin()+2, out.scriptPubKey.begin()+22);
3295
3296                     // record receiving activity
3297                     addressIndex.push_back(make_pair(CAddressIndexKey(2, uint160(hashBytes), pindex->GetHeight(), i, txhash, k, false), out.nValue));
3298
3299                     // record unspent output
3300                     addressUnspentIndex.push_back(make_pair(CAddressUnspentKey(2, uint160(hashBytes), txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->GetHeight())));
3301
3302                 }
3303                 else if (out.scriptPubKey.IsPayToPublicKeyHash()) {
3304                     vector<unsigned char> hashBytes(out.scriptPubKey.begin()+3, out.scriptPubKey.begin()+23);
3305
3306                     // record receiving activity
3307                     addressIndex.push_back(make_pair(CAddressIndexKey(1, uint160(hashBytes), pindex->GetHeight(), i, txhash, k, false), out.nValue));
3308
3309                     // record unspent output
3310                     addressUnspentIndex.push_back(make_pair(CAddressUnspentKey(1, uint160(hashBytes), txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->GetHeight())));
3311
3312                 }
3313                 else if (out.scriptPubKey.IsPayToPublicKey()) {
3314                     vector<unsigned char> hashBytes(out.scriptPubKey.begin()+1, out.scriptPubKey.begin()+34);
3315
3316                     // record receiving activity
3317                     addressIndex.push_back(make_pair(CAddressIndexKey(1, Hash160(hashBytes), pindex->GetHeight(), i, txhash, k, false), out.nValue));
3318
3319                     // record unspent output
3320                     addressUnspentIndex.push_back(make_pair(CAddressUnspentKey(1, Hash160(hashBytes), txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->GetHeight())));
3321
3322                 }
3323                 else if (out.scriptPubKey.IsPayToCryptoCondition()) {
3324                     vector<unsigned char> hashBytes(out.scriptPubKey.begin(), out.scriptPubKey.end());
3325
3326                     // record receiving activity
3327                     addressIndex.push_back(make_pair(CAddressIndexKey(1, Hash160(hashBytes), pindex->GetHeight(), i, txhash, k, false), out.nValue));
3328
3329                     // record unspent output
3330                     addressUnspentIndex.push_back(make_pair(CAddressUnspentKey(1, Hash160(hashBytes), txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->GetHeight())));
3331
3332                 }
3333                 else {
3334                     continue;
3335                 }
3336
3337             }
3338         }
3339
3340         //if ( ASSETCHAINS_SYMBOL[0] == 0 )
3341         //    komodo_earned_interest(pindex->GetHeight(),sum);
3342         CTxUndo undoDummy;
3343         if (i > 0) {
3344             blockundo.vtxundo.push_back(CTxUndo());
3345         }
3346         UpdateCoins(tx, view, i == 0 ? undoDummy : blockundo.vtxundo.back(), pindex->GetHeight());
3347
3348         BOOST_FOREACH(const JSDescription &joinsplit, tx.vjoinsplit) {
3349             BOOST_FOREACH(const uint256 &note_commitment, joinsplit.commitments) {
3350                 // Insert the note commitments into our temporary tree.
3351
3352                 sprout_tree.append(note_commitment);
3353             }
3354         }
3355
3356         BOOST_FOREACH(const OutputDescription &outputDescription, tx.vShieldedOutput) {
3357             sapling_tree.append(outputDescription.cm);
3358         }
3359
3360         vPos.push_back(std::make_pair(tx.GetHash(), pos));
3361         pos.nTxOffset += ::GetSerializeSize(tx, SER_DISK, CLIENT_VERSION);
3362     }
3363
3364     view.PushAnchor(sprout_tree);
3365     view.PushAnchor(sapling_tree);
3366     if (!fJustCheck) {
3367         pindex->hashFinalSproutRoot = sprout_tree.root();
3368     }
3369     blockundo.old_sprout_tree_root = old_sprout_tree_root;
3370
3371     // If Sapling is active, block.hashFinalSaplingRoot must be the
3372     // same as the root of the Sapling tree
3373     if (NetworkUpgradeActive(pindex->GetHeight(), chainparams.GetConsensus(), Consensus::UPGRADE_SAPLING)) {
3374         if (block.hashFinalSaplingRoot != sapling_tree.root()) {
3375             return state.DoS(100,
3376                          error("ConnectBlock(): block's hashFinalSaplingRoot is incorrect"),
3377                                REJECT_INVALID, "bad-sapling-root-in-block");
3378         }
3379     }
3380     int64_t nTime1 = GetTimeMicros(); nTimeConnect += nTime1 - nTimeStart;
3381     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);
3382
3383     CAmount blockReward = nFees + GetBlockSubsidy(pindex->GetHeight(), chainparams.GetConsensus()) + sum;
3384     if ( ASSETCHAINS_OVERRIDE_PUBKEY33[0] != 0 && ASSETCHAINS_COMMISSION != 0 )
3385     {
3386         uint64_t checktoshis;
3387         if ( (checktoshis= komodo_commission((CBlock *)&block)) != 0 )
3388         {
3389             if ( block.vtx[0].vout.size() == 2 && block.vtx[0].vout[1].nValue == checktoshis )
3390                 blockReward += checktoshis;
3391             else fprintf(stderr,"checktoshis %.8f numvouts %d\n",dstr(checktoshis),(int32_t)block.vtx[0].vout.size());
3392         }
3393     }
3394     if (ASSETCHAINS_SYMBOL[0] != 0 && pindex->GetHeight() == 1 && block.vtx[0].GetValueOut() != blockReward)
3395     {
3396         return state.DoS(100, error("ConnectBlock(): coinbase for block 1 pays wrong amount (actual=%d vs correct=%d)", block.vtx[0].GetValueOut(), blockReward),
3397                             REJECT_INVALID, "bad-cb-amount");
3398     }
3399     if ( block.vtx[0].GetValueOut() > blockReward+1 )
3400     {
3401         if ( ASSETCHAINS_SYMBOL[0] != 0 || pindex->GetHeight() >= KOMODO_NOTARIES_HEIGHT1 || block.vtx[0].vout[0].nValue > blockReward )
3402         {
3403             return state.DoS(100,
3404                              error("ConnectBlock(): coinbase pays too much (actual=%d vs limit=%d)",
3405                                    block.vtx[0].GetValueOut(), blockReward),
3406                              REJECT_INVALID, "bad-cb-amount");
3407         } else if ( IS_KOMODO_NOTARY != 0 )
3408             fprintf(stderr,"allow nHeight.%d coinbase %.8f vs %.8f interest %.8f\n",(int32_t)pindex->GetHeight(),dstr(block.vtx[0].GetValueOut()),dstr(blockReward),dstr(sum));
3409     }
3410     if (!control.Wait())
3411         return state.DoS(100, false);
3412     int64_t nTime2 = GetTimeMicros(); nTimeVerify += nTime2 - nTimeStart;
3413     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);
3414
3415     if (fJustCheck)
3416         return true;
3417
3418     // Write undo information to disk
3419     if (pindex->GetUndoPos().IsNull() || !pindex->IsValid(BLOCK_VALID_SCRIPTS))
3420     {
3421         if (pindex->GetUndoPos().IsNull()) {
3422             CDiskBlockPos pos;
3423             if (!FindUndoPos(state, pindex->nFile, pos, ::GetSerializeSize(blockundo, SER_DISK, CLIENT_VERSION) + 40))
3424                 return error("ConnectBlock(): FindUndoPos failed");
3425             if (!UndoWriteToDisk(blockundo, pos, pindex->pprev->GetBlockHash(), chainparams.MessageStart()))
3426                 return AbortNode(state, "Failed to write undo data");
3427
3428             // update nUndoPos in block index
3429             pindex->nUndoPos = pos.nPos;
3430             pindex->nStatus |= BLOCK_HAVE_UNDO;
3431         }
3432
3433         // Now that all consensus rules have been validated, set nCachedBranchId.
3434         // Move this if BLOCK_VALID_CONSENSUS is ever altered.
3435         static_assert(BLOCK_VALID_CONSENSUS == BLOCK_VALID_SCRIPTS,
3436                       "nCachedBranchId must be set after all consensus rules have been validated.");
3437         if (IsActivationHeightForAnyUpgrade(pindex->GetHeight(), Params().GetConsensus())) {
3438             pindex->nStatus |= BLOCK_ACTIVATES_UPGRADE;
3439             pindex->nCachedBranchId = CurrentEpochBranchId(pindex->GetHeight(), chainparams.GetConsensus());
3440         } else if (pindex->pprev) {
3441             pindex->nCachedBranchId = pindex->pprev->nCachedBranchId;
3442         }
3443
3444         pindex->RaiseValidity(BLOCK_VALID_SCRIPTS);
3445         setDirtyBlockIndex.insert(pindex);
3446     }
3447
3448     ConnectNotarisations(block, pindex->GetHeight());
3449
3450     if (fTxIndex)
3451         if (!pblocktree->WriteTxIndex(vPos))
3452             return AbortNode(state, "Failed to write transaction index");
3453     if (fAddressIndex) {
3454         if (!pblocktree->WriteAddressIndex(addressIndex)) {
3455             return AbortNode(state, "Failed to write address index");
3456         }
3457
3458         if (!pblocktree->UpdateAddressUnspentIndex(addressUnspentIndex)) {
3459             return AbortNode(state, "Failed to write address unspent index");
3460         }
3461     }
3462
3463     if (fSpentIndex)
3464         if (!pblocktree->UpdateSpentIndex(spentIndex))
3465             return AbortNode(state, "Failed to write transaction index");
3466
3467     if (fTimestampIndex) {
3468         unsigned int logicalTS = pindex->nTime;
3469         unsigned int prevLogicalTS = 0;
3470
3471         // retrieve logical timestamp of the previous block
3472         if (pindex->pprev)
3473             if (!pblocktree->ReadTimestampBlockIndex(pindex->pprev->GetBlockHash(), prevLogicalTS))
3474                 LogPrintf("%s: Failed to read previous block's logical timestamp\n", __func__);
3475
3476         if (logicalTS <= prevLogicalTS) {
3477             logicalTS = prevLogicalTS + 1;
3478             LogPrintf("%s: Previous logical timestamp is newer Actual[%d] prevLogical[%d] Logical[%d]\n", __func__, pindex->nTime, prevLogicalTS, logicalTS);
3479         }
3480
3481         if (!pblocktree->WriteTimestampIndex(CTimestampIndexKey(logicalTS, pindex->GetBlockHash())))
3482             return AbortNode(state, "Failed to write timestamp index");
3483
3484         if (!pblocktree->WriteTimestampBlockIndex(CTimestampBlockIndexKey(pindex->GetBlockHash()), CTimestampBlockIndexValue(logicalTS)))
3485             return AbortNode(state, "Failed to write blockhash index");
3486     }
3487
3488     // add this block to the view's block chain
3489     view.SetBestBlock(pindex->GetBlockHash());
3490
3491     int64_t nTime3 = GetTimeMicros(); nTimeIndex += nTime3 - nTime2;
3492     LogPrint("bench", "    - Index writing: %.2fms [%.2fs]\n", 0.001 * (nTime3 - nTime2), nTimeIndex * 0.000001);
3493
3494     // Watch for changes to the previous coinbase transaction.
3495     static uint256 hashPrevBestCoinBase;
3496     GetMainSignals().UpdatedTransaction(hashPrevBestCoinBase);
3497     hashPrevBestCoinBase = block.vtx[0].GetHash();
3498
3499     int64_t nTime4 = GetTimeMicros(); nTimeCallbacks += nTime4 - nTime3;
3500     LogPrint("bench", "    - Callbacks: %.2fms [%.2fs]\n", 0.001 * (nTime4 - nTime3), nTimeCallbacks * 0.000001);
3501
3502     //FlushStateToDisk();
3503     komodo_connectblock(pindex,*(CBlock *)&block);
3504     return true;
3505 }
3506
3507 enum FlushStateMode {
3508     FLUSH_STATE_NONE,
3509     FLUSH_STATE_IF_NEEDED,
3510     FLUSH_STATE_PERIODIC,
3511     FLUSH_STATE_ALWAYS
3512 };
3513
3514 /**
3515  * Update the on-disk chain state.
3516  * The caches and indexes are flushed depending on the mode we're called with
3517  * if they're too large, if it's been a while since the last write,
3518  * or always and in all cases if we're in prune mode and are deleting files.
3519  */
3520 bool static FlushStateToDisk(CValidationState &state, FlushStateMode mode) {
3521     LOCK2(cs_main, cs_LastBlockFile);
3522     static int64_t nLastWrite = 0;
3523     static int64_t nLastFlush = 0;
3524     static int64_t nLastSetChain = 0;
3525     std::set<int> setFilesToPrune;
3526     bool fFlushForPrune = false;
3527     try {
3528         if (fPruneMode && fCheckForPruning && !fReindex) {
3529             FindFilesToPrune(setFilesToPrune);
3530             fCheckForPruning = false;
3531             if (!setFilesToPrune.empty()) {
3532                 fFlushForPrune = true;
3533                 if (!fHavePruned) {
3534                     pblocktree->WriteFlag("prunedblockfiles", true);
3535                     fHavePruned = true;
3536                 }
3537             }
3538         }
3539         int64_t nNow = GetTimeMicros();
3540         // Avoid writing/flushing immediately after startup.
3541         if (nLastWrite == 0) {
3542             nLastWrite = nNow;
3543         }
3544         if (nLastFlush == 0) {
3545             nLastFlush = nNow;
3546         }
3547         if (nLastSetChain == 0) {
3548             nLastSetChain = nNow;
3549         }
3550         size_t cacheSize = pcoinsTip->DynamicMemoryUsage();
3551         // The cache is large and close to the limit, but we have time now (not in the middle of a block processing).
3552         bool fCacheLarge = mode == FLUSH_STATE_PERIODIC && cacheSize * (10.0/9) > nCoinCacheUsage;
3553         // The cache is over the limit, we have to write now.
3554         bool fCacheCritical = mode == FLUSH_STATE_IF_NEEDED && cacheSize > nCoinCacheUsage;
3555         // 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.
3556         bool fPeriodicWrite = mode == FLUSH_STATE_PERIODIC && nNow > nLastWrite + (int64_t)DATABASE_WRITE_INTERVAL * 1000000;
3557         // It's been very long since we flushed the cache. Do this infrequently, to optimize cache usage.
3558         bool fPeriodicFlush = mode == FLUSH_STATE_PERIODIC && nNow > nLastFlush + (int64_t)DATABASE_FLUSH_INTERVAL * 1000000;
3559         // Combine all conditions that result in a full cache flush.
3560         bool fDoFullFlush = (mode == FLUSH_STATE_ALWAYS) || fCacheLarge || fCacheCritical || fPeriodicFlush || fFlushForPrune;
3561         // Write blocks and block index to disk.
3562         if (fDoFullFlush || fPeriodicWrite) {
3563             // Depend on nMinDiskSpace to ensure we can write block index
3564             if (!CheckDiskSpace(0))
3565                 return state.Error("out of disk space");
3566             // First make sure all block and undo data is flushed to disk.
3567             FlushBlockFile();
3568             // Then update all block file information (which may refer to block and undo files).
3569             {
3570                 std::vector<std::pair<int, const CBlockFileInfo*> > vFiles;
3571                 vFiles.reserve(setDirtyFileInfo.size());
3572                 for (set<int>::iterator it = setDirtyFileInfo.begin(); it != setDirtyFileInfo.end(); ) {
3573                     vFiles.push_back(make_pair(*it, &vinfoBlockFile[*it]));
3574                     setDirtyFileInfo.erase(it++);
3575                 }
3576                 std::vector<const CBlockIndex*> vBlocks;
3577                 vBlocks.reserve(setDirtyBlockIndex.size());
3578                 for (set<CBlockIndex*>::iterator it = setDirtyBlockIndex.begin(); it != setDirtyBlockIndex.end(); ) {
3579                     vBlocks.push_back(*it);
3580                     setDirtyBlockIndex.erase(it++);
3581                 }
3582                 if (!pblocktree->WriteBatchSync(vFiles, nLastBlockFile, vBlocks)) {
3583                     return AbortNode(state, "Files to write to block index database");
3584                 }
3585             }
3586             // Finally remove any pruned files
3587             if (fFlushForPrune)
3588                 UnlinkPrunedFiles(setFilesToPrune);
3589             nLastWrite = nNow;
3590         }
3591         // Flush best chain related state. This can only be done if the blocks / block index write was also done.
3592         if (fDoFullFlush) {
3593             // Typical CCoins structures on disk are around 128 bytes in size.
3594             // Pushing a new one to the database can cause it to be written
3595             // twice (once in the log, and once in the tables). This is already
3596             // an overestimation, as most will delete an existing entry or
3597             // overwrite one. Still, use a conservative safety factor of 2.
3598             if (!CheckDiskSpace(128 * 2 * 2 * pcoinsTip->GetCacheSize()))
3599                 return state.Error("out of disk space");
3600             // Flush the chainstate (which may refer to block index entries).
3601             if (!pcoinsTip->Flush())
3602                 return AbortNode(state, "Failed to write to coin database");
3603             nLastFlush = nNow;
3604         }
3605         if ((mode == FLUSH_STATE_ALWAYS || mode == FLUSH_STATE_PERIODIC) && nNow > nLastSetChain + (int64_t)DATABASE_WRITE_INTERVAL * 1000000) {
3606             // Update best block in wallet (so we can detect restored wallets).
3607             GetMainSignals().SetBestChain(chainActive.GetLocator());
3608             nLastSetChain = nNow;
3609         }
3610     } catch (const std::runtime_error& e) {
3611         return AbortNode(state, std::string("System error while flushing: ") + e.what());
3612     }
3613     return true;
3614 }
3615
3616 void FlushStateToDisk() {
3617     CValidationState state;
3618     FlushStateToDisk(state, FLUSH_STATE_ALWAYS);
3619 }
3620
3621 void PruneAndFlush() {
3622     CValidationState state;
3623     fCheckForPruning = true;
3624     FlushStateToDisk(state, FLUSH_STATE_NONE);
3625 }
3626
3627 /** Update chainActive and related internal data structures. */
3628 void static UpdateTip(CBlockIndex *pindexNew) {
3629     const CChainParams& chainParams = Params();
3630     chainActive.SetTip(pindexNew);
3631
3632     // New best block
3633     nTimeBestReceived = GetTime();
3634     mempool.AddTransactionsUpdated(1);
3635     KOMODO_NEWBLOCKS++;
3636     double progress;
3637     if ( ASSETCHAINS_SYMBOL[0] == 0 ) {
3638         progress = Checkpoints::GuessVerificationProgress(chainParams.Checkpoints(), chainActive.LastTip());
3639     } else {
3640         int32_t longestchain = komodo_longestchain();
3641         progress = (longestchain > 0 ) ? (double) chainActive.Height() / longestchain : 1.0;
3642     }
3643
3644     LogPrintf("%s: new best=%s  height=%d  log2_work=%.8g  log2_stake=%.8g  tx=%lu  date=%s progress=%f  cache=%.1fMiB(%utx)\n", __func__,
3645               chainActive.LastTip()->GetBlockHash().ToString(), chainActive.Height(),
3646               log(chainActive.Tip()->chainPower.chainWork.getdouble())/log(2.0),
3647               log(chainActive.Tip()->chainPower.chainStake.getdouble())/log(2.0),
3648               (unsigned long)chainActive.LastTip()->nChainTx,
3649               DateTimeStrFormat("%Y-%m-%d %H:%M:%S", chainActive.LastTip()->GetBlockTime()), progress,
3650               pcoinsTip->DynamicMemoryUsage() * (1.0 / (1<<20)), pcoinsTip->GetCacheSize());
3651
3652     cvBlockChange.notify_all();
3653
3654     // Check the version of the last 100 blocks to see if we need to upgrade:
3655     static bool fWarned = false;
3656     if (!IsInitialBlockDownload() && !fWarned)
3657     {
3658         int nUpgraded = 0;
3659         const CBlockIndex* pindex = chainActive.Tip();
3660         for (int i = 0; i < 100 && pindex != NULL; i++)
3661         {
3662             if (pindex->nVersion > CBlock::CURRENT_VERSION)
3663                 ++nUpgraded;
3664             pindex = pindex->pprev;
3665         }
3666         if (nUpgraded > 0)
3667             LogPrintf("%s: %d of last 100 blocks above version %d\n", __func__, nUpgraded, (int)CBlock::CURRENT_VERSION);
3668         if (nUpgraded > 100/2)
3669         {
3670             // strMiscWarning is read by GetWarnings(), called by the JSON-RPC code to warn the user:
3671             strMiscWarning = _("Warning: This version is obsolete; upgrade required!");
3672             CAlert::Notify(strMiscWarning, true);
3673             fWarned = true;
3674         }
3675     }
3676 }
3677
3678 /**
3679  * Disconnect chainActive's tip. You probably want to call mempool.removeForReorg and
3680  * mempool.removeWithoutBranchId after this, with cs_main held.
3681  */
3682 bool static DisconnectTip(CValidationState &state, bool fBare = false) {
3683     CBlockIndex *pindexDelete = chainActive.Tip();
3684     assert(pindexDelete);
3685     // Read block from disk.
3686     CBlock block;
3687     if (!ReadBlockFromDisk(block, pindexDelete,1))
3688         return AbortNode(state, "Failed to read block");
3689     // Apply the block atomically to the chain state.
3690     uint256 sproutAnchorBeforeDisconnect = pcoinsTip->GetBestAnchor(SPROUT);
3691     uint256 saplingAnchorBeforeDisconnect = pcoinsTip->GetBestAnchor(SAPLING);
3692     int64_t nStart = GetTimeMicros();
3693     {
3694         CCoinsViewCache view(pcoinsTip);
3695         if (!DisconnectBlock(block, state, pindexDelete, view))
3696             return error("DisconnectTip(): DisconnectBlock %s failed", pindexDelete->GetBlockHash().ToString());
3697         assert(view.Flush());
3698         DisconnectNotarisations(block);
3699     }
3700     pindexDelete->segid = -2;
3701     pindexDelete->newcoins = 0;
3702     pindexDelete->zfunds = 0;
3703
3704     LogPrint("bench", "- Disconnect block: %.2fms\n", (GetTimeMicros() - nStart) * 0.001);
3705     uint256 sproutAnchorAfterDisconnect = pcoinsTip->GetBestAnchor(SPROUT);
3706     uint256 saplingAnchorAfterDisconnect = pcoinsTip->GetBestAnchor(SAPLING);
3707     // Write the chain state to disk, if necessary.
3708     if (!FlushStateToDisk(state, FLUSH_STATE_IF_NEEDED))
3709         return false;
3710
3711     if (!fBare) {
3712         // resurrect mempool transactions from the disconnected block.
3713         for (int i = 0; i < block.vtx.size(); i++)
3714         {
3715             // ignore validation errors in resurrected transactions
3716             CTransaction &tx = block.vtx[i];
3717             list<CTransaction> removed;
3718             CValidationState stateDummy;
3719             // don't keep staking or invalid transactions
3720             if (tx.IsCoinBase() || ((i == (block.vtx.size() - 1)) && ((ASSETCHAINS_LWMAPOS && block.IsVerusPOSBlock()) || (ASSETCHAINS_STAKED && komodo_isPoS((CBlock *)&block) != 0))) || !AcceptToMemoryPool(mempool, stateDummy, tx, false, NULL))
3721             {
3722                 mempool.remove(tx, removed, true);
3723             }
3724
3725             // if this is a staking tx, and we are on Verus Sapling with nothing at stake solution,
3726             // save staking tx as a possible cheat
3727             if (NetworkUpgradeActive(pindexDelete->GetHeight(), Params().GetConsensus(), Consensus::UPGRADE_SAPLING) &&
3728                 ASSETCHAINS_LWMAPOS && (i == (block.vtx.size() - 1)) &&
3729                 (block.IsVerusPOSBlock()))
3730             {
3731                 CTxHolder txh = CTxHolder(block.vtx[i], pindexDelete->GetHeight());
3732                 cheatList.Add(txh);
3733             }
3734         }
3735         if (sproutAnchorBeforeDisconnect != sproutAnchorAfterDisconnect) {
3736             // The anchor may not change between block disconnects,
3737             // in which case we don't want to evict from the mempool yet!
3738             mempool.removeWithAnchor(sproutAnchorBeforeDisconnect, SPROUT);
3739         }
3740         if (saplingAnchorBeforeDisconnect != saplingAnchorAfterDisconnect) {
3741             // The anchor may not change between block disconnects,
3742             // in which case we don't want to evict from the mempool yet!
3743             mempool.removeWithAnchor(saplingAnchorBeforeDisconnect, SAPLING);
3744         }
3745     }
3746
3747     // Update chainActive and related variables.
3748     UpdateTip(pindexDelete->pprev);
3749
3750     // Get the current commitment tree
3751     SproutMerkleTree newSproutTree;
3752     SaplingMerkleTree newSaplingTree;
3753     assert(pcoinsTip->GetSproutAnchorAt(pcoinsTip->GetBestAnchor(SPROUT), newSproutTree));
3754     assert(pcoinsTip->GetSaplingAnchorAt(pcoinsTip->GetBestAnchor(SAPLING), newSaplingTree));
3755     // Let wallets know transactions went from 1-confirmed to
3756     // 0-confirmed or conflicted:
3757     for (int i = 0; i < block.vtx.size(); i++)
3758     {
3759         CTransaction &tx = block.vtx[i];
3760         if ((i == (block.vtx.size() - 1)) && ((ASSETCHAINS_LWMAPOS && block.IsVerusPOSBlock()) || (ASSETCHAINS_STAKED != 0 && (komodo_isPoS((CBlock *)&block) != 0))))
3761         {
3762             EraseFromWallets(tx.GetHash());
3763         }
3764         else
3765         {
3766             SyncWithWallets(tx, NULL);
3767         }
3768     }
3769     // Update cached incremental witnesses
3770     GetMainSignals().ChainTip(pindexDelete, &block, newSproutTree, newSaplingTree, false);
3771     return true;
3772 }
3773
3774 static int64_t nTimeReadFromDisk = 0;
3775 static int64_t nTimeConnectTotal = 0;
3776 static int64_t nTimeFlush = 0;
3777 static int64_t nTimeChainState = 0;
3778 static int64_t nTimePostConnect = 0;
3779
3780 /**
3781  * Connect a new block to chainActive. pblock is either NULL or a pointer to a CBlock
3782  * corresponding to pindexNew, to bypass loading it again from disk.
3783  * You probably want to call mempool.removeWithoutBranchId after this, with cs_main held.
3784  */
3785 bool static ConnectTip(CValidationState &state, CBlockIndex *pindexNew, CBlock *pblock) {
3786
3787     assert(pindexNew->pprev == chainActive.Tip());
3788     // Read block from disk.
3789     int64_t nTime1 = GetTimeMicros();
3790     CBlock block;
3791     if (!pblock) {
3792         if (!ReadBlockFromDisk(block, pindexNew,1))
3793             return AbortNode(state, "Failed to read block");
3794         pblock = &block;
3795     }
3796     KOMODO_CONNECTING = (int32_t)pindexNew->GetHeight();
3797     // Get the current commitment tree
3798     SproutMerkleTree oldSproutTree;
3799     SaplingMerkleTree oldSaplingTree;
3800     assert(pcoinsTip->GetSproutAnchorAt(pcoinsTip->GetBestAnchor(SPROUT), oldSproutTree));
3801     assert(pcoinsTip->GetSaplingAnchorAt(pcoinsTip->GetBestAnchor(SAPLING), oldSaplingTree));
3802     // Apply the block atomically to the chain state.
3803     int64_t nTime2 = GetTimeMicros(); nTimeReadFromDisk += nTime2 - nTime1;
3804     int64_t nTime3;
3805     LogPrint("bench", "  - Load block from disk: %.2fms [%.2fs]\n", (nTime2 - nTime1) * 0.001, nTimeReadFromDisk * 0.000001);
3806     {
3807         CCoinsViewCache view(pcoinsTip);
3808         bool rv = ConnectBlock(*pblock, state, pindexNew, view, false, true);
3809         KOMODO_CONNECTING = -1;
3810         GetMainSignals().BlockChecked(*pblock, state);
3811         if (!rv) {
3812             if (state.IsInvalid())
3813                 InvalidBlockFound(pindexNew, state);
3814             return error("ConnectTip(): ConnectBlock %s failed", pindexNew->GetBlockHash().ToString());
3815         }
3816         mapBlockSource.erase(pindexNew->GetBlockHash());
3817         nTime3 = GetTimeMicros(); nTimeConnectTotal += nTime3 - nTime2;
3818         LogPrint("bench", "  - Connect total: %.2fms [%.2fs]\n", (nTime3 - nTime2) * 0.001, nTimeConnectTotal * 0.000001);
3819         assert(view.Flush());
3820     }
3821     int64_t nTime4 = GetTimeMicros(); nTimeFlush += nTime4 - nTime3;
3822     LogPrint("bench", "  - Flush: %.2fms [%.2fs]\n", (nTime4 - nTime3) * 0.001, nTimeFlush * 0.000001);
3823     // Write the chain state to disk, if necessary.
3824     if (!FlushStateToDisk(state, FLUSH_STATE_IF_NEEDED))
3825         return false;
3826     int64_t nTime5 = GetTimeMicros(); nTimeChainState += nTime5 - nTime4;
3827     LogPrint("bench", "  - Writing chainstate: %.2fms [%.2fs]\n", (nTime5 - nTime4) * 0.001, nTimeChainState * 0.000001);
3828     // Remove conflicting transactions from the mempool.
3829     list<CTransaction> txConflicted;
3830     mempool.removeForBlock(pblock->vtx, pindexNew->GetHeight(), txConflicted, !IsInitialBlockDownload());
3831
3832     // Remove transactions that expire at new block height from mempool
3833     mempool.removeExpired(pindexNew->GetHeight());
3834
3835     // Update chainActive & related variables.
3836     UpdateTip(pindexNew);
3837     // Tell wallet about transactions that went from mempool
3838     // to conflicted:
3839     BOOST_FOREACH(const CTransaction &tx, txConflicted) {
3840         SyncWithWallets(tx, NULL);
3841     }
3842     // ... and about transactions that got confirmed:
3843     BOOST_FOREACH(const CTransaction &tx, pblock->vtx) {
3844         SyncWithWallets(tx, pblock);
3845     }
3846     // Update cached incremental witnesses
3847     GetMainSignals().ChainTip(pindexNew, pblock, oldSproutTree, oldSaplingTree, true);
3848
3849     EnforceNodeDeprecation(pindexNew->GetHeight());
3850
3851     int64_t nTime6 = GetTimeMicros(); nTimePostConnect += nTime6 - nTime5; nTimeTotal += nTime6 - nTime1;
3852     LogPrint("bench", "  - Connect postprocess: %.2fms [%.2fs]\n", (nTime6 - nTime5) * 0.001, nTimePostConnect * 0.000001);
3853     LogPrint("bench", "- Connect block: %.2fms [%.2fs]\n", (nTime6 - nTime1) * 0.001, nTimeTotal * 0.000001);
3854     if ( KOMODO_LONGESTCHAIN != 0 && pindexNew->GetHeight() >= KOMODO_LONGESTCHAIN )
3855         KOMODO_INSYNC = 1;
3856     else KOMODO_INSYNC = 0;
3857     //fprintf(stderr,"connect.%d insync.%d\n",(int32_t)pindexNew->GetHeight(),KOMODO_INSYNC);
3858     if ( ASSETCHAINS_SYMBOL[0] == 0 && KOMODO_INSYNC != 0 )
3859         komodo_broadcast(pblock,8);
3860     return true;
3861 }
3862
3863 /**
3864  * Return the tip of the chain with the most work in it, that isn't
3865  * known to be invalid (it's however far from certain to be valid).
3866  */
3867 static CBlockIndex* FindMostWorkChain() {
3868     do {
3869         CBlockIndex *pindexNew = NULL;
3870
3871         // Find the best candidate header.
3872         {
3873             std::set<CBlockIndex*, CBlockIndexWorkComparator>::reverse_iterator it = setBlockIndexCandidates.rbegin();
3874             if (it == setBlockIndexCandidates.rend())
3875                 return NULL;
3876             pindexNew = *it;
3877         }
3878
3879         // Check whether all blocks on the path between the currently active chain and the candidate are valid.
3880         // Just going until the active chain is an optimization, as we know all blocks in it are valid already.
3881         CBlockIndex *pindexTest = pindexNew;
3882         bool fInvalidAncestor = false;
3883         while (pindexTest && !chainActive.Contains(pindexTest)) {
3884             assert(pindexTest->nChainTx || pindexTest->GetHeight() == 0);
3885
3886             // Pruned nodes may have entries in setBlockIndexCandidates for
3887             // which block files have been deleted.  Remove those as candidates
3888             // for the most work chain if we come across them; we can't switch
3889             // to a chain unless we have all the non-active-chain parent blocks.
3890             bool fFailedChain = pindexTest->nStatus & BLOCK_FAILED_MASK;
3891             bool fMissingData = !(pindexTest->nStatus & BLOCK_HAVE_DATA);
3892             if (fFailedChain || fMissingData) {
3893                 // Candidate chain is not usable (either invalid or missing data)
3894                 if (fFailedChain && (pindexBestInvalid == NULL || pindexNew->chainPower > pindexBestInvalid->chainPower))
3895                     pindexBestInvalid = pindexNew;
3896                 CBlockIndex *pindexFailed = pindexNew;
3897                 // Remove the entire chain from the set.
3898                 while (pindexTest != pindexFailed) {
3899                     if (fFailedChain) {
3900                         pindexFailed->nStatus |= BLOCK_FAILED_CHILD;
3901                     } else if (fMissingData) {
3902                         // If we're missing data, then add back to mapBlocksUnlinked,
3903                         // so that if the block arrives in the future we can try adding
3904                         // to setBlockIndexCandidates again.
3905                         mapBlocksUnlinked.insert(std::make_pair(pindexFailed->pprev, pindexFailed));
3906                     }
3907                     setBlockIndexCandidates.erase(pindexFailed);
3908                     pindexFailed = pindexFailed->pprev;
3909                 }
3910                 setBlockIndexCandidates.erase(pindexTest);
3911                 fInvalidAncestor = true;
3912                 break;
3913             }
3914             pindexTest = pindexTest->pprev;
3915         }
3916         if (!fInvalidAncestor)
3917             return pindexNew;
3918     } while(true);
3919 }
3920
3921 /** Delete all entries in setBlockIndexCandidates that are worse than the current tip. */
3922 static void PruneBlockIndexCandidates() {
3923     // Note that we can't delete the current block itself, as we may need to return to it later in case a
3924     // reorganization to a better block fails.
3925     std::set<CBlockIndex*, CBlockIndexWorkComparator>::iterator it = setBlockIndexCandidates.begin();
3926     while (it != setBlockIndexCandidates.end() && setBlockIndexCandidates.value_comp()(*it, chainActive.LastTip())) {
3927         setBlockIndexCandidates.erase(it++);
3928     }
3929     // Either the current tip or a successor of it we're working towards is left in setBlockIndexCandidates.
3930     assert(!setBlockIndexCandidates.empty());
3931 }
3932
3933 /**
3934  * Try to make some progress towards making pindexMostWork the active block.
3935  * pblock is either NULL or a pointer to a CBlock corresponding to pindexMostWork.
3936  */
3937 static bool ActivateBestChainStep(CValidationState &state, CBlockIndex *pindexMostWork, CBlock *pblock) {
3938     AssertLockHeld(cs_main);
3939     bool fInvalidFound = false;
3940     const CBlockIndex *pindexOldTip = chainActive.Tip();
3941     const CBlockIndex *pindexFork = chainActive.FindFork(pindexMostWork);
3942
3943     // - On ChainDB initialization, pindexOldTip will be null, so there are no removable blocks.
3944     // - If pindexMostWork is in a chain that doesn't have the same genesis block as our chain,
3945     //   then pindexFork will be null, and we would need to remove the entire chain including
3946     //   our genesis block. In practice this (probably) won't happen because of checks elsewhere.
3947     auto reorgLength = pindexOldTip ? pindexOldTip->GetHeight() - (pindexFork ? pindexFork->GetHeight() : -1) : 0;
3948     static_assert(MAX_REORG_LENGTH > 0, "We must be able to reorg some distance");
3949     if (reorgLength > MAX_REORG_LENGTH) {
3950         auto msg = strprintf(_(
3951                                "A block chain reorganization has been detected that would roll back %d blocks! "
3952                                "This is larger than the maximum of %d blocks, and so the node is shutting down for your safety."
3953                                ), reorgLength, MAX_REORG_LENGTH) + "\n\n" +
3954         _("Reorganization details") + ":\n" +
3955         "- " + strprintf(_("Current tip: %s, height %d, work %s\nstake %s"),
3956                          pindexOldTip->phashBlock->GetHex(), pindexOldTip->GetHeight(), pindexOldTip->chainPower.chainWork.GetHex(),
3957                          pindexOldTip->chainPower.chainStake.GetHex()) + "\n" +
3958         "- " + strprintf(_("New tip:     %s, height %d, work %s\nstake %s"),
3959                          pindexMostWork->phashBlock->GetHex(), pindexMostWork->GetHeight(), pindexMostWork->chainPower.chainWork.GetHex(),
3960                          pindexMostWork->chainPower.chainStake.GetHex()) + "\n" +
3961         "- " + strprintf(_("Fork point:  %s %s, height %d"),
3962                          ASSETCHAINS_SYMBOL,pindexFork->phashBlock->GetHex(), pindexFork->GetHeight()) + "\n\n" +
3963         _("Please help, human!");
3964         LogPrintf("*** %s\n", msg);
3965         uiInterface.ThreadSafeMessageBox(msg, "", CClientUIInterface::MSG_ERROR);
3966         StartShutdown();
3967         return false;
3968     }
3969
3970     // Disconnect active blocks which are no longer in the best chain.
3971     bool fBlocksDisconnected = false;
3972
3973     while (chainActive.Tip() && chainActive.Tip() != pindexFork) {
3974         if (!DisconnectTip(state))
3975             return false;
3976         fBlocksDisconnected = true;
3977     }
3978     if ( KOMODO_REWIND != 0 )
3979     {
3980         CBlockIndex *tipindex;
3981         fprintf(stderr,">>>>>>>>>>> rewind start ht.%d -> KOMODO_REWIND.%d\n",chainActive.LastTip()->GetHeight(),KOMODO_REWIND);
3982         while ( KOMODO_REWIND > 0 && (tipindex= chainActive.LastTip()) != 0 && tipindex->GetHeight() > KOMODO_REWIND )
3983         {
3984             fBlocksDisconnected = true;
3985             fprintf(stderr,"%d ",(int32_t)tipindex->GetHeight());
3986             InvalidateBlock(state,tipindex);
3987             if ( !DisconnectTip(state) )
3988                 break;
3989         }
3990         fprintf(stderr,"reached rewind.%d, best to do: ./komodo-cli -ac_name=%s stop\n",KOMODO_REWIND,ASSETCHAINS_SYMBOL);
3991         sleep(20);
3992         fprintf(stderr,"resuming normal operations\n");
3993         KOMODO_REWIND = 0;
3994         //return(true);
3995     }
3996     // Build list of new blocks to connect.
3997     std::vector<CBlockIndex*> vpindexToConnect;
3998     bool fContinue = true;
3999     int nHeight = pindexFork ? pindexFork->GetHeight() : -1;
4000     while (fContinue && nHeight != pindexMostWork->GetHeight()) {
4001         // Don't iterate the entire list of potential improvements toward the best tip, as we likely only need
4002         // a few blocks along the way.
4003         int nTargetHeight = std::min(nHeight + 32, pindexMostWork->GetHeight());
4004         vpindexToConnect.clear();
4005         vpindexToConnect.reserve(nTargetHeight - nHeight);
4006         CBlockIndex *pindexIter = pindexMostWork->GetAncestor(nTargetHeight);
4007         while (pindexIter && pindexIter->GetHeight() != nHeight) {
4008             vpindexToConnect.push_back(pindexIter);
4009             pindexIter = pindexIter->pprev;
4010         }
4011         nHeight = nTargetHeight;
4012
4013         // Connect new blocks.
4014         BOOST_REVERSE_FOREACH(CBlockIndex *pindexConnect, vpindexToConnect) {
4015             if (!ConnectTip(state, pindexConnect, pindexConnect == pindexMostWork ? pblock : NULL)) {
4016                 if (state.IsInvalid()) {
4017                     // The block violates a consensus rule.
4018                     if (!state.CorruptionPossible())
4019                         InvalidChainFound(vpindexToConnect.back());
4020                     state = CValidationState();
4021                     fInvalidFound = true;
4022                     fContinue = false;
4023                     break;
4024                 } else {
4025                     // A system error occurred (disk space, database error, ...).
4026                     return false;
4027                 }
4028             } else {
4029                 PruneBlockIndexCandidates();
4030                 if (!pindexOldTip || chainActive.Tip()->chainPower > pindexOldTip->chainPower) {
4031                     // We're in a better position than we were. Return temporarily to release the lock.
4032                     fContinue = false;
4033                     break;
4034                 }
4035             }
4036         }
4037     }
4038
4039     if (fBlocksDisconnected) {
4040         mempool.removeForReorg(pcoinsTip, chainActive.Tip()->GetHeight() + 1, STANDARD_LOCKTIME_VERIFY_FLAGS);
4041     }
4042     mempool.removeWithoutBranchId(
4043                                   CurrentEpochBranchId(chainActive.Tip()->GetHeight() + 1, Params().GetConsensus()));
4044     mempool.check(pcoinsTip);
4045
4046     // Callbacks/notifications for a new best chain.
4047     if (fInvalidFound)
4048         CheckForkWarningConditionsOnNewFork(vpindexToConnect.back());
4049     else
4050         CheckForkWarningConditions();
4051
4052     return true;
4053 }
4054
4055 /**
4056  * Make the best chain active, in multiple steps. The result is either failure
4057  * or an activated best chain. pblock is either NULL or a pointer to a block
4058  * that is already loaded (to avoid loading it again from disk).
4059  */
4060 bool ActivateBestChain(CValidationState &state, CBlock *pblock) {
4061     CBlockIndex *pindexNewTip = NULL;
4062     CBlockIndex *pindexMostWork = NULL;
4063     const CChainParams& chainParams = Params();
4064     do {
4065         boost::this_thread::interruption_point();
4066
4067         bool fInitialDownload;
4068         {
4069             LOCK(cs_main);
4070             pindexMostWork = FindMostWorkChain();
4071
4072             // Whether we have anything to do at all.
4073             if (pindexMostWork == NULL || pindexMostWork == chainActive.Tip())
4074                 return true;
4075
4076             if (!ActivateBestChainStep(state, pindexMostWork, pblock && pblock->GetHash() == pindexMostWork->GetBlockHash() ? pblock : NULL))
4077                 return false;
4078             pindexNewTip = chainActive.Tip();
4079             fInitialDownload = IsInitialBlockDownload();
4080         }
4081         // When we reach this point, we switched to a new tip (stored in pindexNewTip).
4082
4083         // Notifications/callbacks that can run without cs_main
4084         if (!fInitialDownload) {
4085             uint256 hashNewTip = pindexNewTip->GetBlockHash();
4086             // Relay inventory, but don't relay old inventory during initial block download.
4087             int nBlockEstimate = 0;
4088             if (fCheckpointsEnabled)
4089                 nBlockEstimate = Checkpoints::GetTotalBlocksEstimate(chainParams.Checkpoints());
4090             // Don't relay blocks if pruning -- could cause a peer to try to download, resulting
4091             // in a stalled download if the block file is pruned before the request.
4092             if (nLocalServices & NODE_NETWORK) {
4093                 LOCK(cs_vNodes);
4094                 BOOST_FOREACH(CNode* pnode, vNodes)
4095                 if (chainActive.Height() > (pnode->nStartingHeight != -1 ? pnode->nStartingHeight - 2000 : nBlockEstimate))
4096                     pnode->PushInventory(CInv(MSG_BLOCK, hashNewTip));
4097             }
4098             // Notify external listeners about the new tip.
4099             GetMainSignals().UpdatedBlockTip(pindexNewTip);
4100             uiInterface.NotifyBlockTip(hashNewTip);
4101         } //else fprintf(stderr,"initial download skips propagation\n");
4102     } while(pindexMostWork != chainActive.Tip());
4103     CheckBlockIndex();
4104
4105     // Write changes periodically to disk, after relay.
4106     if (!FlushStateToDisk(state, FLUSH_STATE_PERIODIC)) {
4107         return false;
4108     }
4109
4110     return true;
4111 }
4112
4113 bool InvalidateBlock(CValidationState& state, CBlockIndex *pindex) {
4114     AssertLockHeld(cs_main);
4115
4116     // Mark the block itself as invalid.
4117     pindex->nStatus |= BLOCK_FAILED_VALID;
4118     setDirtyBlockIndex.insert(pindex);
4119     setBlockIndexCandidates.erase(pindex);
4120
4121     while (chainActive.Contains(pindex)) {
4122         CBlockIndex *pindexWalk = chainActive.Tip();
4123         pindexWalk->nStatus |= BLOCK_FAILED_CHILD;
4124         setDirtyBlockIndex.insert(pindexWalk);
4125         setBlockIndexCandidates.erase(pindexWalk);
4126         // ActivateBestChain considers blocks already in chainActive
4127         // unconditionally valid already, so force disconnect away from it.
4128         if (!DisconnectTip(state)) {
4129             mempool.removeForReorg(pcoinsTip, chainActive.Tip()->GetHeight() + 1, STANDARD_LOCKTIME_VERIFY_FLAGS);
4130             mempool.removeWithoutBranchId(
4131                                           CurrentEpochBranchId(chainActive.Tip()->GetHeight() + 1, Params().GetConsensus()));
4132             return false;
4133         }
4134     }
4135     //LimitMempoolSize(mempool, GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000, GetArg("-mempoolexpiry", DEFAULT_MEMPOOL_EXPIRY) * 60 * 60);
4136
4137     // The resulting new best tip may not be in setBlockIndexCandidates anymore, so
4138     // add it again.
4139     BlockMap::iterator it = mapBlockIndex.begin();
4140     while (it != mapBlockIndex.end() && it->second != 0 ) {
4141         if (it->second->IsValid(BLOCK_VALID_TRANSACTIONS) && it->second->nChainTx && !setBlockIndexCandidates.value_comp()(it->second, chainActive.Tip())) {
4142             setBlockIndexCandidates.insert(it->second);
4143         }
4144         it++;
4145     }
4146
4147     InvalidChainFound(pindex);
4148     mempool.removeForReorg(pcoinsTip, chainActive.Tip()->GetHeight() + 1, STANDARD_LOCKTIME_VERIFY_FLAGS);
4149     mempool.removeWithoutBranchId(
4150                                   CurrentEpochBranchId(chainActive.Tip()->GetHeight() + 1, Params().GetConsensus()));
4151     return true;
4152 }
4153
4154 bool ReconsiderBlock(CValidationState& state, CBlockIndex *pindex) {
4155     AssertLockHeld(cs_main);
4156
4157     int nHeight = pindex->GetHeight();
4158
4159     // Remove the invalidity flag from this block and all its descendants.
4160     BlockMap::iterator it = mapBlockIndex.begin();
4161     while (it != mapBlockIndex.end()  && it->second != 0) {
4162         if (!it->second->IsValid() && it->second->GetAncestor(nHeight) == pindex) {
4163             it->second->nStatus &= ~BLOCK_FAILED_MASK;
4164             setDirtyBlockIndex.insert(it->second);
4165             if (it->second->IsValid(BLOCK_VALID_TRANSACTIONS) && it->second->nChainTx && setBlockIndexCandidates.value_comp()(chainActive.Tip(), it->second)) {
4166                 setBlockIndexCandidates.insert(it->second);
4167             }
4168             if (it->second == pindexBestInvalid) {
4169                 // Reset invalid block marker if it was pointing to one of those.
4170                 pindexBestInvalid = NULL;
4171             }
4172         }
4173         it++;
4174     }
4175
4176     // Remove the invalidity flag from all ancestors too.
4177     while (pindex != NULL) {
4178         if (pindex->nStatus & BLOCK_FAILED_MASK) {
4179             pindex->nStatus &= ~BLOCK_FAILED_MASK;
4180             setDirtyBlockIndex.insert(pindex);
4181         }
4182         pindex = pindex->pprev;
4183     }
4184     return true;
4185 }
4186
4187 CBlockIndex* AddToBlockIndex(const CBlockHeader& block)
4188 {
4189     // Check for duplicate
4190     uint256 hash = block.GetHash();
4191     BlockMap::iterator it = mapBlockIndex.find(hash);
4192     BlockMap::iterator miPrev = mapBlockIndex.find(block.hashPrevBlock);
4193     if (it != mapBlockIndex.end())
4194     {
4195         if ( it->second != 0 ) // vNodes.size() >= KOMODO_LIMITED_NETWORKSIZE, change behavior to allow komodo_ensure to work
4196         {
4197             // this is the strange case where somehow the hash is in the mapBlockIndex via as yet undetermined process, but the pindex for the hash is not there. Theoretically it is due to processing the block headers, but I have seen it get this case without having received it from the block headers or anywhere else... jl777
4198             //fprintf(stderr,"addtoblockindex already there %p\n",it->second);
4199             return it->second;
4200         }
4201         if ( miPrev != mapBlockIndex.end() && (*miPrev).second == 0 )
4202         {
4203             //fprintf(stderr,"edge case of both block and prevblock in the strange state\n");
4204             return(0); // return here to avoid the state of pindex->GetHeight() not set and pprev NULL
4205         }
4206     }
4207     // Construct new block index object
4208     CBlockIndex* pindexNew = new CBlockIndex(block);
4209     assert(pindexNew);
4210     // We assign the sequence id to blocks only when the full data is available,
4211     // to avoid miners withholding blocks but broadcasting headers, to get a
4212     // competitive advantage.
4213     pindexNew->nSequenceId = 0;
4214     BlockMap::iterator mi = mapBlockIndex.insert(make_pair(hash, pindexNew)).first;
4215     pindexNew->phashBlock = &((*mi).first);
4216     if (miPrev != mapBlockIndex.end())
4217     {
4218         if ( (pindexNew->pprev= (*miPrev).second) != 0 )
4219             pindexNew->SetHeight(pindexNew->pprev->GetHeight() + 1);
4220         else fprintf(stderr,"unexpected null pprev %s\n",hash.ToString().c_str());
4221         pindexNew->BuildSkip();
4222     }
4223     pindexNew->chainPower = (pindexNew->pprev ? CChainPower(pindexNew) + pindexNew->pprev->chainPower : CChainPower(pindexNew)) + GetBlockProof(*pindexNew);
4224     pindexNew->RaiseValidity(BLOCK_VALID_TREE);
4225     if (pindexBestHeader == NULL || pindexBestHeader->chainPower < pindexNew->chainPower)
4226         pindexBestHeader = pindexNew;
4227
4228     setDirtyBlockIndex.insert(pindexNew);
4229     //fprintf(stderr,"added to block index %s %p\n",hash.ToString().c_str(),pindexNew);
4230     mi->second = pindexNew;
4231     return pindexNew;
4232 }
4233
4234 /** Mark a block as having its data received and checked (up to BLOCK_VALID_TRANSACTIONS). */
4235 bool ReceivedBlockTransactions(const CBlock &block, CValidationState& state, CBlockIndex *pindexNew, const CDiskBlockPos& pos)
4236 {
4237     pindexNew->nTx = block.vtx.size();
4238     pindexNew->nChainTx = 0;
4239     CAmount sproutValue = 0;
4240     CAmount saplingValue = 0;
4241     for (auto tx : block.vtx) {
4242         // Negative valueBalance "takes" money from the transparent value pool
4243         // and adds it to the Sapling value pool. Positive valueBalance "gives"
4244         // money to the transparent value pool, removing from the Sapling value
4245         // pool. So we invert the sign here.
4246         saplingValue += -tx.valueBalance;
4247
4248         for (auto js : tx.vjoinsplit) {
4249             sproutValue += js.vpub_old;
4250             sproutValue -= js.vpub_new;
4251         }
4252     }
4253     pindexNew->nSproutValue = sproutValue;
4254     pindexNew->nChainSproutValue = boost::none;
4255     pindexNew->nSaplingValue = saplingValue;
4256     pindexNew->nChainSaplingValue = boost::none;
4257     pindexNew->nFile = pos.nFile;
4258     pindexNew->nDataPos = pos.nPos;
4259     pindexNew->nUndoPos = 0;
4260     pindexNew->nStatus |= BLOCK_HAVE_DATA;
4261     pindexNew->RaiseValidity(BLOCK_VALID_TRANSACTIONS);
4262     setDirtyBlockIndex.insert(pindexNew);
4263
4264     if (pindexNew->pprev == NULL || pindexNew->pprev->nChainTx) {
4265         // If pindexNew is the genesis block or all parents are BLOCK_VALID_TRANSACTIONS.
4266         deque<CBlockIndex*> queue;
4267         queue.push_back(pindexNew);
4268
4269         // Recursively process any descendant blocks that now may be eligible to be connected.
4270         while (!queue.empty()) {
4271             CBlockIndex *pindex = queue.front();
4272             queue.pop_front();
4273             pindex->nChainTx = (pindex->pprev ? pindex->pprev->nChainTx : 0) + pindex->nTx;
4274             if (pindex->pprev) {
4275                 if (pindex->pprev->nChainSproutValue && pindex->nSproutValue) {
4276                     pindex->nChainSproutValue = *pindex->pprev->nChainSproutValue + *pindex->nSproutValue;
4277                 } else {
4278                     pindex->nChainSproutValue = boost::none;
4279                 }
4280                 if (pindex->pprev->nChainSaplingValue) {
4281                     pindex->nChainSaplingValue = *pindex->pprev->nChainSaplingValue + pindex->nSaplingValue;
4282                 } else {
4283                     pindex->nChainSaplingValue = boost::none;
4284                 }
4285             } else {
4286                 pindex->nChainSproutValue = pindex->nSproutValue;
4287                 pindex->nChainSaplingValue = pindex->nSaplingValue;
4288             }
4289             {
4290                 LOCK(cs_nBlockSequenceId);
4291                 pindex->nSequenceId = nBlockSequenceId++;
4292             }
4293             if (chainActive.Tip() == NULL || !setBlockIndexCandidates.value_comp()(pindex, chainActive.Tip())) {
4294                 setBlockIndexCandidates.insert(pindex);
4295             }
4296             std::pair<std::multimap<CBlockIndex*, CBlockIndex*>::iterator, std::multimap<CBlockIndex*, CBlockIndex*>::iterator> range = mapBlocksUnlinked.equal_range(pindex);
4297             while (range.first != range.second) {
4298                 std::multimap<CBlockIndex*, CBlockIndex*>::iterator it = range.first;
4299                 queue.push_back(it->second);
4300                 range.first++;
4301                 mapBlocksUnlinked.erase(it);
4302             }
4303         }
4304     } else {
4305         if (pindexNew->pprev && pindexNew->pprev->IsValid(BLOCK_VALID_TREE)) {
4306             mapBlocksUnlinked.insert(std::make_pair(pindexNew->pprev, pindexNew));
4307         }
4308     }
4309
4310     return true;
4311 }
4312
4313 bool FindBlockPos(CValidationState &state, CDiskBlockPos &pos, unsigned int nAddSize, unsigned int nHeight, uint64_t nTime, bool fKnown = false)
4314 {
4315     LOCK(cs_LastBlockFile);
4316
4317     unsigned int nFile = fKnown ? pos.nFile : nLastBlockFile;
4318     if (vinfoBlockFile.size() <= nFile) {
4319         vinfoBlockFile.resize(nFile + 1);
4320     }
4321
4322     if (!fKnown) {
4323         while (vinfoBlockFile[nFile].nSize + nAddSize >= MAX_BLOCKFILE_SIZE) {
4324             nFile++;
4325             if (vinfoBlockFile.size() <= nFile) {
4326                 vinfoBlockFile.resize(nFile + 1);
4327             }
4328         }
4329         pos.nFile = nFile;
4330         pos.nPos = vinfoBlockFile[nFile].nSize;
4331     }
4332
4333     if (nFile != nLastBlockFile) {
4334         if (!fKnown) {
4335             LogPrintf("Leaving block file %i: %s\n", nFile, vinfoBlockFile[nFile].ToString());
4336         }
4337         FlushBlockFile(!fKnown);
4338         nLastBlockFile = nFile;
4339     }
4340
4341     vinfoBlockFile[nFile].AddBlock(nHeight, nTime);
4342     if (fKnown)
4343         vinfoBlockFile[nFile].nSize = std::max(pos.nPos + nAddSize, vinfoBlockFile[nFile].nSize);
4344     else
4345         vinfoBlockFile[nFile].nSize += nAddSize;
4346
4347     if (!fKnown) {
4348         unsigned int nOldChunks = (pos.nPos + BLOCKFILE_CHUNK_SIZE - 1) / BLOCKFILE_CHUNK_SIZE;
4349         unsigned int nNewChunks = (vinfoBlockFile[nFile].nSize + BLOCKFILE_CHUNK_SIZE - 1) / BLOCKFILE_CHUNK_SIZE;
4350         if (nNewChunks > nOldChunks) {
4351             if (fPruneMode)
4352                 fCheckForPruning = true;
4353             if (CheckDiskSpace(nNewChunks * BLOCKFILE_CHUNK_SIZE - pos.nPos)) {
4354                 FILE *file = OpenBlockFile(pos);
4355                 if (file) {
4356                     LogPrintf("Pre-allocating up to position 0x%x in blk%05u.dat\n", nNewChunks * BLOCKFILE_CHUNK_SIZE, pos.nFile);
4357                     AllocateFileRange(file, pos.nPos, nNewChunks * BLOCKFILE_CHUNK_SIZE - pos.nPos);
4358                     fclose(file);
4359                 }
4360             }
4361             else
4362                 return state.Error("out of disk space");
4363         }
4364     }
4365
4366     setDirtyFileInfo.insert(nFile);
4367     return true;
4368 }
4369
4370 bool FindUndoPos(CValidationState &state, int nFile, CDiskBlockPos &pos, unsigned int nAddSize)
4371 {
4372     pos.nFile = nFile;
4373
4374     LOCK(cs_LastBlockFile);
4375
4376     unsigned int nNewSize;
4377     pos.nPos = vinfoBlockFile[nFile].nUndoSize;
4378     nNewSize = vinfoBlockFile[nFile].nUndoSize += nAddSize;
4379     setDirtyFileInfo.insert(nFile);
4380
4381     unsigned int nOldChunks = (pos.nPos + UNDOFILE_CHUNK_SIZE - 1) / UNDOFILE_CHUNK_SIZE;
4382     unsigned int nNewChunks = (nNewSize + UNDOFILE_CHUNK_SIZE - 1) / UNDOFILE_CHUNK_SIZE;
4383     if (nNewChunks > nOldChunks) {
4384         if (fPruneMode)
4385             fCheckForPruning = true;
4386         if (CheckDiskSpace(nNewChunks * UNDOFILE_CHUNK_SIZE - pos.nPos)) {
4387             FILE *file = OpenUndoFile(pos);
4388             if (file) {
4389                 LogPrintf("Pre-allocating up to position 0x%x in rev%05u.dat\n", nNewChunks * UNDOFILE_CHUNK_SIZE, pos.nFile);
4390                 AllocateFileRange(file, pos.nPos, nNewChunks * UNDOFILE_CHUNK_SIZE - pos.nPos);
4391                 fclose(file);
4392             }
4393         }
4394         else
4395             return state.Error("out of disk space");
4396     }
4397
4398     return true;
4399 }
4400
4401 bool CheckBlockHeader(int32_t *futureblockp,int32_t height,CBlockIndex *pindex, const CBlockHeader& blockhdr, CValidationState& state, bool fCheckPOW)
4402 {
4403     // Check timestamp
4404     if ( 0 )
4405     {
4406         uint256 hash; int32_t i;
4407         hash = blockhdr.GetHash();
4408         for (i=31; i>=0; i--)
4409             fprintf(stderr,"%02x",((uint8_t *)&hash)[i]);
4410         fprintf(stderr," <- CheckBlockHeader\n");
4411         if ( chainActive.LastTip() != 0 )
4412         {
4413             hash = chainActive.LastTip()->GetBlockHash();
4414             for (i=31; i>=0; i--)
4415                 fprintf(stderr,"%02x",((uint8_t *)&hash)[i]);
4416             fprintf(stderr," <- chainTip\n");
4417         }
4418     }
4419     *futureblockp = 0;
4420     if (blockhdr.GetBlockTime() > GetAdjustedTime() + 60)
4421     {
4422         CBlockIndex *tipindex;
4423         //fprintf(stderr,"ht.%d future block %u vs time.%u + 60\n",height,(uint32_t)blockhdr.GetBlockTime(),(uint32_t)GetAdjustedTime());
4424         if ( (tipindex= chainActive.Tip()) != 0 && tipindex->GetBlockHash() == blockhdr.hashPrevBlock && blockhdr.GetBlockTime() < GetAdjustedTime() + 60 + 5 )
4425         {
4426             //fprintf(stderr,"it is the next block, let's wait for %d seconds\n",GetAdjustedTime() + 60 - blockhdr.GetBlockTime());
4427             while ( blockhdr.GetBlockTime() > GetAdjustedTime() + 60 )
4428                 sleep(1);
4429             //fprintf(stderr,"now its valid\n");
4430         }
4431         else
4432         {
4433             if (blockhdr.GetBlockTime() < GetAdjustedTime() + 600)
4434                 *futureblockp = 1;
4435             //LogPrintf("CheckBlockHeader block from future %d error",blockhdr.GetBlockTime() - GetAdjustedTime());
4436             return false; //state.Invalid(error("CheckBlockHeader(): block timestamp too far in the future"),REJECT_INVALID, "time-too-new");
4437         }
4438     }
4439     // Check block version
4440     if (height > 0 && blockhdr.nVersion < MIN_BLOCK_VERSION)
4441         return state.DoS(100, error("CheckBlockHeader(): block version too low"),REJECT_INVALID, "version-too-low");
4442
4443     // Check Equihash solution is valid
4444     if ( fCheckPOW )
4445     {
4446         if ( !CheckEquihashSolution(&blockhdr, Params()) )
4447             return state.DoS(100, error("CheckBlockHeader(): Equihash solution invalid"),REJECT_INVALID, "invalid-solution");
4448     }
4449     // Check proof of work matches claimed amount
4450     /*komodo_index2pubkey33(pubkey33,pindex,height);
4451      if ( fCheckPOW && !CheckProofOfWork(height,pubkey33,blockhdr.GetHash(), blockhdr.nBits, Params().GetConsensus(),blockhdr.nTime) )
4452      return state.DoS(50, error("CheckBlockHeader(): proof of work failed"),REJECT_INVALID, "high-hash");*/
4453     return true;
4454 }
4455
4456 int32_t komodo_check_deposit(int32_t height,const CBlock& block,uint32_t prevtime);
4457 int32_t komodo_checkPOW(int32_t slowflag,CBlock *pblock,int32_t height);
4458
4459 bool CheckBlock(int32_t *futureblockp,int32_t height,CBlockIndex *pindex,const CBlock& block, CValidationState& state,
4460                 libzcash::ProofVerifier& verifier,
4461                 bool fCheckPOW, bool fCheckMerkleRoot)
4462 {
4463     uint8_t pubkey33[33]; uint256 hash;
4464     // These are checks that are independent of context.
4465     hash = block.GetHash();
4466     // Check that the header is valid (particularly PoW).  This is mostly redundant with the call in AcceptBlockHeader.
4467     if (!CheckBlockHeader(futureblockp,height,pindex,block,state,fCheckPOW))
4468     {
4469         if ( *futureblockp == 0 )
4470         {
4471             LogPrintf("CheckBlock header error");
4472             return false;
4473         }
4474     }
4475     if ( fCheckPOW )
4476     {
4477         //if ( !CheckEquihashSolution(&block, Params()) )
4478         //    return state.DoS(100, error("CheckBlock: Equihash solution invalid"),REJECT_INVALID, "invalid-solution");
4479         komodo_block2pubkey33(pubkey33,(CBlock *)&block);
4480         if ( !CheckProofOfWork(block,pubkey33,height,Params().GetConsensus()) )
4481         {
4482             int32_t z; for (z=31; z>=0; z--)
4483                 fprintf(stderr,"%02x",((uint8_t *)&hash)[z]);
4484             fprintf(stderr," failed hash ht.%d\n",height);
4485             return state.DoS(50, error("CheckBlock: proof of work failed"),REJECT_INVALID, "high-hash");
4486         }
4487         if ( komodo_checkPOW(1,(CBlock *)&block,height) < 0 ) // checks Equihash
4488             return state.DoS(100, error("CheckBlock: failed slow_checkPOW"),REJECT_INVALID, "failed-slow_checkPOW");
4489     }
4490     // Check the merkle root.
4491     if (fCheckMerkleRoot) {
4492         bool mutated;
4493         uint256 hashMerkleRoot2 = block.BuildMerkleTree(&mutated);
4494         if (block.hashMerkleRoot != hashMerkleRoot2)
4495             return state.DoS(100, error("CheckBlock: hashMerkleRoot mismatch"),
4496                              REJECT_INVALID, "bad-txnmrklroot", true);
4497
4498         // Check for merkle tree malleability (CVE-2012-2459): repeating sequences
4499         // of transactions in a block without affecting the merkle root of a block,
4500         // while still invalidating it.
4501         if (mutated)
4502             return state.DoS(100, error("CheckBlock: duplicate transaction"),
4503                              REJECT_INVALID, "bad-txns-duplicate", true);
4504     }
4505
4506     // All potential-corruption validation must be done before we do any
4507     // transaction validation, as otherwise we may mark the header as invalid
4508     // because we receive the wrong transactions for it.
4509
4510     // Size limits
4511     if (block.vtx.empty() || block.vtx.size() > MAX_BLOCK_SIZE || ::GetSerializeSize(block, SER_NETWORK, PROTOCOL_VERSION) > MAX_BLOCK_SIZE)
4512         return state.DoS(100, error("CheckBlock: size limits failed"),
4513                          REJECT_INVALID, "bad-blk-length");
4514
4515     // First transaction must be coinbase, the rest must not be
4516     if (block.vtx.empty() || !block.vtx[0].IsCoinBase())
4517         return state.DoS(100, error("CheckBlock: first tx is not coinbase"),
4518                          REJECT_INVALID, "bad-cb-missing");
4519
4520     for (unsigned int i = 1; i < block.vtx.size(); i++)
4521         if (block.vtx[i].IsCoinBase())
4522             return state.DoS(100, error("CheckBlock: more than one coinbase"),
4523                              REJECT_INVALID, "bad-cb-multiple");
4524
4525     // Check transactions
4526     if ( ASSETCHAINS_CC != 0 ) // CC contracts might refer to transactions in the current block, from a CC spend within the same block and out of order
4527     {
4528         CValidationState stateDummy; int32_t i,j,rejects=0,lastrejects=0;
4529         //fprintf(stderr,"put block's tx into mempool\n");
4530         while ( 1 )
4531         {
4532             for (i=0; i<block.vtx.size(); i++)
4533             {
4534                 CTransaction Tx; const CTransaction &tx = (CTransaction)block.vtx[i];
4535                 if (tx.IsCoinBase() || ((i == (block.vtx.size() - 1)) && ((ASSETCHAINS_LWMAPOS && block.IsVerusPOSBlock()) || (ASSETCHAINS_STAKED && komodo_isPoS((CBlock *)&block) != 0))))
4536                     continue;
4537                 Tx = tx;
4538                 if ( myAddtomempool(Tx) == false ) // happens with out of order tx in block on resync
4539                     rejects++;
4540             }
4541             if ( rejects == 0 || rejects == lastrejects )
4542             {
4543                 if ( 0 && lastrejects != 0 )
4544                     fprintf(stderr,"lastrejects.%d -> all tx in mempool\n",lastrejects);
4545                 break;
4546             }
4547             //fprintf(stderr,"addtomempool ht.%d for CC checking: n.%d rejects.%d last.%d\n",height,(int32_t)block.vtx.size(),rejects,lastrejects);
4548             lastrejects = rejects;
4549             rejects = 0;
4550         }
4551         //fprintf(stderr,"done putting block's tx into mempool\n");
4552     }
4553
4554     for (uint32_t i = 0; i < block.vtx.size(); i++)
4555     {
4556         const CTransaction& tx = block.vtx[i];
4557         if ( komodo_validate_interest(tx,height == 0 ? komodo_block2height((CBlock *)&block) : height,block.nTime,0) < 0 )
4558             return error("CheckBlock: komodo_validate_interest failed");
4559         if (!CheckTransaction(tx, state, verifier))
4560             return error("CheckBlock: CheckTransaction failed");
4561     }
4562     unsigned int nSigOps = 0;
4563     BOOST_FOREACH(const CTransaction& tx, block.vtx)
4564     {
4565         nSigOps += GetLegacySigOpCount(tx);
4566     }
4567     if (nSigOps > MAX_BLOCK_SIGOPS)
4568         return state.DoS(100, error("CheckBlock: out-of-bounds SigOpCount"),
4569                          REJECT_INVALID, "bad-blk-sigops", true);
4570     if ( komodo_check_deposit(height,block,(pindex==0||pindex->pprev==0)?0:pindex->pprev->nTime) < 0 )
4571     {
4572         //static uint32_t counter;
4573         //if ( counter++ < 100 && ASSETCHAINS_STAKED == 0 )
4574         //    fprintf(stderr,"check deposit rejection\n");
4575         LogPrintf("CheckBlockHeader komodo_check_deposit error");
4576         return(false);
4577     }
4578     return true;
4579 }
4580
4581 bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationState& state, CBlockIndex * const pindexPrev)
4582 {
4583     const CChainParams& chainParams = Params();
4584     const Consensus::Params& consensusParams = chainParams.GetConsensus();
4585     uint256 hash = block.GetHash();
4586     if (hash == consensusParams.hashGenesisBlock)
4587         return true;
4588
4589     assert(pindexPrev);
4590
4591     int nHeight = pindexPrev->GetHeight()+1;
4592
4593     // Check proof of work
4594     if ( (ASSETCHAINS_SYMBOL[0] != 0 || nHeight < 235300 || nHeight > 236000) && block.nBits != GetNextWorkRequired(pindexPrev, &block, consensusParams))
4595     {
4596         cout << block.nBits << " block.nBits vs. calc " << GetNextWorkRequired(pindexPrev, &block, consensusParams) <<
4597                                " for block #" << nHeight << endl;
4598         return state.DoS(100, error("%s: incorrect proof of work", __func__),
4599                         REJECT_INVALID, "bad-diffbits");
4600     }
4601
4602     // Check timestamp against prev
4603     if (block.GetBlockTime() <= pindexPrev->GetMedianTimePast())
4604     {
4605         return state.Invalid(error("%s: block's timestamp is too early", __func__),
4606                         REJECT_INVALID, "time-too-old");
4607     }
4608
4609     // Check that timestamp is not too far in the future
4610     if (block.GetBlockTime() > GetAdjustedTime() + consensusParams.nMaxFutureBlockTime)
4611     {
4612         return state.Invalid(error("%s: block timestamp too far in the future", __func__),
4613                         REJECT_INVALID, "time-too-new");
4614     }
4615
4616     if (fCheckpointsEnabled)
4617     {
4618         // Check that the block chain matches the known block chain up to a checkpoint
4619         if (!Checkpoints::CheckBlock(chainParams.Checkpoints(), nHeight, hash))
4620         {
4621             /*CBlockIndex *heightblock = chainActive[nHeight];
4622             if ( heightblock != 0 && heightblock->GetBlockHash() == hash )
4623             {
4624                 //fprintf(stderr,"got a pre notarization block that matches height.%d\n",(int32_t)nHeight);
4625                 return true;
4626             }*/
4627             return state.DoS(100, error("%s: rejected by checkpoint lock-in at %d", __func__, nHeight),REJECT_CHECKPOINT, "checkpoint mismatch");
4628         }
4629         // Don't accept any forks from the main chain prior to last checkpoint
4630         CBlockIndex* pcheckpoint = Checkpoints::GetLastCheckpoint(chainParams.Checkpoints());
4631         int32_t notarized_height;
4632         if ( nHeight == 1 && chainActive.LastTip() != 0 && chainActive.LastTip()->GetHeight() > 1 )
4633         {
4634             CBlockIndex *heightblock = chainActive[nHeight];
4635             if ( heightblock != 0 && heightblock->GetBlockHash() == hash )
4636                 return true;
4637             return state.DoS(1, error("%s: trying to change height 1 forbidden", __func__));
4638         }
4639         if ( nHeight != 0 )
4640         {
4641             if ( pcheckpoint != 0 && nHeight < pcheckpoint->GetHeight() )
4642                 return state.DoS(1, error("%s: forked chain older than last checkpoint (height %d) vs %d", __func__, nHeight,pcheckpoint->GetHeight()));
4643             if ( komodo_checkpoint(&notarized_height,nHeight,hash) < 0 )
4644             {
4645                 CBlockIndex *heightblock = chainActive[nHeight];
4646                 if ( heightblock != 0 && heightblock->GetBlockHash() == hash )
4647                 {
4648                     //fprintf(stderr,"got a pre notarization block that matches height.%d\n",(int32_t)nHeight);
4649                     return true;
4650                 } else return state.DoS(1, error("%s: forked chain %d older than last notarized (height %d) vs %d", __func__,nHeight, notarized_height));
4651             }
4652         }
4653     }
4654     // Reject block.nVersion < 4 blocks
4655     if (block.nVersion < 4)
4656         return state.Invalid(error("%s : rejected nVersion<4 block", __func__),
4657                              REJECT_OBSOLETE, "bad-version");
4658
4659     return true;
4660 }
4661
4662 bool ContextualCheckBlock(const CBlock& block, CValidationState& state, CBlockIndex * const pindexPrev)
4663 {
4664     const int nHeight = pindexPrev == NULL ? 0 : pindexPrev->GetHeight() + 1;
4665     const Consensus::Params& consensusParams = Params().GetConsensus();
4666     bool sapling = NetworkUpgradeActive(nHeight, consensusParams, Consensus::UPGRADE_SAPLING);
4667
4668     // Check that all transactions are finalized
4669     for (uint32_t i = 0; i < block.vtx.size(); i++) {
4670         const CTransaction& tx = block.vtx[i];
4671
4672         // Check transaction contextually against consensus rules at block height
4673         if (!ContextualCheckTransaction(tx, state, nHeight, 100)) {
4674             return false; // Failure reason has been set in validation state object
4675         }
4676
4677         // if this is a stake transaction with a stake opreturn, reject it if not staking a block. don't check coinbase or actual stake tx
4678         CStakeParams p;
4679         if (sapling && i > 0 && i < (block.vtx.size() - 1) && ValidateStakeTransaction(tx, p, false))
4680         {
4681             return state.DoS(10, error("%s: attempt to submit block with staking transaction that is not staking", __func__), REJECT_INVALID, "bad-txns-staking");
4682         }
4683
4684         int nLockTimeFlags = 0;
4685         int64_t nLockTimeCutoff = (nLockTimeFlags & LOCKTIME_MEDIAN_TIME_PAST)
4686         ? pindexPrev->GetMedianTimePast()
4687         : block.GetBlockTime();
4688         if (!IsFinalTx(tx, nHeight, nLockTimeCutoff)) {
4689             return state.DoS(10, error("%s: contains a non-final transaction", __func__), REJECT_INVALID, "bad-txns-nonfinal");
4690         }
4691     }
4692
4693     // Enforce BIP 34 rule that the coinbase starts with serialized block height.
4694     // In Zcash this has been enforced since launch, except that the genesis
4695     // block didn't include the height in the coinbase (see Zcash protocol spec
4696     // section '6.8 Bitcoin Improvement Proposals').
4697     if (nHeight > 0)
4698     {
4699         CScript expect = CScript() << nHeight;
4700         if (block.vtx[0].vin[0].scriptSig.size() < expect.size() ||
4701             !std::equal(expect.begin(), expect.end(), block.vtx[0].vin[0].scriptSig.begin())) {
4702             return state.DoS(100, error("%s: block height mismatch in coinbase", __func__), REJECT_INVALID, "bad-cb-height");
4703         }
4704     }
4705     return true;
4706 }
4707
4708 bool AcceptBlockHeader(int32_t *futureblockp,const CBlockHeader& block, CValidationState& state, CBlockIndex** ppindex)
4709 {
4710     static uint256 zero;
4711     const CChainParams& chainparams = Params();
4712     AssertLockHeld(cs_main);
4713
4714     // Check for duplicate
4715     uint256 hash = block.GetHash();
4716     BlockMap::iterator miSelf = mapBlockIndex.find(hash);
4717     CBlockIndex *pindex = NULL;
4718     if (miSelf != mapBlockIndex.end())
4719     {
4720         // Block header is already known.
4721         if ( (pindex= miSelf->second) == 0 )
4722             miSelf->second = pindex = AddToBlockIndex(block);
4723         if (ppindex)
4724             *ppindex = pindex;
4725         if ( pindex != 0 && pindex->nStatus & BLOCK_FAILED_MASK )
4726             return state.Invalid(error("%s: block is marked invalid", __func__), 0, "duplicate");
4727         /*if ( pindex != 0 && hash == komodo_requestedhash )
4728         {
4729             fprintf(stderr,"AddToBlockIndex A komodo_requestedhash %s\n",komodo_requestedhash.ToString().c_str());
4730             memset(&komodo_requestedhash,0,sizeof(komodo_requestedhash));
4731             komodo_requestedcount = 0;
4732         }*/
4733
4734         //if ( pindex == 0 )
4735         //    fprintf(stderr,"accepthdr %s already known but no pindex\n",hash.ToString().c_str());
4736         return true;
4737     }
4738     if (!CheckBlockHeader(futureblockp,*ppindex!=0?(*ppindex)->GetHeight():0,*ppindex, block, state,0))
4739     {
4740         if ( *futureblockp == 0 )
4741         {
4742             LogPrintf("AcceptBlockHeader CheckBlockHeader error\n");
4743             return false;
4744         }
4745     }
4746     // Get prev block index
4747     CBlockIndex* pindexPrev = NULL;
4748     if (hash != chainparams.GetConsensus().hashGenesisBlock)
4749     {
4750         BlockMap::iterator mi = mapBlockIndex.find(block.hashPrevBlock);
4751         if (mi == mapBlockIndex.end())
4752         {
4753             LogPrintf("AcceptBlockHeader hashPrevBlock %s not found\n",block.hashPrevBlock.ToString().c_str());
4754             return(false);
4755             //return state.DoS(10, error("%s: prev block not found", __func__), 0, "bad-prevblk");
4756         }
4757         pindexPrev = (*mi).second;
4758         if (pindexPrev == 0 )
4759         {
4760             LogPrintf("AcceptBlockHeader hashPrevBlock %s no pindexPrev\n",block.hashPrevBlock.ToString().c_str());
4761             return(false);
4762         }
4763         if ( (pindexPrev->nStatus & BLOCK_FAILED_MASK) )
4764             return state.DoS(100, error("%s: prev block invalid", __func__), REJECT_INVALID, "bad-prevblk");
4765     }
4766     if (!ContextualCheckBlockHeader(block, state, pindexPrev))
4767     {
4768         //fprintf(stderr,"AcceptBlockHeader ContextualCheckBlockHeader failed\n");
4769         LogPrintf("AcceptBlockHeader ContextualCheckBlockHeader failed\n");
4770         return false;
4771     }
4772     if (pindex == NULL)
4773     {
4774         if ( (pindex= AddToBlockIndex(block)) != 0 )
4775         {
4776             miSelf = mapBlockIndex.find(hash);
4777             if (miSelf != mapBlockIndex.end())
4778                 miSelf->second = pindex;
4779             //fprintf(stderr,"AcceptBlockHeader couldnt add to block index\n");
4780         }
4781     }
4782     if (ppindex)
4783         *ppindex = pindex;
4784     /*if ( pindex != 0 && hash == komodo_requestedhash )
4785     {
4786         fprintf(stderr,"AddToBlockIndex komodo_requestedhash %s\n",komodo_requestedhash.ToString().c_str());
4787         memset(&komodo_requestedhash,0,sizeof(komodo_requestedhash));
4788         komodo_requestedcount = 0;
4789     }*/
4790     return true;
4791 }
4792
4793 bool AcceptBlock(int32_t *futureblockp,CBlock& block, CValidationState& state, CBlockIndex** ppindex, bool fRequested, CDiskBlockPos* dbp)
4794 {
4795     const CChainParams& chainparams = Params();
4796     AssertLockHeld(cs_main);
4797
4798     CBlockIndex *&pindex = *ppindex;
4799     if (!AcceptBlockHeader(futureblockp, block, state, &pindex))
4800     {
4801         if ( *futureblockp == 0 )
4802         {
4803             LogPrintf("AcceptBlock AcceptBlockHeader error\n");
4804             return false;
4805         }
4806     }
4807     if ( pindex == 0 )
4808     {
4809         LogPrintf("AcceptBlock null pindex\n");
4810         *futureblockp = true;
4811         return false;
4812     }
4813     //fprintf(stderr,"acceptblockheader passed\n");
4814     // Try to process all requested blocks that we don't have, but only
4815     // process an unrequested block if it's new and has enough work to
4816     // advance our tip, and isn't too many blocks ahead.
4817     bool fAlreadyHave = pindex->nStatus & BLOCK_HAVE_DATA;
4818     bool fHasMoreWork = (chainActive.Tip() ? pindex->chainPower > chainActive.Tip()->chainPower : true);
4819     // Blocks that are too out-of-order needlessly limit the effectiveness of
4820     // pruning, because pruning will not delete block files that contain any
4821     // blocks which are too close in height to the tip.  Apply this test
4822     // regardless of whether pruning is enabled; it should generally be safe to
4823     // not process unrequested blocks.
4824     bool fTooFarAhead = (pindex->GetHeight() > int(chainActive.Height() + BLOCK_DOWNLOAD_WINDOW)); //MIN_BLOCKS_TO_KEEP));
4825
4826     // TODO: deal better with return value and error conditions for duplicate
4827     // and unrequested blocks.
4828     //fprintf(stderr,"Accept %s flags already.%d requested.%d morework.%d farahead.%d\n",pindex->GetBlockHash().ToString().c_str(),fAlreadyHave,fRequested,fHasMoreWork,fTooFarAhead);
4829     if (fAlreadyHave) return true;
4830     if (!fRequested) {  // If we didn't ask for it:
4831         if (pindex->nTx != 0) return true;  // This is a previously-processed block that was pruned
4832         if (!fHasMoreWork) return true;     // Don't process less-work chains
4833         if (fTooFarAhead) return true;      // Block height is too high
4834     }
4835
4836     // See method docstring for why this is always disabled
4837     auto verifier = libzcash::ProofVerifier::Disabled();
4838     if ((!CheckBlock(futureblockp,pindex->GetHeight(),pindex,block, state, verifier,0)) || !ContextualCheckBlock(block, state, pindex->pprev))
4839     {
4840         if ( *futureblockp == 0 )
4841         {
4842             if (state.IsInvalid() && !state.CorruptionPossible()) {
4843                 pindex->nStatus |= BLOCK_FAILED_VALID;
4844                 setDirtyBlockIndex.insert(pindex);
4845             }
4846             LogPrintf("AcceptBlock CheckBlock or ContextualCheckBlock error\n");
4847             return false;
4848         }
4849     }
4850
4851     int nHeight = pindex->GetHeight();
4852     // Write block to history file
4853     try {
4854         unsigned int nBlockSize = ::GetSerializeSize(block, SER_DISK, CLIENT_VERSION);
4855         CDiskBlockPos blockPos;
4856         if (dbp != NULL)
4857             blockPos = *dbp;
4858         if (!FindBlockPos(state, blockPos, nBlockSize+8, nHeight, block.GetBlockTime(), dbp != NULL))
4859             return error("AcceptBlock(): FindBlockPos failed");
4860         if (dbp == NULL)
4861             if (!WriteBlockToDisk(block, blockPos, chainparams.MessageStart()))
4862                 AbortNode(state, "Failed to write block");
4863         if (!ReceivedBlockTransactions(block, state, pindex, blockPos))
4864             return error("AcceptBlock(): ReceivedBlockTransactions failed");
4865     } catch (const std::runtime_error& e) {
4866         return AbortNode(state, std::string("System error: ") + e.what());
4867     }
4868
4869     if (fCheckForPruning)
4870         FlushStateToDisk(state, FLUSH_STATE_NONE); // we just allocated more disk space for block files
4871     if ( *futureblockp == 0 )
4872         return true;
4873     LogPrintf("AcceptBlock block from future error\n");
4874     return false;
4875 }
4876
4877 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart, unsigned nRequired, const Consensus::Params& consensusParams)
4878 {
4879     unsigned int nFound = 0;
4880     for (int i = 0; i < consensusParams.nMajorityWindow && nFound < nRequired && pstart != NULL; i++)
4881     {
4882         if (pstart->nVersion >= minVersion)
4883             ++nFound;
4884         pstart = pstart->pprev;
4885     }
4886     return (nFound >= nRequired);
4887 }
4888
4889 void komodo_currentheight_set(int32_t height);
4890
4891 CBlockIndex *komodo_ensure(CBlock *pblock,uint256 hash)
4892 {
4893     CBlockIndex *pindex = 0;
4894     BlockMap::iterator miSelf = mapBlockIndex.find(hash);
4895     if ( miSelf != mapBlockIndex.end() )
4896     {
4897         if ( (pindex= miSelf->second) == 0 ) // create pindex so first Accept block doesnt fail
4898         {
4899             miSelf->second = AddToBlockIndex(*pblock);
4900             //fprintf(stderr,"Block header %s is already known, but without pindex -> ensured %p\n",hash.ToString().c_str(),miSelf->second);
4901         }
4902         /*if ( hash != Params().GetConsensus().hashGenesisBlock )
4903         {
4904             miSelf = mapBlockIndex.find(pblock->hashPrevBlock);
4905             if ( miSelf != mapBlockIndex.end() )
4906             {
4907                 if ( miSelf->second == 0 )
4908                 {
4909                     miSelf->second = InsertBlockIndex(pblock->hashPrevBlock);
4910                     fprintf(stderr,"autocreate previndex %s\n",pblock->hashPrevBlock.ToString().c_str());
4911                 }
4912             }
4913         }*/
4914     }
4915     return(pindex);
4916 }
4917
4918 CBlockIndex *oldkomodo_ensure(CBlock *pblock,uint256 hash)
4919 {
4920     CBlockIndex *pindex=0,*previndex=0;
4921     if ( (pindex= mapBlockIndex[hash]) == 0 )
4922     {
4923         pindex = new CBlockIndex();
4924         if (!pindex)
4925             throw runtime_error("komodo_ensure: new CBlockIndex failed");
4926         BlockMap::iterator mi = mapBlockIndex.insert(make_pair(hash, pindex)).first;
4927         pindex->phashBlock = &((*mi).first);
4928     }
4929     BlockMap::iterator miSelf = mapBlockIndex.find(hash);
4930     if ( miSelf == mapBlockIndex.end() )
4931     {
4932         LogPrintf("komodo_ensure unexpected missing hash %s\n",hash.ToString().c_str());
4933         return(0);
4934     }
4935     if ( miSelf->second == 0 ) // create pindex so first Accept block doesnt fail
4936     {
4937         if ( pindex == 0 )
4938         {
4939             pindex = AddToBlockIndex(*pblock);
4940             fprintf(stderr,"ensure call addtoblockindex, got %p\n",pindex);
4941         }
4942         if ( pindex != 0 )
4943         {
4944             miSelf->second = pindex;
4945             LogPrintf("Block header %s is already known, but without pindex -> ensured %p\n",hash.ToString().c_str(),miSelf->second);
4946         } else LogPrintf("komodo_ensure unexpected null pindex\n");
4947     }
4948     /*if ( hash != Params().GetConsensus().hashGenesisBlock )
4949         {
4950             miSelf = mapBlockIndex.find(pblock->hashPrevBlock);
4951             if ( miSelf == mapBlockIndex.end() )
4952                 previndex = InsertBlockIndex(pblock->hashPrevBlock);
4953             if ( (miSelf= mapBlockIndex.find(pblock->hashPrevBlock)) != mapBlockIndex.end() )
4954             {
4955                 if ( miSelf->second == 0 ) // create pindex so first Accept block doesnt fail
4956                 {
4957                     if ( previndex == 0 )
4958                         previndex = InsertBlockIndex(pblock->hashPrevBlock);
4959                     if ( previndex != 0 )
4960                     {
4961                         miSelf->second = previndex;
4962                         LogPrintf("autocreate previndex %s\n",pblock->hashPrevBlock.ToString().c_str());
4963                     } else LogPrintf("komodo_ensure unexpected null previndex\n");
4964                 }
4965             } else LogPrintf("komodo_ensure unexpected null miprev\n");
4966         }
4967      }*/
4968     return(pindex);
4969 }
4970
4971 bool ProcessNewBlock(bool from_miner,int32_t height,CValidationState &state, CNode* pfrom, CBlock* pblock, bool fForceProcessing, CDiskBlockPos *dbp)
4972 {
4973     // Preliminary checks
4974     bool checked; uint256 hash; int32_t futureblock=0;
4975     auto verifier = libzcash::ProofVerifier::Disabled();
4976     hash = pblock->GetHash();
4977     //fprintf(stderr,"ProcessBlock %d\n",(int32_t)chainActive.LastTip()->GetHeight());
4978     {
4979         LOCK(cs_main);
4980         if ( chainActive.LastTip() != 0 )
4981             komodo_currentheight_set(chainActive.LastTip()->GetHeight());
4982         checked = CheckBlock(&futureblock,height!=0?height:komodo_block2height(pblock),0,*pblock, state, verifier,0);
4983         bool fRequested = MarkBlockAsReceived(hash);
4984         fRequested |= fForceProcessing;
4985         if ( checked != 0 && komodo_checkPOW(0,pblock,height) < 0 ) //from_miner && ASSETCHAINS_STAKED == 0
4986         {
4987             checked = 0;
4988             //fprintf(stderr,"passed checkblock but failed checkPOW.%d\n",from_miner && ASSETCHAINS_STAKED == 0);
4989         }
4990         if (!checked && futureblock == 0)
4991         {
4992             if ( pfrom != 0 )
4993             {
4994                 Misbehaving(pfrom->GetId(), 1);
4995             }
4996             return error("%s: CheckBlock FAILED", __func__);
4997         }
4998         // Store to disk
4999         CBlockIndex *pindex = NULL;
5000
5001         bool ret = AcceptBlock(&futureblock,*pblock, state, &pindex, fRequested, dbp);
5002         if (pindex && pfrom) {
5003             mapBlockSource[pindex->GetBlockHash()] = pfrom->GetId();
5004         }
5005         CheckBlockIndex();
5006         if (!ret && futureblock == 0)
5007             return error("%s: AcceptBlock FAILED", __func__);
5008         //else fprintf(stderr,"added block %s %p\n",pindex->GetBlockHash().ToString().c_str(),pindex->pprev);
5009     }
5010
5011     if (futureblock == 0 && !ActivateBestChain(state, pblock))
5012         return error("%s: ActivateBestChain failed", __func__);
5013     //fprintf(stderr,"finished ProcessBlock %d\n",(int32_t)chainActive.LastTip()->GetHeight());
5014
5015     // when we succeed here, we prune all cheat candidates in the cheat list to 250 blocks ago, as they should be used or not
5016     // useful by then
5017     if ((height - 250) > 1)
5018         cheatList.Prune(height - 200);
5019
5020     return true;
5021 }
5022
5023 bool TestBlockValidity(CValidationState &state, const CBlock& block, CBlockIndex * const pindexPrev, bool fCheckPOW, bool fCheckMerkleRoot)
5024 {
5025     AssertLockHeld(cs_main);
5026     assert(pindexPrev == chainActive.Tip());
5027
5028     CCoinsViewCache viewNew(pcoinsTip);
5029     CBlockIndex indexDummy(block);
5030     indexDummy.pprev = pindexPrev;
5031     indexDummy.SetHeight(pindexPrev->GetHeight() + 1);
5032     // JoinSplit proofs are verified in ConnectBlock
5033     auto verifier = libzcash::ProofVerifier::Disabled();
5034     // NOTE: CheckBlockHeader is called by CheckBlock
5035     if (!ContextualCheckBlockHeader(block, state, pindexPrev))
5036     {
5037         //fprintf(stderr,"TestBlockValidity failure A checkPOW.%d\n",fCheckPOW);
5038         return false;
5039     }
5040     int32_t futureblock;
5041     if (!CheckBlock(&futureblock,indexDummy.GetHeight(),0,block, state, verifier, fCheckPOW, fCheckMerkleRoot))
5042     {
5043         //fprintf(stderr,"TestBlockValidity failure B checkPOW.%d\n",fCheckPOW);
5044         return false;
5045     }
5046     if (!ContextualCheckBlock(block, state, pindexPrev))
5047     {
5048         //fprintf(stderr,"TestBlockValidity failure C checkPOW.%d\n",fCheckPOW);
5049         return false;
5050     }
5051     if (!ConnectBlock(block, state, &indexDummy, viewNew, true,fCheckPOW))
5052     {
5053         //fprintf(stderr,"TestBlockValidity failure D checkPOW.%d\n",fCheckPOW);
5054         return false;
5055     }
5056     assert(state.IsValid());
5057     if ( futureblock != 0 )
5058         return(false);
5059     return true;
5060 }
5061
5062 /**
5063  * BLOCK PRUNING CODE
5064  */
5065
5066 /* Calculate the amount of disk space the block & undo files currently use */
5067 uint64_t CalculateCurrentUsage()
5068 {
5069     uint64_t retval = 0;
5070     BOOST_FOREACH(const CBlockFileInfo &file, vinfoBlockFile) {
5071         retval += file.nSize + file.nUndoSize;
5072     }
5073     return retval;
5074 }
5075
5076 /* Prune a block file (modify associated database entries)*/
5077 void PruneOneBlockFile(const int fileNumber)
5078 {
5079     for (BlockMap::iterator it = mapBlockIndex.begin(); it != mapBlockIndex.end(); ++it) {
5080         CBlockIndex* pindex = it->second;
5081         if (pindex->nFile == fileNumber) {
5082             pindex->nStatus &= ~BLOCK_HAVE_DATA;
5083             pindex->nStatus &= ~BLOCK_HAVE_UNDO;
5084             pindex->nFile = 0;
5085             pindex->nDataPos = 0;
5086             pindex->nUndoPos = 0;
5087             setDirtyBlockIndex.insert(pindex);
5088
5089             // Prune from mapBlocksUnlinked -- any block we prune would have
5090             // to be downloaded again in order to consider its chain, at which
5091             // point it would be considered as a candidate for
5092             // mapBlocksUnlinked or setBlockIndexCandidates.
5093             std::pair<std::multimap<CBlockIndex*, CBlockIndex*>::iterator, std::multimap<CBlockIndex*, CBlockIndex*>::iterator> range = mapBlocksUnlinked.equal_range(pindex->pprev);
5094             while (range.first != range.second) {
5095                 std::multimap<CBlockIndex *, CBlockIndex *>::iterator it = range.first;
5096                 range.first++;
5097                 if (it->second == pindex) {
5098                     mapBlocksUnlinked.erase(it);
5099                 }
5100             }
5101         }
5102     }
5103
5104     vinfoBlockFile[fileNumber].SetNull();
5105     setDirtyFileInfo.insert(fileNumber);
5106 }
5107
5108
5109 void UnlinkPrunedFiles(std::set<int>& setFilesToPrune)
5110 {
5111     for (set<int>::iterator it = setFilesToPrune.begin(); it != setFilesToPrune.end(); ++it) {
5112         CDiskBlockPos pos(*it, 0);
5113         boost::filesystem::remove(GetBlockPosFilename(pos, "blk"));
5114         boost::filesystem::remove(GetBlockPosFilename(pos, "rev"));
5115         LogPrintf("Prune: %s deleted blk/rev (%05u)\n", __func__, *it);
5116     }
5117 }
5118
5119 /* Calculate the block/rev files that should be deleted to remain under target*/
5120 void FindFilesToPrune(std::set<int>& setFilesToPrune)
5121 {
5122     LOCK2(cs_main, cs_LastBlockFile);
5123     if (chainActive.Tip() == NULL || nPruneTarget == 0) {
5124         return;
5125     }
5126     if (chainActive.Tip()->GetHeight() <= Params().PruneAfterHeight()) {
5127         return;
5128     }
5129     unsigned int nLastBlockWeCanPrune = chainActive.Tip()->GetHeight() - MIN_BLOCKS_TO_KEEP;
5130     uint64_t nCurrentUsage = CalculateCurrentUsage();
5131     // We don't check to prune until after we've allocated new space for files
5132     // So we should leave a buffer under our target to account for another allocation
5133     // before the next pruning.
5134     uint64_t nBuffer = BLOCKFILE_CHUNK_SIZE + UNDOFILE_CHUNK_SIZE;
5135     uint64_t nBytesToPrune;
5136     int count=0;
5137
5138     if (nCurrentUsage + nBuffer >= nPruneTarget) {
5139         for (int fileNumber = 0; fileNumber < nLastBlockFile; fileNumber++) {
5140             nBytesToPrune = vinfoBlockFile[fileNumber].nSize + vinfoBlockFile[fileNumber].nUndoSize;
5141
5142             if (vinfoBlockFile[fileNumber].nSize == 0)
5143                 continue;
5144
5145             if (nCurrentUsage + nBuffer < nPruneTarget)  // are we below our target?
5146                 break;
5147
5148             // don't prune files that could have a block within MIN_BLOCKS_TO_KEEP of the main chain's tip but keep scanning
5149             if (vinfoBlockFile[fileNumber].nHeightLast > nLastBlockWeCanPrune)
5150                 continue;
5151
5152             PruneOneBlockFile(fileNumber);
5153             // Queue up the files for removal
5154             setFilesToPrune.insert(fileNumber);
5155             nCurrentUsage -= nBytesToPrune;
5156             count++;
5157         }
5158     }
5159
5160     LogPrint("prune", "Prune: target=%dMiB actual=%dMiB diff=%dMiB max_prune_height=%d removed %d blk/rev pairs\n",
5161              nPruneTarget/1024/1024, nCurrentUsage/1024/1024,
5162              ((int64_t)nPruneTarget - (int64_t)nCurrentUsage)/1024/1024,
5163              nLastBlockWeCanPrune, count);
5164 }
5165
5166 bool CheckDiskSpace(uint64_t nAdditionalBytes)
5167 {
5168     uint64_t nFreeBytesAvailable = boost::filesystem::space(GetDataDir()).available;
5169
5170     // Check for nMinDiskSpace bytes (currently 50MB)
5171     if (nFreeBytesAvailable < nMinDiskSpace + nAdditionalBytes)
5172         return AbortNode("Disk space is low!", _("Error: Disk space is low!"));
5173
5174     return true;
5175 }
5176
5177 FILE* OpenDiskFile(const CDiskBlockPos &pos, const char *prefix, bool fReadOnly)
5178 {
5179     static int32_t didinit[64];
5180     if (pos.IsNull())
5181         return NULL;
5182     boost::filesystem::path path = GetBlockPosFilename(pos, prefix);
5183     boost::filesystem::create_directories(path.parent_path());
5184     FILE* file = fopen(path.string().c_str(), "rb+");
5185     if (!file && !fReadOnly)
5186         file = fopen(path.string().c_str(), "wb+");
5187     if (!file) {
5188         LogPrintf("Unable to open file %s\n", path.string());
5189         return NULL;
5190     }
5191     if ( pos.nFile < sizeof(didinit)/sizeof(*didinit) && didinit[pos.nFile] == 0 && strcmp(prefix,(char *)"blk") == 0 )
5192     {
5193         komodo_prefetch(file);
5194         didinit[pos.nFile] = 1;
5195     }
5196     if (pos.nPos) {
5197         if (fseek(file, pos.nPos, SEEK_SET)) {
5198             LogPrintf("Unable to seek to position %u of %s\n", pos.nPos, path.string());
5199             fclose(file);
5200             return NULL;
5201         }
5202     }
5203     return file;
5204 }
5205
5206 FILE* OpenBlockFile(const CDiskBlockPos &pos, bool fReadOnly) {
5207     return OpenDiskFile(pos, "blk", fReadOnly);
5208 }
5209
5210 FILE* OpenUndoFile(const CDiskBlockPos &pos, bool fReadOnly) {
5211     return OpenDiskFile(pos, "rev", fReadOnly);
5212 }
5213
5214 boost::filesystem::path GetBlockPosFilename(const CDiskBlockPos &pos, const char *prefix)
5215 {
5216     return GetDataDir() / "blocks" / strprintf("%s%05u.dat", prefix, pos.nFile);
5217 }
5218
5219 CBlockIndex * InsertBlockIndex(uint256 hash)
5220 {
5221     if (hash.IsNull())
5222         return NULL;
5223
5224     // Return existing
5225     BlockMap::iterator mi = mapBlockIndex.find(hash);
5226     if (mi != mapBlockIndex.end())
5227         return (*mi).second;
5228
5229     // Create new
5230     CBlockIndex* pindexNew = new CBlockIndex();
5231     if (!pindexNew)
5232         throw runtime_error("LoadBlockIndex(): new CBlockIndex failed");
5233     mi = mapBlockIndex.insert(make_pair(hash, pindexNew)).first;
5234     pindexNew->phashBlock = &((*mi).first);
5235     //fprintf(stderr,"inserted to block index %s\n",hash.ToString().c_str());
5236
5237     return pindexNew;
5238 }
5239
5240 //void komodo_pindex_init(CBlockIndex *pindex,int32_t height);
5241
5242 bool static LoadBlockIndexDB()
5243 {
5244     const CChainParams& chainparams = Params();
5245     LogPrintf("%s: start loading guts\n", __func__);
5246     if (!pblocktree->LoadBlockIndexGuts())
5247         return false;
5248     LogPrintf("%s: loaded guts\n", __func__);
5249     boost::this_thread::interruption_point();
5250
5251     // Calculate chainPower
5252     vector<pair<int, CBlockIndex*> > vSortedByHeight;
5253     vSortedByHeight.reserve(mapBlockIndex.size());
5254     BOOST_FOREACH(const PAIRTYPE(uint256, CBlockIndex*)& item, mapBlockIndex)
5255     {
5256         CBlockIndex* pindex = item.second;
5257         vSortedByHeight.push_back(make_pair(pindex->GetHeight(), pindex));
5258         //komodo_pindex_init(pindex,(int32_t)pindex->GetHeight());
5259     }
5260     //fprintf(stderr,"load blockindexDB paired %u\n",(uint32_t)time(NULL));
5261     sort(vSortedByHeight.begin(), vSortedByHeight.end());
5262     //fprintf(stderr,"load blockindexDB sorted %u\n",(uint32_t)time(NULL));
5263     BOOST_FOREACH(const PAIRTYPE(int, CBlockIndex*)& item, vSortedByHeight)
5264     {
5265         CBlockIndex* pindex = item.second;
5266         pindex->chainPower = (pindex->pprev ? CChainPower(pindex) + pindex->pprev->chainPower : CChainPower(pindex)) + GetBlockProof(*pindex);
5267         // We can link the chain of blocks for which we've received transactions at some point.
5268         // Pruned nodes may have deleted the block.
5269         if (pindex->nTx > 0) {
5270             if (pindex->pprev) {
5271                 if (pindex->pprev->nChainTx) {
5272                     pindex->nChainTx = pindex->pprev->nChainTx + pindex->nTx;
5273                     if (pindex->pprev->nChainSproutValue && pindex->nSproutValue) {
5274                         pindex->nChainSproutValue = *pindex->pprev->nChainSproutValue + *pindex->nSproutValue;
5275                     } else {
5276                         pindex->nChainSproutValue = boost::none;
5277                     }
5278                     if (pindex->pprev->nChainSaplingValue) {
5279                         pindex->nChainSaplingValue = *pindex->pprev->nChainSaplingValue + pindex->nSaplingValue;
5280                     } else {
5281                         pindex->nChainSaplingValue = boost::none;
5282                     }
5283                 } else {
5284                     pindex->nChainTx = 0;
5285                     pindex->nChainSproutValue = boost::none;
5286                     pindex->nChainSaplingValue = boost::none;
5287                     mapBlocksUnlinked.insert(std::make_pair(pindex->pprev, pindex));
5288                 }
5289             } else {
5290                 pindex->nChainTx = pindex->nTx;
5291                 pindex->nChainSproutValue = pindex->nSproutValue;
5292                 pindex->nChainSaplingValue = pindex->nSaplingValue;
5293             }
5294         }
5295         // Construct in-memory chain of branch IDs.
5296         // Relies on invariant: a block that does not activate a network upgrade
5297         // will always be valid under the same consensus rules as its parent.
5298         // Genesis block has a branch ID of zero by definition, but has no
5299         // validity status because it is side-loaded into a fresh chain.
5300         // Activation blocks will have branch IDs set (read from disk).
5301         if (pindex->pprev) {
5302             if (pindex->IsValid(BLOCK_VALID_CONSENSUS) && !pindex->nCachedBranchId) {
5303                 pindex->nCachedBranchId = pindex->pprev->nCachedBranchId;
5304             }
5305         } else {
5306             pindex->nCachedBranchId = SPROUT_BRANCH_ID;
5307         }
5308         if (pindex->IsValid(BLOCK_VALID_TRANSACTIONS) && (pindex->nChainTx || pindex->pprev == NULL))
5309             setBlockIndexCandidates.insert(pindex);
5310         if (pindex->nStatus & BLOCK_FAILED_MASK && (!pindexBestInvalid || pindex->chainPower > pindexBestInvalid->chainPower))
5311             pindexBestInvalid = pindex;
5312         if (pindex->pprev)
5313             pindex->BuildSkip();
5314         if (pindex->IsValid(BLOCK_VALID_TREE) && (pindexBestHeader == NULL || CBlockIndexWorkComparator()(pindexBestHeader, pindex)))
5315             pindexBestHeader = pindex;
5316         //komodo_pindex_init(pindex,(int32_t)pindex->GetHeight());
5317     }
5318     //fprintf(stderr,"load blockindexDB chained %u\n",(uint32_t)time(NULL));
5319
5320     // Load block file info
5321     pblocktree->ReadLastBlockFile(nLastBlockFile);
5322     vinfoBlockFile.resize(nLastBlockFile + 1);
5323     LogPrintf("%s: last block file = %i\n", __func__, nLastBlockFile);
5324     for (int nFile = 0; nFile <= nLastBlockFile; nFile++) {
5325         pblocktree->ReadBlockFileInfo(nFile, vinfoBlockFile[nFile]);
5326     }
5327     LogPrintf("%s: last block file info: %s\n", __func__, vinfoBlockFile[nLastBlockFile].ToString());
5328     for (int nFile = nLastBlockFile + 1; true; nFile++) {
5329         CBlockFileInfo info;
5330         if (pblocktree->ReadBlockFileInfo(nFile, info)) {
5331             vinfoBlockFile.push_back(info);
5332         } else {
5333             break;
5334         }
5335     }
5336
5337     // Check presence of blk files
5338     LogPrintf("Checking all blk files are present...\n");
5339     set<int> setBlkDataFiles;
5340     BOOST_FOREACH(const PAIRTYPE(uint256, CBlockIndex*)& item, mapBlockIndex)
5341     {
5342         CBlockIndex* pindex = item.second;
5343         if (pindex->nStatus & BLOCK_HAVE_DATA) {
5344             setBlkDataFiles.insert(pindex->nFile);
5345         }
5346         //komodo_pindex_init(pindex,(int32_t)pindex->GetHeight());
5347     }
5348     //fprintf(stderr,"load blockindexDB %u\n",(uint32_t)time(NULL));
5349     for (std::set<int>::iterator it = setBlkDataFiles.begin(); it != setBlkDataFiles.end(); it++)
5350     {
5351         CDiskBlockPos pos(*it, 0);
5352         if (CAutoFile(OpenBlockFile(pos, true), SER_DISK, CLIENT_VERSION).IsNull()) {
5353             return false;
5354         }
5355     }
5356
5357     // Check whether we have ever pruned block & undo files
5358     pblocktree->ReadFlag("prunedblockfiles", fHavePruned);
5359     if (fHavePruned)
5360         LogPrintf("LoadBlockIndexDB(): Block files have previously been pruned\n");
5361
5362     // Check whether we need to continue reindexing
5363     bool fReindexing = false;
5364     pblocktree->ReadReindexing(fReindexing);
5365     fReindex |= fReindexing;
5366
5367     // Check whether we have a transaction index
5368     pblocktree->ReadFlag("txindex", fTxIndex);
5369     LogPrintf("%s: transaction index %s\n", __func__, fTxIndex ? "enabled" : "disabled");
5370     // Check whether we have an address index
5371     pblocktree->ReadFlag("addressindex", fAddressIndex);
5372     LogPrintf("%s: address index %s\n", __func__, fAddressIndex ? "enabled" : "disabled");
5373
5374     // Check whether we have a timestamp index
5375     pblocktree->ReadFlag("timestampindex", fTimestampIndex);
5376     LogPrintf("%s: timestamp index %s\n", __func__, fTimestampIndex ? "enabled" : "disabled");
5377
5378     // Check whether we have a spent index
5379     pblocktree->ReadFlag("spentindex", fSpentIndex);
5380     LogPrintf("%s: spent index %s\n", __func__, fSpentIndex ? "enabled" : "disabled");
5381
5382     // Fill in-memory data
5383     BOOST_FOREACH(const PAIRTYPE(uint256, CBlockIndex*)& item, mapBlockIndex)
5384     {
5385         CBlockIndex* pindex = item.second;
5386         // - This relationship will always be true even if pprev has multiple
5387         //   children, because hashSproutAnchor is technically a property of pprev,
5388         //   not its children.
5389         // - This will miss chain tips; we handle the best tip below, and other
5390         //   tips will be handled by ConnectTip during a re-org.
5391         if (pindex->pprev) {
5392             pindex->pprev->hashFinalSproutRoot = pindex->hashSproutAnchor;
5393         }
5394         //komodo_pindex_init(pindex,(int32_t)pindex->GetHeight());
5395     }
5396
5397     // Load pointer to end of best chain
5398     BlockMap::iterator it = mapBlockIndex.find(pcoinsTip->GetBestBlock());
5399     if (it == mapBlockIndex.end())
5400         return true;
5401
5402     chainActive.SetTip(it->second);
5403
5404     // Set hashFinalSproutRoot for the end of best chain
5405     it->second->hashFinalSproutRoot = pcoinsTip->GetBestAnchor(SPROUT);
5406
5407     PruneBlockIndexCandidates();
5408
5409     double progress;
5410     if ( ASSETCHAINS_SYMBOL[0] == 0 ) {
5411         progress = Checkpoints::GuessVerificationProgress(chainparams.Checkpoints(), chainActive.Tip());
5412     } else {
5413         int32_t longestchain = komodo_longestchain();
5414         // TODO: komodo_longestchain does not have the data it needs at the time LoadBlockIndexDB
5415         // runs, which makes it return 0, so we guess 50% for now
5416         progress = (longestchain > 0 ) ? (double) chainActive.Height() / longestchain : 0.5;
5417     }
5418
5419     LogPrintf("%s: hashBestChain=%s height=%d date=%s progress=%f\n", __func__,
5420               chainActive.LastTip()->GetBlockHash().ToString(), chainActive.Height(),
5421               DateTimeStrFormat("%Y-%m-%d %H:%M:%S", chainActive.LastTip()->GetBlockTime()),
5422               progress);
5423
5424     EnforceNodeDeprecation(chainActive.Height(), true);
5425
5426     return true;
5427 }
5428
5429 CVerifyDB::CVerifyDB()
5430 {
5431     uiInterface.ShowProgress(_("Verifying blocks..."), 0);
5432 }
5433
5434 CVerifyDB::~CVerifyDB()
5435 {
5436     uiInterface.ShowProgress("", 100);
5437 }
5438
5439 bool CVerifyDB::VerifyDB(CCoinsView *coinsview, int nCheckLevel, int nCheckDepth)
5440 {
5441     LOCK(cs_main);
5442     if (chainActive.Tip() == NULL || chainActive.Tip()->pprev == NULL)
5443         return true;
5444
5445     // Verify blocks in the best chain
5446     if (nCheckDepth <= 0)
5447         nCheckDepth = 1000000000; // suffices until the year 19000
5448     if (nCheckDepth > chainActive.Height())
5449         nCheckDepth = chainActive.Height();
5450     nCheckLevel = std::max(0, std::min(4, nCheckLevel));
5451     LogPrintf("Verifying last %i blocks at level %i\n", nCheckDepth, nCheckLevel);
5452     CCoinsViewCache coins(coinsview);
5453     CBlockIndex* pindexState = chainActive.Tip();
5454     CBlockIndex* pindexFailure = NULL;
5455     int nGoodTransactions = 0;
5456     CValidationState state;
5457     // No need to verify JoinSplits twice
5458     auto verifier = libzcash::ProofVerifier::Disabled();
5459     //fprintf(stderr,"start VerifyDB %u\n",(uint32_t)time(NULL));
5460     for (CBlockIndex* pindex = chainActive.Tip(); pindex && pindex->pprev; pindex = pindex->pprev)
5461     {
5462         boost::this_thread::interruption_point();
5463         uiInterface.ShowProgress(_("Verifying blocks..."), std::max(1, std::min(99, (int)(((double)(chainActive.Height() - pindex->GetHeight())) / (double)nCheckDepth * (nCheckLevel >= 4 ? 50 : 100)))));
5464         if (pindex->GetHeight() < chainActive.Height()-nCheckDepth)
5465             break;
5466         CBlock block;
5467         // check level 0: read from disk
5468         if (!ReadBlockFromDisk(block, pindex,0))
5469             return error("VerifyDB(): *** ReadBlockFromDisk failed at %d, hash=%s", pindex->GetHeight(), pindex->GetBlockHash().ToString());
5470         // check level 1: verify block validity
5471         int32_t futureblock;
5472         if (nCheckLevel >= 1 && !CheckBlock(&futureblock,pindex->GetHeight(),pindex,block, state, verifier,0) )
5473             return error("VerifyDB(): *** found bad block at %d, hash=%s\n", pindex->GetHeight(), pindex->GetBlockHash().ToString());
5474         // check level 2: verify undo validity
5475         if (nCheckLevel >= 2 && pindex) {
5476             CBlockUndo undo;
5477             CDiskBlockPos pos = pindex->GetUndoPos();
5478             if (!pos.IsNull()) {
5479                 if (!UndoReadFromDisk(undo, pos, pindex->pprev->GetBlockHash()))
5480                     return error("VerifyDB(): *** found bad undo data at %d, hash=%s\n", pindex->GetHeight(), pindex->GetBlockHash().ToString());
5481             }
5482         }
5483         // check level 3: check for inconsistencies during memory-only disconnect of tip blocks
5484         if (nCheckLevel >= 3 && pindex == pindexState && (coins.DynamicMemoryUsage() + pcoinsTip->DynamicMemoryUsage()) <= nCoinCacheUsage) {
5485             bool fClean = true;
5486             if (!DisconnectBlock(block, state, pindex, coins, &fClean))
5487                 return error("VerifyDB(): *** irrecoverable inconsistency in block data at %d, hash=%s", pindex->GetHeight(), pindex->GetBlockHash().ToString());
5488             pindexState = pindex->pprev;
5489             if (!fClean) {
5490                 nGoodTransactions = 0;
5491                 pindexFailure = pindex;
5492             } else
5493                 nGoodTransactions += block.vtx.size();
5494         }
5495         if (ShutdownRequested())
5496             return true;
5497     }
5498     //fprintf(stderr,"end VerifyDB %u\n",(uint32_t)time(NULL));
5499     if (pindexFailure)
5500         return error("VerifyDB(): *** coin database inconsistencies found (last %i blocks, %i good transactions before that)\n", chainActive.Height() - pindexFailure->GetHeight() + 1, nGoodTransactions);
5501
5502     // check level 4: try reconnecting blocks
5503     if (nCheckLevel >= 4) {
5504         CBlockIndex *pindex = pindexState;
5505         while (pindex != chainActive.Tip()) {
5506             boost::this_thread::interruption_point();
5507             uiInterface.ShowProgress(_("Verifying blocks..."), std::max(1, std::min(99, 100 - (int)(((double)(chainActive.Height() - pindex->GetHeight())) / (double)nCheckDepth * 50))));
5508             pindex = chainActive.Next(pindex);
5509             CBlock block;
5510             if (!ReadBlockFromDisk(block, pindex,0))
5511                 return error("VerifyDB(): *** ReadBlockFromDisk failed at %d, hash=%s", pindex->GetHeight(), pindex->GetBlockHash().ToString());
5512             if (!ConnectBlock(block, state, pindex, coins,false, true))
5513                 return error("VerifyDB(): *** found unconnectable block at %d, hash=%s", pindex->GetHeight(), pindex->GetBlockHash().ToString());
5514         }
5515     }
5516
5517     LogPrintf("No coin database inconsistencies in last %i blocks (%i transactions)\n", chainActive.Height() - pindexState->GetHeight(), nGoodTransactions);
5518
5519     return true;
5520 }
5521
5522 bool RewindBlockIndex(const CChainParams& params, bool& clearWitnessCaches)
5523 {
5524     LOCK(cs_main);
5525
5526     // RewindBlockIndex is called after LoadBlockIndex, so at this point every block
5527     // index will have nCachedBranchId set based on the values previously persisted
5528     // to disk. By definition, a set nCachedBranchId means that the block was
5529     // fully-validated under the corresponding consensus rules. Thus we can quickly
5530     // identify whether the current active chain matches our expected sequence of
5531     // consensus rule changes, with two checks:
5532     //
5533     // - BLOCK_ACTIVATES_UPGRADE is set only on blocks that activate upgrades.
5534     // - nCachedBranchId for each block matches what we expect.
5535     auto sufficientlyValidated = [&params](const CBlockIndex* pindex) {
5536         auto consensus = params.GetConsensus();
5537         bool fFlagSet = pindex->nStatus & BLOCK_ACTIVATES_UPGRADE;
5538         bool fFlagExpected = IsActivationHeightForAnyUpgrade(pindex->GetHeight(), consensus);
5539         return fFlagSet == fFlagExpected &&
5540         pindex->nCachedBranchId &&
5541         *pindex->nCachedBranchId == CurrentEpochBranchId(pindex->GetHeight(), consensus);
5542     };
5543
5544     int nHeight = 1;
5545     while (nHeight <= chainActive.Height()) {
5546         if (!sufficientlyValidated(chainActive[nHeight])) {
5547             break;
5548         }
5549         nHeight++;
5550     }
5551
5552     // nHeight is now the height of the first insufficiently-validated block, or tipheight + 1
5553     auto rewindLength = chainActive.Height() - nHeight;
5554     if (rewindLength > 0 && rewindLength > MAX_REORG_LENGTH)
5555     {
5556         auto pindexOldTip = chainActive.Tip();
5557         auto pindexRewind = chainActive[nHeight - 1];
5558         auto msg = strprintf(_(
5559                                "A block chain rewind has been detected that would roll back %d blocks! "
5560                                "This is larger than the maximum of %d blocks, and so the node is shutting down for your safety."
5561                                ), rewindLength, MAX_REORG_LENGTH) + "\n\n" +
5562         _("Rewind details") + ":\n" +
5563         "- " + strprintf(_("Current tip:   %s, height %d"),
5564                          pindexOldTip->phashBlock->GetHex(), pindexOldTip->GetHeight()) + "\n" +
5565         "- " + strprintf(_("Rewinding to:  %s, height %d"),
5566                          pindexRewind->phashBlock->GetHex(), pindexRewind->GetHeight()) + "\n\n" +
5567         _("Please help, human!");
5568         LogPrintf("*** %s\n", msg);
5569         uiInterface.ThreadSafeMessageBox(msg, "", CClientUIInterface::MSG_ERROR);
5570         StartShutdown();
5571         return false;
5572     }
5573
5574     CValidationState state;
5575     CBlockIndex* pindex = chainActive.Tip();
5576     while (chainActive.Height() >= nHeight) {
5577         if (fPruneMode && !(chainActive.Tip()->nStatus & BLOCK_HAVE_DATA)) {
5578             // If pruning, don't try rewinding past the HAVE_DATA point;
5579             // since older blocks can't be served anyway, there's
5580             // no need to walk further, and trying to DisconnectTip()
5581             // will fail (and require a needless reindex/redownload
5582             // of the blockchain).
5583             break;
5584         }
5585         if (!DisconnectTip(state, true)) {
5586             return error("RewindBlockIndex: unable to disconnect block at height %i", pindex->GetHeight());
5587         }
5588         // Occasionally flush state to disk.
5589         if (!FlushStateToDisk(state, FLUSH_STATE_PERIODIC))
5590             return false;
5591     }
5592
5593     // Reduce validity flag and have-data flags.
5594
5595     // Collect blocks to be removed (blocks in mapBlockIndex must be at least BLOCK_VALID_TREE).
5596     // We do this after actual disconnecting, otherwise we'll end up writing the lack of data
5597     // to disk before writing the chainstate, resulting in a failure to continue if interrupted.
5598     std::vector<const CBlockIndex*> vBlocks;
5599     for (BlockMap::iterator it = mapBlockIndex.begin(); it != mapBlockIndex.end(); it++) {
5600         CBlockIndex* pindexIter = it->second;
5601
5602         // Note: If we encounter an insufficiently validated block that
5603         // is on chainActive, it must be because we are a pruning node, and
5604         // this block or some successor doesn't HAVE_DATA, so we were unable to
5605         // rewind all the way.  Blocks remaining on chainActive at this point
5606         // must not have their validity reduced.
5607         if (!sufficientlyValidated(pindexIter) && !chainActive.Contains(pindexIter)) {
5608             // Reduce validity
5609             pindexIter->nStatus =
5610             std::min<unsigned int>(pindexIter->nStatus & BLOCK_VALID_MASK, BLOCK_VALID_TREE) |
5611             (pindexIter->nStatus & ~BLOCK_VALID_MASK);
5612             // Remove have-data flags
5613             pindexIter->nStatus &= ~(BLOCK_HAVE_DATA | BLOCK_HAVE_UNDO);
5614             // Remove branch ID
5615             pindexIter->nStatus &= ~BLOCK_ACTIVATES_UPGRADE;
5616             pindexIter->nCachedBranchId = boost::none;
5617             // Remove storage location
5618             pindexIter->nFile = 0;
5619             pindexIter->nDataPos = 0;
5620             pindexIter->nUndoPos = 0;
5621             // Remove various other things
5622             pindexIter->nTx = 0;
5623             pindexIter->nChainTx = 0;
5624             pindexIter->nSproutValue = boost::none;
5625             pindexIter->nChainSproutValue = boost::none;
5626             pindexIter->nSaplingValue = 0;
5627             pindexIter->nChainSaplingValue = boost::none;
5628             pindexIter->nSequenceId = 0;
5629
5630             // Make sure it gets written
5631             /* corresponds to commented out block below as an alternative to setDirtyBlockIndex
5632             vBlocks.push_back(pindexIter);
5633             */
5634             setDirtyBlockIndex.insert(pindexIter);
5635             if (pindexIter == pindexBestInvalid)
5636             {
5637                 //fprintf(stderr,"Reset invalid block marker if it was pointing to this block\n");
5638                 pindexBestInvalid = NULL;
5639             }
5640
5641             // Update indices
5642             setBlockIndexCandidates.erase(pindexIter);
5643             auto ret = mapBlocksUnlinked.equal_range(pindexIter->pprev);
5644             while (ret.first != ret.second) {
5645                 if (ret.first->second == pindexIter) {
5646                     mapBlocksUnlinked.erase(ret.first++);
5647                 } else {
5648                     ++ret.first;
5649                 }
5650             }
5651         } else if (pindexIter->IsValid(BLOCK_VALID_TRANSACTIONS) && pindexIter->nChainTx) {
5652             setBlockIndexCandidates.insert(pindexIter);
5653         }
5654     }
5655
5656     /*
5657     // Set pindexBestHeader to the current chain tip
5658     // (since we are about to delete the block it is pointing to)
5659     pindexBestHeader = chainActive.Tip();
5660
5661     // Erase block indices on-disk
5662     if (!pblocktree->EraseBatchSync(vBlocks)) {
5663         return AbortNode(state, "Failed to erase from block index database");
5664     }
5665
5666     // Erase block indices in-memory
5667     for (auto pindex : vBlocks) {
5668         auto ret = mapBlockIndex.find(*pindex->phashBlock);
5669         if (ret != mapBlockIndex.end()) {
5670             mapBlockIndex.erase(ret);
5671             delete pindex;
5672         }
5673     }
5674     */
5675
5676     PruneBlockIndexCandidates();
5677
5678     CheckBlockIndex();
5679
5680     if (!FlushStateToDisk(state, FLUSH_STATE_ALWAYS)) {
5681         return false;
5682     }
5683
5684     return true;
5685 }
5686
5687 void UnloadBlockIndex()
5688 {
5689     LOCK(cs_main);
5690     setBlockIndexCandidates.clear();
5691     chainActive.SetTip(NULL);
5692     pindexBestInvalid = NULL;
5693     pindexBestHeader = NULL;
5694     mempool.clear();
5695     mapOrphanTransactions.clear();
5696     mapOrphanTransactionsByPrev.clear();
5697     nSyncStarted = 0;
5698     mapBlocksUnlinked.clear();
5699     vinfoBlockFile.clear();
5700     nLastBlockFile = 0;
5701     nBlockSequenceId = 1;
5702     mapBlockSource.clear();
5703     mapBlocksInFlight.clear();
5704     nQueuedValidatedHeaders = 0;
5705     nPreferredDownload = 0;
5706     setDirtyBlockIndex.clear();
5707     setDirtyFileInfo.clear();
5708     mapNodeState.clear();
5709     recentRejects.reset(NULL);
5710
5711     BOOST_FOREACH(BlockMap::value_type& entry, mapBlockIndex) {
5712         delete entry.second;
5713     }
5714     mapBlockIndex.clear();
5715     fHavePruned = false;
5716 }
5717
5718 bool LoadBlockIndex()
5719 {
5720     // Load block index from databases
5721     KOMODO_LOADINGBLOCKS = 1;
5722     if (!fReindex && !LoadBlockIndexDB())
5723     {
5724         KOMODO_LOADINGBLOCKS = 0;
5725         return false;
5726     }
5727     fprintf(stderr,"finished loading blocks %s\n",ASSETCHAINS_SYMBOL);
5728     return true;
5729 }
5730
5731
5732 bool InitBlockIndex() {
5733     const CChainParams& chainparams = Params();
5734     LOCK(cs_main);
5735
5736     // Initialize global variables that cannot be constructed at startup.
5737     recentRejects.reset(new CRollingBloomFilter(120000, 0.000001));
5738     // Check whether we're already initialized
5739     if (chainActive.Genesis() != NULL)
5740     {
5741         return true;
5742     }
5743     // Use the provided setting for -txindex in the new database
5744     fTxIndex = GetBoolArg("-txindex", true);
5745     pblocktree->WriteFlag("txindex", fTxIndex);
5746     // Use the provided setting for -addressindex in the new database
5747     fAddressIndex = GetBoolArg("-addressindex", DEFAULT_ADDRESSINDEX);
5748     pblocktree->WriteFlag("addressindex", fAddressIndex);
5749
5750     // Use the provided setting for -timestampindex in the new database
5751     fTimestampIndex = GetBoolArg("-timestampindex", DEFAULT_TIMESTAMPINDEX);
5752     pblocktree->WriteFlag("timestampindex", fTimestampIndex);
5753
5754     fSpentIndex = GetBoolArg("-spentindex", DEFAULT_SPENTINDEX);
5755     pblocktree->WriteFlag("spentindex", fSpentIndex);
5756     fprintf(stderr,"fAddressIndex.%d/%d fSpentIndex.%d/%d\n",fAddressIndex,DEFAULT_ADDRESSINDEX,fSpentIndex,DEFAULT_SPENTINDEX);
5757     LogPrintf("Initializing databases...\n");
5758
5759     // Only add the genesis block if not reindexing (in which case we reuse the one already on disk)
5760     if (!fReindex) {
5761         try {
5762             CBlock &block = const_cast<CBlock&>(Params().GenesisBlock());
5763             // Start new block file
5764             unsigned int nBlockSize = ::GetSerializeSize(block, SER_DISK, CLIENT_VERSION);
5765             CDiskBlockPos blockPos;
5766             CValidationState state;
5767             if (!FindBlockPos(state, blockPos, nBlockSize+8, 0, block.GetBlockTime()))
5768                 return error("LoadBlockIndex(): FindBlockPos failed");
5769             if (!WriteBlockToDisk(block, blockPos, chainparams.MessageStart()))
5770                 return error("LoadBlockIndex(): writing genesis block to disk failed");
5771             CBlockIndex *pindex = AddToBlockIndex(block);
5772             if ( pindex == 0 )
5773                 return error("LoadBlockIndex(): couldnt add to block index");
5774             if (!ReceivedBlockTransactions(block, state, pindex, blockPos))
5775                 return error("LoadBlockIndex(): genesis block not accepted");
5776             if (!ActivateBestChain(state, &block))
5777                 return error("LoadBlockIndex(): genesis block cannot be activated");
5778             // Force a chainstate write so that when we VerifyDB in a moment, it doesn't check stale data
5779             return FlushStateToDisk(state, FLUSH_STATE_ALWAYS);
5780         } catch (const std::runtime_error& e) {
5781             return error("LoadBlockIndex(): failed to initialize block database: %s", e.what());
5782         }
5783     }
5784
5785     return true;
5786 }
5787
5788
5789
5790 bool LoadExternalBlockFile(FILE* fileIn, CDiskBlockPos *dbp)
5791 {
5792     const CChainParams& chainparams = Params();
5793     // Map of disk positions for blocks with unknown parent (only used for reindex)
5794     static std::multimap<uint256, CDiskBlockPos> mapBlocksUnknownParent;
5795     int64_t nStart = GetTimeMillis();
5796
5797     int nLoaded = 0;
5798     try {
5799         // This takes over fileIn and calls fclose() on it in the CBufferedFile destructor
5800         //CBufferedFile blkdat(fileIn, 2*MAX_BLOCK_SIZE, MAX_BLOCK_SIZE+8, SER_DISK, CLIENT_VERSION);
5801         CBufferedFile blkdat(fileIn, 32*MAX_BLOCK_SIZE, MAX_BLOCK_SIZE+8, SER_DISK, CLIENT_VERSION);
5802         uint64_t nRewind = blkdat.GetPos();
5803         while (!blkdat.eof()) {
5804             boost::this_thread::interruption_point();
5805
5806             blkdat.SetPos(nRewind);
5807             nRewind++; // start one byte further next time, in case of failure
5808             blkdat.SetLimit(); // remove former limit
5809             unsigned int nSize = 0;
5810             try {
5811                 // locate a header
5812                 unsigned char buf[MESSAGE_START_SIZE];
5813                 blkdat.FindByte(Params().MessageStart()[0]);
5814                 nRewind = blkdat.GetPos()+1;
5815                 blkdat >> FLATDATA(buf);
5816                 if (memcmp(buf, Params().MessageStart(), MESSAGE_START_SIZE))
5817                     continue;
5818                 // read size
5819                 blkdat >> nSize;
5820                 if (nSize < 80 || nSize > MAX_BLOCK_SIZE)
5821                     continue;
5822             } catch (const std::exception&) {
5823                 // no valid block header found; don't complain
5824                 break;
5825             }
5826             try {
5827                 // read block
5828                 uint64_t nBlockPos = blkdat.GetPos();
5829                 if (dbp)
5830                     dbp->nPos = nBlockPos;
5831                 blkdat.SetLimit(nBlockPos + nSize);
5832                 blkdat.SetPos(nBlockPos);
5833                 CBlock block;
5834                 blkdat >> block;
5835                 nRewind = blkdat.GetPos();
5836
5837                 // detect out of order blocks, and store them for later
5838                 uint256 hash = block.GetHash();
5839                 if (hash != chainparams.GetConsensus().hashGenesisBlock && mapBlockIndex.find(block.hashPrevBlock) == mapBlockIndex.end()) {
5840                     LogPrint("reindex", "%s: Out of order block %s, parent %s not known\n", __func__, hash.ToString(),
5841                              block.hashPrevBlock.ToString());
5842                     if (dbp)
5843                         mapBlocksUnknownParent.insert(std::make_pair(block.hashPrevBlock, *dbp));
5844                     continue;
5845                 }
5846
5847                 // process in case the block isn't known yet
5848                 if (mapBlockIndex.count(hash) == 0 || (mapBlockIndex[hash]->nStatus & BLOCK_HAVE_DATA) == 0) {
5849                     CValidationState state;
5850                     if (ProcessNewBlock(0,0,state, NULL, &block, true, dbp))
5851                         nLoaded++;
5852                     if (state.IsError())
5853                         break;
5854                 } else if (hash != chainparams.GetConsensus().hashGenesisBlock && mapBlockIndex[hash]->GetHeight() % 1000 == 0) {
5855                     LogPrintf("Block Import: already had block %s at height %d\n", hash.ToString(), mapBlockIndex[hash]->GetHeight());
5856                 }
5857
5858                 // Recursively process earlier encountered successors of this block
5859                 deque<uint256> queue;
5860                 queue.push_back(hash);
5861                 while (!queue.empty()) {
5862                     uint256 head = queue.front();
5863                     queue.pop_front();
5864                     std::pair<std::multimap<uint256, CDiskBlockPos>::iterator, std::multimap<uint256, CDiskBlockPos>::iterator> range = mapBlocksUnknownParent.equal_range(head);
5865                     while (range.first != range.second) {
5866                         std::multimap<uint256, CDiskBlockPos>::iterator it = range.first;
5867                         if (ReadBlockFromDisk(mapBlockIndex[hash]!=0?mapBlockIndex[hash]->GetHeight():0,block, it->second,1))
5868                         {
5869                             LogPrintf("%s: Processing out of order child %s of %s\n", __func__, block.GetHash().ToString(),
5870                                       head.ToString());
5871                             CValidationState dummy;
5872                             if (ProcessNewBlock(0,0,dummy, NULL, &block, true, &it->second))
5873                             {
5874                                 nLoaded++;
5875                                 queue.push_back(block.GetHash());
5876                             }
5877                         }
5878                         range.first++;
5879                         mapBlocksUnknownParent.erase(it);
5880                     }
5881                 }
5882             } catch (const std::exception& e) {
5883                 LogPrintf("%s: Deserialize or I/O error - %s\n", __func__, e.what());
5884             }
5885         }
5886     } catch (const std::runtime_error& e) {
5887         AbortNode(std::string("System error: ") + e.what());
5888     }
5889     if (nLoaded > 0)
5890         LogPrintf("Loaded %i blocks from external file in %dms\n", nLoaded, GetTimeMillis() - nStart);
5891     return nLoaded > 0;
5892 }
5893
5894 void static CheckBlockIndex()
5895 {
5896     const Consensus::Params& consensusParams = Params().GetConsensus();
5897     if (!fCheckBlockIndex) {
5898         return;
5899     }
5900
5901     LOCK(cs_main);
5902
5903     // During a reindex, we read the genesis block and call CheckBlockIndex before ActivateBestChain,
5904     // so we have the genesis block in mapBlockIndex but no active chain.  (A few of the tests when
5905     // iterating the block tree require that chainActive has been initialized.)
5906     if (chainActive.Height() < 0) {
5907         assert(mapBlockIndex.size() <= 1);
5908         return;
5909     }
5910
5911     // Build forward-pointing map of the entire block tree.
5912     std::multimap<CBlockIndex*,CBlockIndex*> forward;
5913     for (BlockMap::iterator it = mapBlockIndex.begin(); it != mapBlockIndex.end(); it++) {
5914         if ( it->second != 0 )
5915             forward.insert(std::make_pair(it->second->pprev, it->second));
5916     }
5917     if ( Params().NetworkIDString() != "regtest" )
5918         assert(forward.size() == mapBlockIndex.size());
5919
5920     std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> rangeGenesis = forward.equal_range(NULL);
5921     CBlockIndex *pindex = rangeGenesis.first->second;
5922     rangeGenesis.first++;
5923     assert(rangeGenesis.first == rangeGenesis.second); // There is only one index entry with parent NULL.
5924
5925     // Iterate over the entire block tree, using depth-first search.
5926     // Along the way, remember whether there are blocks on the path from genesis
5927     // block being explored which are the first to have certain properties.
5928     size_t nNodes = 0;
5929     int nHeight = 0;
5930     CBlockIndex* pindexFirstInvalid = NULL; // Oldest ancestor of pindex which is invalid.
5931     CBlockIndex* pindexFirstMissing = NULL; // Oldest ancestor of pindex which does not have BLOCK_HAVE_DATA.
5932     CBlockIndex* pindexFirstNeverProcessed = NULL; // Oldest ancestor of pindex for which nTx == 0.
5933     CBlockIndex* pindexFirstNotTreeValid = NULL; // Oldest ancestor of pindex which does not have BLOCK_VALID_TREE (regardless of being valid or not).
5934     CBlockIndex* pindexFirstNotTransactionsValid = NULL; // Oldest ancestor of pindex which does not have BLOCK_VALID_TRANSACTIONS (regardless of being valid or not).
5935     CBlockIndex* pindexFirstNotChainValid = NULL; // Oldest ancestor of pindex which does not have BLOCK_VALID_CHAIN (regardless of being valid or not).
5936     CBlockIndex* pindexFirstNotScriptsValid = NULL; // Oldest ancestor of pindex which does not have BLOCK_VALID_SCRIPTS (regardless of being valid or not).
5937     while (pindex != NULL) {
5938         nNodes++;
5939         if (pindexFirstInvalid == NULL && pindex->nStatus & BLOCK_FAILED_VALID) pindexFirstInvalid = pindex;
5940         if (pindexFirstMissing == NULL && !(pindex->nStatus & BLOCK_HAVE_DATA)) pindexFirstMissing = pindex;
5941         if (pindexFirstNeverProcessed == NULL && pindex->nTx == 0) pindexFirstNeverProcessed = pindex;
5942         if (pindex->pprev != NULL && pindexFirstNotTreeValid == NULL && (pindex->nStatus & BLOCK_VALID_MASK) < BLOCK_VALID_TREE) pindexFirstNotTreeValid = pindex;
5943         if (pindex->pprev != NULL && pindexFirstNotTransactionsValid == NULL && (pindex->nStatus & BLOCK_VALID_MASK) < BLOCK_VALID_TRANSACTIONS) pindexFirstNotTransactionsValid = pindex;
5944         if (pindex->pprev != NULL && pindexFirstNotChainValid == NULL && (pindex->nStatus & BLOCK_VALID_MASK) < BLOCK_VALID_CHAIN) pindexFirstNotChainValid = pindex;
5945         if (pindex->pprev != NULL && pindexFirstNotScriptsValid == NULL && (pindex->nStatus & BLOCK_VALID_MASK) < BLOCK_VALID_SCRIPTS) pindexFirstNotScriptsValid = pindex;
5946
5947         // Begin: actual consistency checks.
5948         if (pindex->pprev == NULL) {
5949             // Genesis block checks.
5950             assert(pindex->GetBlockHash() == consensusParams.hashGenesisBlock); // Genesis block's hash must match.
5951             assert(pindex == chainActive.Genesis()); // The current active chain's genesis block must be this block.
5952         }
5953         if (pindex->nChainTx == 0) assert(pindex->nSequenceId == 0);  // nSequenceId can't be set for blocks that aren't linked
5954         // VALID_TRANSACTIONS is equivalent to nTx > 0 for all nodes (whether or not pruning has occurred).
5955         // HAVE_DATA is only equivalent to nTx > 0 (or VALID_TRANSACTIONS) if no pruning has occurred.
5956         if (!fHavePruned) {
5957             // If we've never pruned, then HAVE_DATA should be equivalent to nTx > 0
5958             assert(!(pindex->nStatus & BLOCK_HAVE_DATA) == (pindex->nTx == 0));
5959             assert(pindexFirstMissing == pindexFirstNeverProcessed);
5960         } else {
5961             // If we have pruned, then we can only say that HAVE_DATA implies nTx > 0
5962             if (pindex->nStatus & BLOCK_HAVE_DATA) assert(pindex->nTx > 0);
5963         }
5964         if (pindex->nStatus & BLOCK_HAVE_UNDO) assert(pindex->nStatus & BLOCK_HAVE_DATA);
5965         assert(((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_TRANSACTIONS) == (pindex->nTx > 0)); // This is pruning-independent.
5966         // All parents having had data (at some point) is equivalent to all parents being VALID_TRANSACTIONS, which is equivalent to nChainTx being set.
5967         assert((pindexFirstNeverProcessed != NULL) == (pindex->nChainTx == 0)); // nChainTx != 0 is used to signal that all parent blocks have been processed (but may have been pruned).
5968         assert((pindexFirstNotTransactionsValid != NULL) == (pindex->nChainTx == 0));
5969         assert(pindex->GetHeight() == nHeight); // nHeight must be consistent.
5970         assert(pindex->pprev == NULL || pindex->chainPower >= pindex->pprev->chainPower); // For every block except the genesis block, the chainwork must be larger than the parent's.
5971         assert(nHeight < 2 || (pindex->pskip && (pindex->pskip->GetHeight() < nHeight))); // The pskip pointer must point back for all but the first 2 blocks.
5972         assert(pindexFirstNotTreeValid == NULL); // All mapBlockIndex entries must at least be TREE valid
5973         if ((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_TREE) assert(pindexFirstNotTreeValid == NULL); // TREE valid implies all parents are TREE valid
5974         if ((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_CHAIN) assert(pindexFirstNotChainValid == NULL); // CHAIN valid implies all parents are CHAIN valid
5975         if ((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_SCRIPTS) assert(pindexFirstNotScriptsValid == NULL); // SCRIPTS valid implies all parents are SCRIPTS valid
5976         if (pindexFirstInvalid == NULL) {
5977             // Checks for not-invalid blocks.
5978             assert((pindex->nStatus & BLOCK_FAILED_MASK) == 0); // The failed mask cannot be set for blocks without invalid parents.
5979         }
5980         if (!CBlockIndexWorkComparator()(pindex, chainActive.Tip()) && pindexFirstNeverProcessed == NULL) {
5981             if (pindexFirstInvalid == NULL) {
5982                 // If this block sorts at least as good as the current tip and
5983                 // is valid and we have all data for its parents, it must be in
5984                 // setBlockIndexCandidates.  chainActive.Tip() must also be there
5985                 // even if some data has been pruned.
5986                 if (pindexFirstMissing == NULL || pindex == chainActive.Tip()) {
5987                     assert(setBlockIndexCandidates.count(pindex));
5988                 }
5989                 // If some parent is missing, then it could be that this block was in
5990                 // setBlockIndexCandidates but had to be removed because of the missing data.
5991                 // In this case it must be in mapBlocksUnlinked -- see test below.
5992             }
5993         } else { // If this block sorts worse than the current tip or some ancestor's block has never been seen, it cannot be in setBlockIndexCandidates.
5994             assert(setBlockIndexCandidates.count(pindex) == 0);
5995         }
5996         // Check whether this block is in mapBlocksUnlinked.
5997         std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> rangeUnlinked = mapBlocksUnlinked.equal_range(pindex->pprev);
5998         bool foundInUnlinked = false;
5999         while (rangeUnlinked.first != rangeUnlinked.second) {
6000             assert(rangeUnlinked.first->first == pindex->pprev);
6001             if (rangeUnlinked.first->second == pindex) {
6002                 foundInUnlinked = true;
6003                 break;
6004             }
6005             rangeUnlinked.first++;
6006         }
6007         if (pindex->pprev && (pindex->nStatus & BLOCK_HAVE_DATA) && pindexFirstNeverProcessed != NULL && pindexFirstInvalid == NULL) {
6008             // If this block has block data available, some parent was never received, and has no invalid parents, it must be in mapBlocksUnlinked.
6009             assert(foundInUnlinked);
6010         }
6011         if (!(pindex->nStatus & BLOCK_HAVE_DATA)) assert(!foundInUnlinked); // Can't be in mapBlocksUnlinked if we don't HAVE_DATA
6012         if (pindexFirstMissing == NULL) assert(!foundInUnlinked); // We aren't missing data for any parent -- cannot be in mapBlocksUnlinked.
6013         if (pindex->pprev && (pindex->nStatus & BLOCK_HAVE_DATA) && pindexFirstNeverProcessed == NULL && pindexFirstMissing != NULL) {
6014             // We HAVE_DATA for this block, have received data for all parents at some point, but we're currently missing data for some parent.
6015             assert(fHavePruned); // We must have pruned.
6016             // This block may have entered mapBlocksUnlinked if:
6017             //  - it has a descendant that at some point had more work than the
6018             //    tip, and
6019             //  - we tried switching to that descendant but were missing
6020             //    data for some intermediate block between chainActive and the
6021             //    tip.
6022             // So if this block is itself better than chainActive.Tip() and it wasn't in
6023             // setBlockIndexCandidates, then it must be in mapBlocksUnlinked.
6024             if (!CBlockIndexWorkComparator()(pindex, chainActive.Tip()) && setBlockIndexCandidates.count(pindex) == 0) {
6025                 if (pindexFirstInvalid == NULL) {
6026                     assert(foundInUnlinked);
6027                 }
6028             }
6029         }
6030         // assert(pindex->GetBlockHash() == pindex->GetBlockHeader().GetHash()); // Perhaps too slow
6031         // End: actual consistency checks.
6032
6033         // Try descending into the first subnode.
6034         std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> range = forward.equal_range(pindex);
6035         if (range.first != range.second) {
6036             // A subnode was found.
6037             pindex = range.first->second;
6038             nHeight++;
6039             continue;
6040         }
6041         // This is a leaf node.
6042         // Move upwards until we reach a node of which we have not yet visited the last child.
6043         while (pindex) {
6044             // We are going to either move to a parent or a sibling of pindex.
6045             // If pindex was the first with a certain property, unset the corresponding variable.
6046             if (pindex == pindexFirstInvalid) pindexFirstInvalid = NULL;
6047             if (pindex == pindexFirstMissing) pindexFirstMissing = NULL;
6048             if (pindex == pindexFirstNeverProcessed) pindexFirstNeverProcessed = NULL;
6049             if (pindex == pindexFirstNotTreeValid) pindexFirstNotTreeValid = NULL;
6050             if (pindex == pindexFirstNotTransactionsValid) pindexFirstNotTransactionsValid = NULL;
6051             if (pindex == pindexFirstNotChainValid) pindexFirstNotChainValid = NULL;
6052             if (pindex == pindexFirstNotScriptsValid) pindexFirstNotScriptsValid = NULL;
6053             // Find our parent.
6054             CBlockIndex* pindexPar = pindex->pprev;
6055             // Find which child we just visited.
6056             std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> rangePar = forward.equal_range(pindexPar);
6057             while (rangePar.first->second != pindex) {
6058                 assert(rangePar.first != rangePar.second); // Our parent must have at least the node we're coming from as child.
6059                 rangePar.first++;
6060             }
6061             // Proceed to the next one.
6062             rangePar.first++;
6063             if (rangePar.first != rangePar.second) {
6064                 // Move to the sibling.
6065                 pindex = rangePar.first->second;
6066                 break;
6067             } else {
6068                 // Move up further.
6069                 pindex = pindexPar;
6070                 nHeight--;
6071                 continue;
6072             }
6073         }
6074     }
6075
6076     // Check that we actually traversed the entire map.
6077     assert(nNodes == forward.size());
6078 }
6079
6080 //////////////////////////////////////////////////////////////////////////////
6081 //
6082 // CAlert
6083 //
6084
6085 std::string GetWarnings(const std::string& strFor)
6086 {
6087     int nPriority = 0;
6088     string strStatusBar;
6089     string strRPC;
6090
6091     if (!CLIENT_VERSION_IS_RELEASE)
6092         strStatusBar = _("This is a pre-release test build - use at your own risk - do not use for mining or merchant applications");
6093
6094     if (GetBoolArg("-testsafemode", false))
6095         strStatusBar = strRPC = "testsafemode enabled";
6096
6097     // Misc warnings like out of disk space and clock is wrong
6098     if (strMiscWarning != "")
6099     {
6100         nPriority = 1000;
6101         strStatusBar = strMiscWarning;
6102     }
6103
6104     if (fLargeWorkForkFound)
6105     {
6106         nPriority = 2000;
6107         strStatusBar = strRPC = _("Warning: The network does not appear to fully agree! Some miners appear to be experiencing issues.");
6108     }
6109     else if (fLargeWorkInvalidChainFound)
6110     {
6111         nPriority = 2000;
6112         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.");
6113     }
6114
6115     // Alerts
6116     {
6117         LOCK(cs_mapAlerts);
6118         BOOST_FOREACH(PAIRTYPE(const uint256, CAlert)& item, mapAlerts)
6119         {
6120             const CAlert& alert = item.second;
6121             if (alert.AppliesToMe() && alert.nPriority > nPriority)
6122             {
6123                 nPriority = alert.nPriority;
6124                 strStatusBar = alert.strStatusBar;
6125                 if (alert.nPriority >= ALERT_PRIORITY_SAFE_MODE) {
6126                     strRPC = alert.strRPCError;
6127                 }
6128             }
6129         }
6130     }
6131
6132     if (strFor == "statusbar")
6133         return strStatusBar;
6134     else if (strFor == "rpc")
6135         return strRPC;
6136     assert(!"GetWarnings(): invalid parameter");
6137     return "error";
6138 }
6139
6140
6141
6142
6143
6144
6145
6146
6147 //////////////////////////////////////////////////////////////////////////////
6148 //
6149 // Messages
6150 //
6151
6152
6153 bool static AlreadyHave(const CInv& inv) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
6154 {
6155     switch (inv.type)
6156     {
6157         case MSG_TX:
6158         {
6159             assert(recentRejects);
6160             if (chainActive.Tip()->GetBlockHash() != hashRecentRejectsChainTip)
6161             {
6162                 // If the chain tip has changed previously rejected transactions
6163                 // might be now valid, e.g. due to a nLockTime'd tx becoming valid,
6164                 // or a double-spend. Reset the rejects filter and give those
6165                 // txs a second chance.
6166                 hashRecentRejectsChainTip = chainActive.Tip()->GetBlockHash();
6167                 recentRejects->reset();
6168             }
6169
6170             return recentRejects->contains(inv.hash) ||
6171             mempool.exists(inv.hash) ||
6172             mapOrphanTransactions.count(inv.hash) ||
6173             pcoinsTip->HaveCoins(inv.hash);
6174         }
6175         case MSG_BLOCK:
6176             return mapBlockIndex.count(inv.hash);
6177     }
6178     // Don't know what it is, just say we already got one
6179     return true;
6180 }
6181
6182 void static ProcessGetData(CNode* pfrom)
6183 {
6184     std::deque<CInv>::iterator it = pfrom->vRecvGetData.begin();
6185
6186     vector<CInv> vNotFound;
6187
6188     LOCK(cs_main);
6189
6190     while (it != pfrom->vRecvGetData.end()) {
6191         // Don't bother if send buffer is too full to respond anyway
6192         if (pfrom->nSendSize >= SendBufferSize())
6193             break;
6194
6195         const CInv &inv = *it;
6196         {
6197             boost::this_thread::interruption_point();
6198             it++;
6199
6200             if (inv.type == MSG_BLOCK || inv.type == MSG_FILTERED_BLOCK)
6201             {
6202                 bool send = false;
6203                 BlockMap::iterator mi = mapBlockIndex.find(inv.hash);
6204                 if (mi != mapBlockIndex.end())
6205                 {
6206                     if (chainActive.Contains(mi->second)) {
6207                         send = true;
6208                     } else {
6209                         static const int nOneMonth = 30 * 24 * 60 * 60;
6210                         // To prevent fingerprinting attacks, only send blocks outside of the active
6211                         // chain if they are valid, and no more than a month older (both in time, and in
6212                         // best equivalent proof of work) than the best header chain we know about.
6213                         send = mi->second->IsValid(BLOCK_VALID_SCRIPTS) && (pindexBestHeader != NULL) &&
6214                         (pindexBestHeader->GetBlockTime() - mi->second->GetBlockTime() < nOneMonth) &&
6215                         (GetBlockProofEquivalentTime(*pindexBestHeader, *mi->second, *pindexBestHeader, Params().GetConsensus()) < nOneMonth);
6216                         if (!send) {
6217                             LogPrintf("%s: ignoring request from peer=%i for old block that isn't in the main chain\n", __func__, pfrom->GetId());
6218                         }
6219                     }
6220                 }
6221                 // Pruned nodes may have deleted the block, so check whether
6222                 // it's available before trying to send.
6223                 if (send && (mi->second->nStatus & BLOCK_HAVE_DATA))
6224                 {
6225                     // Send block from disk
6226                     CBlock block;
6227                     if (!ReadBlockFromDisk(block, (*mi).second,1))
6228                     {
6229                         assert(!"cannot load block from disk");
6230                     }
6231                     else
6232                     {
6233                         if (inv.type == MSG_BLOCK)
6234                         {
6235                             //uint256 hash; int32_t z;
6236                             //hash = block.GetHash();
6237                             //for (z=31; z>=0; z--)
6238                             //    fprintf(stderr,"%02x",((uint8_t *)&hash)[z]);
6239                             //fprintf(stderr," send block %d\n",komodo_block2height(&block));
6240                             pfrom->PushMessage("block", block);
6241                         }
6242                         else // MSG_FILTERED_BLOCK)
6243                         {
6244                             LOCK(pfrom->cs_filter);
6245                             if (pfrom->pfilter)
6246                             {
6247                                 CMerkleBlock merkleBlock(block, *pfrom->pfilter);
6248                                 pfrom->PushMessage("merkleblock", merkleBlock);
6249                                 // CMerkleBlock just contains hashes, so also push any transactions in the block the client did not see
6250                                 // This avoids hurting performance by pointlessly requiring a round-trip
6251                                 // Note that there is currently no way for a node to request any single transactions we didn't send here -
6252                                 // they must either disconnect and retry or request the full block.
6253                                 // Thus, the protocol spec specified allows for us to provide duplicate txn here,
6254                                 // however we MUST always provide at least what the remote peer needs
6255                                 typedef std::pair<unsigned int, uint256> PairType;
6256                                 BOOST_FOREACH(PairType& pair, merkleBlock.vMatchedTxn)
6257                                 if (!pfrom->setInventoryKnown.count(CInv(MSG_TX, pair.second)))
6258                                     pfrom->PushMessage("tx", block.vtx[pair.first]);
6259                             }
6260                             // else
6261                             // no response
6262                         }
6263                     }
6264                     // Trigger the peer node to send a getblocks request for the next batch of inventory
6265                     if (inv.hash == pfrom->hashContinue)
6266                     {
6267                         // Bypass PushInventory, this must send even if redundant,
6268                         // and we want it right after the last block so they don't
6269                         // wait for other stuff first.
6270                         vector<CInv> vInv;
6271                         vInv.push_back(CInv(MSG_BLOCK, chainActive.Tip()->GetBlockHash()));
6272                         pfrom->PushMessage("inv", vInv);
6273                         pfrom->hashContinue.SetNull();
6274                     }
6275                 }
6276             }
6277             else if (inv.IsKnownType())
6278             {
6279                 // Send stream from relay memory
6280                 bool pushed = false;
6281                 {
6282                     LOCK(cs_mapRelay);
6283                     map<CInv, CDataStream>::iterator mi = mapRelay.find(inv);
6284                     if (mi != mapRelay.end()) {
6285                         pfrom->PushMessage(inv.GetCommand(), (*mi).second);
6286                         pushed = true;
6287                     }
6288                 }
6289                 if (!pushed && inv.type == MSG_TX) {
6290                     CTransaction tx;
6291                     if (mempool.lookup(inv.hash, tx)) {
6292                         CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
6293                         ss.reserve(1000);
6294                         ss << tx;
6295                         pfrom->PushMessage("tx", ss);
6296                         pushed = true;
6297                     }
6298                 }
6299                 if (!pushed) {
6300                     vNotFound.push_back(inv);
6301                 }
6302             }
6303
6304             // Track requests for our stuff.
6305             GetMainSignals().Inventory(inv.hash);
6306
6307             if (inv.type == MSG_BLOCK || inv.type == MSG_FILTERED_BLOCK)
6308                 break;
6309         }
6310     }
6311
6312     pfrom->vRecvGetData.erase(pfrom->vRecvGetData.begin(), it);
6313
6314     if (!vNotFound.empty()) {
6315         // Let the peer know that we didn't find what it asked for, so it doesn't
6316         // have to wait around forever. Currently only SPV clients actually care
6317         // about this message: it's needed when they are recursively walking the
6318         // dependencies of relevant unconfirmed transactions. SPV clients want to
6319         // do that because they want to know about (and store and rebroadcast and
6320         // risk analyze) the dependencies of transactions relevant to them, without
6321         // having to download the entire memory pool.
6322         pfrom->PushMessage("notfound", vNotFound);
6323     }
6324 }
6325
6326 bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv, int64_t nTimeReceived)
6327 {
6328     const CChainParams& chainparams = Params();
6329     LogPrint("net", "received: %s (%u bytes) peer=%d\n", SanitizeString(strCommand), vRecv.size(), pfrom->id);
6330     //fprintf(stderr, "recv: %s peer=%d\n", SanitizeString(strCommand).c_str(), (int32_t)pfrom->GetId());
6331     if (mapArgs.count("-dropmessagestest") && GetRand(atoi(mapArgs["-dropmessagestest"])) == 0)
6332     {
6333         LogPrintf("dropmessagestest DROPPING RECV MESSAGE\n");
6334         return true;
6335     }
6336
6337     if (strCommand == "version")
6338     {
6339         // Each connection can only send one version message
6340         if (pfrom->nVersion != 0)
6341         {
6342             pfrom->PushMessage("reject", strCommand, REJECT_DUPLICATE, string("Duplicate version message"));
6343             Misbehaving(pfrom->GetId(), 1);
6344             return false;
6345         }
6346
6347         int64_t nTime;
6348         CAddress addrMe;
6349         CAddress addrFrom;
6350         uint64_t nNonce = 1;
6351         int nVersion;           // use temporary for version, don't set version number until validated as connected
6352         vRecv >> nVersion >> pfrom->nServices >> nTime >> addrMe;
6353         if (nVersion == 10300)
6354             nVersion = 300;
6355
6356         if (nVersion < MIN_PEER_PROTO_VERSION)
6357         {
6358             // disconnect from peers older than this proto version
6359             LogPrintf("peer=%d using obsolete version %i; disconnecting\n", pfrom->id, pfrom->nVersion);
6360             pfrom->PushMessage("reject", strCommand, REJECT_OBSOLETE,
6361                                strprintf("Version must be %d or greater", MIN_PEER_PROTO_VERSION));
6362             pfrom->fDisconnect = true;
6363             return false;
6364         }
6365
6366         // Reject incoming connections from nodes that don't know about the current epoch
6367         const Consensus::Params& params = Params().GetConsensus();
6368         auto currentEpoch = CurrentEpoch(GetHeight(), params);
6369         if (nVersion < params.vUpgrades[currentEpoch].nProtocolVersion)
6370         {
6371             LogPrintf("peer=%d using obsolete version %i; disconnecting\n", pfrom->id, nVersion);
6372             pfrom->PushMessage("reject", strCommand, REJECT_OBSOLETE,
6373                             strprintf("Version must be %d or greater",
6374                             params.vUpgrades[currentEpoch].nProtocolVersion));
6375             pfrom->fDisconnect = true;
6376             return false;
6377         }
6378
6379         if (!vRecv.empty())
6380             vRecv >> addrFrom >> nNonce;
6381         if (!vRecv.empty()) {
6382             vRecv >> LIMITED_STRING(pfrom->strSubVer, MAX_SUBVERSION_LENGTH);
6383             pfrom->cleanSubVer = SanitizeString(pfrom->strSubVer);
6384         }
6385         if (!vRecv.empty())
6386             vRecv >> pfrom->nStartingHeight;
6387         if (!vRecv.empty())
6388             vRecv >> pfrom->fRelayTxes; // set to true after we get the first filter* message
6389         else
6390             pfrom->fRelayTxes = true;
6391
6392         // Disconnect if we connected to ourself
6393         if (nNonce == nLocalHostNonce && nNonce > 1)
6394         {
6395             LogPrintf("connected to self at %s, disconnecting\n", pfrom->addr.ToString());
6396             pfrom->fDisconnect = true;
6397             return true;
6398         }
6399
6400         pfrom->nVersion = nVersion;
6401
6402         pfrom->addrLocal = addrMe;
6403         if (pfrom->fInbound && addrMe.IsRoutable())
6404         {
6405             SeenLocal(addrMe);
6406         }
6407
6408         // Be shy and don't send version until we hear
6409         if (pfrom->fInbound)
6410             pfrom->PushVersion();
6411
6412         pfrom->fClient = !(pfrom->nServices & NODE_NETWORK);
6413
6414         // Potentially mark this peer as a preferred download peer.
6415         UpdatePreferredDownload(pfrom, State(pfrom->GetId()));
6416
6417         // Change version
6418         pfrom->PushMessage("verack");
6419         pfrom->ssSend.SetVersion(min(pfrom->nVersion, PROTOCOL_VERSION));
6420
6421         if (!pfrom->fInbound)
6422         {
6423             // Advertise our address
6424             if (fListen && !IsInitialBlockDownload())
6425             {
6426                 CAddress addr = GetLocalAddress(&pfrom->addr);
6427                 if (addr.IsRoutable())
6428                 {
6429                     LogPrintf("ProcessMessages: advertizing address %s\n", addr.ToString());
6430                     pfrom->PushAddress(addr);
6431                 } else if (IsPeerAddrLocalGood(pfrom)) {
6432                     addr.SetIP(pfrom->addrLocal);
6433                     LogPrintf("ProcessMessages: advertizing address %s\n", addr.ToString());
6434                     pfrom->PushAddress(addr);
6435                 }
6436             }
6437
6438             // Get recent addresses
6439             if (pfrom->fOneShot || pfrom->nVersion >= CADDR_TIME_VERSION || addrman.size() < 1000)
6440             {
6441                 pfrom->PushMessage("getaddr");
6442                 pfrom->fGetAddr = true;
6443             }
6444             addrman.Good(pfrom->addr);
6445         } else {
6446             if (((CNetAddr)pfrom->addr) == (CNetAddr)addrFrom)
6447             {
6448                 addrman.Add(addrFrom, addrFrom);
6449                 addrman.Good(addrFrom);
6450             }
6451         }
6452
6453         // Relay alerts
6454         {
6455             LOCK(cs_mapAlerts);
6456             BOOST_FOREACH(PAIRTYPE(const uint256, CAlert)& item, mapAlerts)
6457             item.second.RelayTo(pfrom);
6458         }
6459
6460         pfrom->fSuccessfullyConnected = true;
6461
6462         string remoteAddr;
6463         if (fLogIPs)
6464             remoteAddr = ", peeraddr=" + pfrom->addr.ToString();
6465
6466         LogPrintf("receive version message: %s: version %d, blocks=%d, us=%s, peer=%d%s\n",
6467                   pfrom->cleanSubVer, pfrom->nVersion,
6468                   pfrom->nStartingHeight, addrMe.ToString(), pfrom->id,
6469                   remoteAddr);
6470
6471         int64_t nTimeOffset = nTime - GetTime();
6472         pfrom->nTimeOffset = nTimeOffset;
6473         AddTimeData(pfrom->addr, nTimeOffset);
6474     }
6475
6476
6477     else if (pfrom->nVersion == 0)
6478     {
6479         // Must have a version message before anything else
6480         Misbehaving(pfrom->GetId(), 1);
6481         return false;
6482     }
6483
6484
6485     else if (strCommand == "verack")
6486     {
6487         pfrom->SetRecvVersion(min(pfrom->nVersion, PROTOCOL_VERSION));
6488
6489         // Mark this node as currently connected, so we update its timestamp later.
6490         if (pfrom->fNetworkNode) {
6491             LOCK(cs_main);
6492             State(pfrom->GetId())->fCurrentlyConnected = true;
6493         }
6494     }
6495
6496
6497     // Disconnect existing peer connection when:
6498     // 1. The version message has been received
6499     // 2. Peer version is below the minimum version for the current epoch
6500     else if (pfrom->nVersion < chainparams.GetConsensus().vUpgrades[
6501         CurrentEpoch(GetHeight(), chainparams.GetConsensus())].nProtocolVersion)
6502     {
6503         LogPrintf("peer=%d using obsolete version %i; disconnecting\n", pfrom->id, pfrom->nVersion);
6504         pfrom->PushMessage("reject", strCommand, REJECT_OBSOLETE,
6505                             strprintf("Version must be %d or greater",
6506                             chainparams.GetConsensus().vUpgrades[
6507                                 CurrentEpoch(GetHeight(), chainparams.GetConsensus())].nProtocolVersion));
6508         pfrom->fDisconnect = true;
6509         return false;
6510     }
6511
6512
6513     else if (strCommand == "addr")
6514     {
6515         vector<CAddress> vAddr;
6516         vRecv >> vAddr;
6517
6518         // Don't want addr from older versions unless seeding
6519         if (pfrom->nVersion < CADDR_TIME_VERSION && addrman.size() > 1000)
6520             return true;
6521         if (vAddr.size() > 1000)
6522         {
6523             Misbehaving(pfrom->GetId(), 20);
6524             return error("message addr size() = %u", vAddr.size());
6525         }
6526
6527         // Store the new addresses
6528         vector<CAddress> vAddrOk;
6529         int64_t nNow = GetAdjustedTime();
6530         int64_t nSince = nNow - 10 * 60;
6531         BOOST_FOREACH(CAddress& addr, vAddr)
6532         {
6533             boost::this_thread::interruption_point();
6534
6535             if (addr.nTime <= 100000000 || addr.nTime > nNow + 10 * 60)
6536                 addr.nTime = nNow - 5 * 24 * 60 * 60;
6537             pfrom->AddAddressKnown(addr);
6538             bool fReachable = IsReachable(addr);
6539             if (addr.nTime > nSince && !pfrom->fGetAddr && vAddr.size() <= 10 && addr.IsRoutable())
6540             {
6541                 // Relay to a limited number of other nodes
6542                 {
6543                     LOCK(cs_vNodes);
6544                     // Use deterministic randomness to send to the same nodes for 24 hours
6545                     // at a time so the addrKnowns of the chosen nodes prevent repeats
6546                     static uint256 hashSalt;
6547                     if (hashSalt.IsNull())
6548                         hashSalt = GetRandHash();
6549                     uint64_t hashAddr = addr.GetHash();
6550                     uint256 hashRand = ArithToUint256(UintToArith256(hashSalt) ^ (hashAddr<<32) ^ ((GetTime()+hashAddr)/(24*60*60)));
6551                     hashRand = Hash(BEGIN(hashRand), END(hashRand));
6552                     multimap<uint256, CNode*> mapMix;
6553                     BOOST_FOREACH(CNode* pnode, vNodes)
6554                     {
6555                         if (pnode->nVersion < CADDR_TIME_VERSION)
6556                             continue;
6557                         unsigned int nPointer;
6558                         memcpy(&nPointer, &pnode, sizeof(nPointer));
6559                         uint256 hashKey = ArithToUint256(UintToArith256(hashRand) ^ nPointer);
6560                         hashKey = Hash(BEGIN(hashKey), END(hashKey));
6561                         mapMix.insert(make_pair(hashKey, pnode));
6562                     }
6563                     int nRelayNodes = fReachable ? 2 : 1; // limited relaying of addresses outside our network(s)
6564                     for (multimap<uint256, CNode*>::iterator mi = mapMix.begin(); mi != mapMix.end() && nRelayNodes-- > 0; ++mi)
6565                         ((*mi).second)->PushAddress(addr);
6566                 }
6567             }
6568             // Do not store addresses outside our network
6569             if (fReachable)
6570                 vAddrOk.push_back(addr);
6571         }
6572         addrman.Add(vAddrOk, pfrom->addr, 2 * 60 * 60);
6573         if (vAddr.size() < 1000)
6574             pfrom->fGetAddr = false;
6575         if (pfrom->fOneShot)
6576             pfrom->fDisconnect = true;
6577     }
6578
6579
6580     else if (strCommand == "inv")
6581     {
6582         vector<CInv> vInv;
6583         vRecv >> vInv;
6584         if (vInv.size() > MAX_INV_SZ)
6585         {
6586             Misbehaving(pfrom->GetId(), 20);
6587             return error("message inv size() = %u", vInv.size());
6588         }
6589
6590         LOCK(cs_main);
6591
6592         std::vector<CInv> vToFetch;
6593
6594         for (unsigned int nInv = 0; nInv < vInv.size(); nInv++)
6595         {
6596             const CInv &inv = vInv[nInv];
6597
6598             boost::this_thread::interruption_point();
6599             pfrom->AddInventoryKnown(inv);
6600
6601             bool fAlreadyHave = AlreadyHave(inv);
6602             LogPrint("net", "got inv: %s  %s peer=%d\n", inv.ToString(), fAlreadyHave ? "have" : "new", pfrom->id);
6603
6604             if (!fAlreadyHave && !fImporting && !fReindex && inv.type != MSG_BLOCK)
6605                 pfrom->AskFor(inv);
6606
6607             if (inv.type == MSG_BLOCK) {
6608                 UpdateBlockAvailability(pfrom->GetId(), inv.hash);
6609                 if (!fAlreadyHave && !fImporting && !fReindex && !mapBlocksInFlight.count(inv.hash)) {
6610                     // First request the headers preceding the announced block. In the normal fully-synced
6611                     // case where a new block is announced that succeeds the current tip (no reorganization),
6612                     // there are no such headers.
6613                     // Secondly, and only when we are close to being synced, we request the announced block directly,
6614                     // to avoid an extra round-trip. Note that we must *first* ask for the headers, so by the
6615                     // time the block arrives, the header chain leading up to it is already validated. Not
6616                     // doing this will result in the received block being rejected as an orphan in case it is
6617                     // not a direct successor.
6618                     pfrom->PushMessage("getheaders", chainActive.GetLocator(pindexBestHeader), inv.hash);
6619                     CNodeState *nodestate = State(pfrom->GetId());
6620                     if (chainActive.Tip()->GetBlockTime() > GetAdjustedTime() - chainparams.GetConsensus().nPowTargetSpacing * 20 &&
6621                         nodestate->nBlocksInFlight < MAX_BLOCKS_IN_TRANSIT_PER_PEER) {
6622                         vToFetch.push_back(inv);
6623                         // Mark block as in flight already, even though the actual "getdata" message only goes out
6624                         // later (within the same cs_main lock, though).
6625                         MarkBlockAsInFlight(pfrom->GetId(), inv.hash, chainparams.GetConsensus());
6626                     }
6627                     LogPrint("net", "getheaders (%d) %s to peer=%d\n", pindexBestHeader->GetHeight(), inv.hash.ToString(), pfrom->id);
6628                 }
6629             }
6630
6631             // Track requests for our stuff
6632             GetMainSignals().Inventory(inv.hash);
6633
6634             if (pfrom->nSendSize > (SendBufferSize() * 2)) {
6635                 Misbehaving(pfrom->GetId(), 50);
6636                 return error("send buffer size() = %u", pfrom->nSendSize);
6637             }
6638         }
6639
6640         if (!vToFetch.empty())
6641             pfrom->PushMessage("getdata", vToFetch);
6642     }
6643
6644
6645     else if (strCommand == "getdata")
6646     {
6647         vector<CInv> vInv;
6648         vRecv >> vInv;
6649         if (vInv.size() > MAX_INV_SZ)
6650         {
6651             Misbehaving(pfrom->GetId(), 20);
6652             return error("message getdata size() = %u", vInv.size());
6653         }
6654
6655         if (fDebug || (vInv.size() != 1))
6656             LogPrint("net", "received getdata (%u invsz) peer=%d\n", vInv.size(), pfrom->id);
6657
6658         if ((fDebug && vInv.size() > 0) || (vInv.size() == 1))
6659             LogPrint("net", "received getdata for: %s peer=%d\n", vInv[0].ToString(), pfrom->id);
6660
6661         pfrom->vRecvGetData.insert(pfrom->vRecvGetData.end(), vInv.begin(), vInv.end());
6662         ProcessGetData(pfrom);
6663     }
6664
6665
6666     else if (strCommand == "getblocks")
6667     {
6668         CBlockLocator locator;
6669         uint256 hashStop;
6670         vRecv >> locator >> hashStop;
6671
6672         LOCK(cs_main);
6673
6674         // Find the last block the caller has in the main chain
6675         CBlockIndex* pindex = FindForkInGlobalIndex(chainActive, locator);
6676
6677         // Send the rest of the chain
6678         if (pindex)
6679             pindex = chainActive.Next(pindex);
6680         int nLimit = 500;
6681         LogPrint("net", "getblocks %d to %s limit %d from peer=%d\n", (pindex ? pindex->GetHeight() : -1), hashStop.IsNull() ? "end" : hashStop.ToString(), nLimit, pfrom->id);
6682         for (; pindex; pindex = chainActive.Next(pindex))
6683         {
6684             if (pindex->GetBlockHash() == hashStop)
6685             {
6686                 LogPrint("net", "  getblocks stopping at %d %s\n", pindex->GetHeight(), pindex->GetBlockHash().ToString());
6687                 break;
6688             }
6689             pfrom->PushInventory(CInv(MSG_BLOCK, pindex->GetBlockHash()));
6690             if (--nLimit <= 0)
6691             {
6692                 // When this block is requested, we'll send an inv that'll
6693                 // trigger the peer to getblocks the next batch of inventory.
6694                 LogPrint("net", "  getblocks stopping at limit %d %s\n", pindex->GetHeight(), pindex->GetBlockHash().ToString());
6695                 pfrom->hashContinue = pindex->GetBlockHash();
6696                 break;
6697             }
6698         }
6699     }
6700
6701
6702     else if (strCommand == "getheaders")
6703     {
6704         CBlockLocator locator;
6705         uint256 hashStop;
6706         vRecv >> locator >> hashStop;
6707
6708         LOCK(cs_main);
6709
6710         if (IsInitialBlockDownload())
6711             return true;
6712
6713         CBlockIndex* pindex = NULL;
6714         if (locator.IsNull())
6715         {
6716             // If locator is null, return the hashStop block
6717             BlockMap::iterator mi = mapBlockIndex.find(hashStop);
6718             if (mi == mapBlockIndex.end())
6719                 return true;
6720             pindex = (*mi).second;
6721         }
6722         else
6723         {
6724             // Find the last block the caller has in the main chain
6725             pindex = FindForkInGlobalIndex(chainActive, locator);
6726             if (pindex)
6727                 pindex = chainActive.Next(pindex);
6728         }
6729
6730         // we must use CNetworkBlockHeader, as CBlockHeader won't include the 0x00 nTx count at the end for compatibility
6731         vector<CNetworkBlockHeader> vHeaders;
6732         int nLimit = MAX_HEADERS_RESULTS;
6733         LogPrint("net", "getheaders %d to %s from peer=%d\n", (pindex ? pindex->GetHeight() : -1), hashStop.ToString(), pfrom->id);
6734         //if ( pfrom->lasthdrsreq >= chainActive.Height()-MAX_HEADERS_RESULTS || pfrom->lasthdrsreq != (int32_t)(pindex ? pindex->GetHeight() : -1) )// no need to ever suppress this
6735         {
6736             pfrom->lasthdrsreq = (int32_t)(pindex ? pindex->GetHeight() : -1);
6737             for (; pindex; pindex = chainActive.Next(pindex))
6738             {
6739                 CBlockHeader h = pindex->GetBlockHeader();
6740                 //printf("size.%i, solution size.%i\n", (int)sizeof(h), (int)h.nSolution.size());
6741                 //printf("hash.%s prevhash.%s nonce.%s\n", h.GetHash().ToString().c_str(), h.hashPrevBlock.ToString().c_str(), h.nNonce.ToString().c_str());
6742                 vHeaders.push_back(pindex->GetBlockHeader());
6743                 if (--nLimit <= 0 || pindex->GetBlockHash() == hashStop)
6744                     break;
6745             }
6746             pfrom->PushMessage("headers", vHeaders);
6747         }
6748         /*else if ( IS_KOMODO_NOTARY != 0 )
6749         {
6750             static uint32_t counter;
6751             if ( counter++ < 3 )
6752                 fprintf(stderr,"you can ignore redundant getheaders from peer.%d %d prev.%d\n",(int32_t)pfrom->id,(int32_t)(pindex ? pindex->GetHeight() : -1),pfrom->lasthdrsreq);
6753         }*/
6754     }
6755
6756
6757     else if (strCommand == "tx")
6758     {
6759         vector<uint256> vWorkQueue;
6760         vector<uint256> vEraseQueue;
6761         CTransaction tx;
6762         vRecv >> tx;
6763
6764         CInv inv(MSG_TX, tx.GetHash());
6765         pfrom->AddInventoryKnown(inv);
6766
6767         LOCK(cs_main);
6768
6769         bool fMissingInputs = false;
6770         CValidationState state;
6771
6772         pfrom->setAskFor.erase(inv.hash);
6773         mapAlreadyAskedFor.erase(inv);
6774
6775         if (!AlreadyHave(inv) && AcceptToMemoryPool(mempool, state, tx, true, &fMissingInputs))
6776         {
6777             mempool.check(pcoinsTip);
6778             RelayTransaction(tx);
6779             vWorkQueue.push_back(inv.hash);
6780
6781             LogPrint("mempool", "AcceptToMemoryPool: peer=%d %s: accepted %s (poolsz %u)\n",
6782                      pfrom->id, pfrom->cleanSubVer,
6783                      tx.GetHash().ToString(),
6784                      mempool.mapTx.size());
6785
6786             // Recursively process any orphan transactions that depended on this one
6787             set<NodeId> setMisbehaving;
6788             for (unsigned int i = 0; i < vWorkQueue.size(); i++)
6789             {
6790                 map<uint256, set<uint256> >::iterator itByPrev = mapOrphanTransactionsByPrev.find(vWorkQueue[i]);
6791                 if (itByPrev == mapOrphanTransactionsByPrev.end())
6792                     continue;
6793                 for (set<uint256>::iterator mi = itByPrev->second.begin();
6794                      mi != itByPrev->second.end();
6795                      ++mi)
6796                 {
6797                     const uint256& orphanHash = *mi;
6798                     const CTransaction& orphanTx = mapOrphanTransactions[orphanHash].tx;
6799                     NodeId fromPeer = mapOrphanTransactions[orphanHash].fromPeer;
6800                     bool fMissingInputs2 = false;
6801                     // Use a dummy CValidationState so someone can't setup nodes to counter-DoS based on orphan
6802                     // resolution (that is, feeding people an invalid transaction based on LegitTxX in order to get
6803                     // anyone relaying LegitTxX banned)
6804                     CValidationState stateDummy;
6805
6806
6807                     if (setMisbehaving.count(fromPeer))
6808                         continue;
6809                     if (AcceptToMemoryPool(mempool, stateDummy, orphanTx, true, &fMissingInputs2))
6810                     {
6811                         LogPrint("mempool", "   accepted orphan tx %s\n", orphanHash.ToString());
6812                         RelayTransaction(orphanTx);
6813                         vWorkQueue.push_back(orphanHash);
6814                         vEraseQueue.push_back(orphanHash);
6815                     }
6816                     else if (!fMissingInputs2)
6817                     {
6818                         int nDos = 0;
6819                         if (stateDummy.IsInvalid(nDos) && nDos > 0)
6820                         {
6821                             // Punish peer that gave us an invalid orphan tx
6822                             Misbehaving(fromPeer, nDos);
6823                             setMisbehaving.insert(fromPeer);
6824                             LogPrint("mempool", "   invalid orphan tx %s\n", orphanHash.ToString());
6825                         }
6826                         // Has inputs but not accepted to mempool
6827                         // Probably non-standard or insufficient fee/priority
6828                         LogPrint("mempool", "   removed orphan tx %s\n", orphanHash.ToString());
6829                         vEraseQueue.push_back(orphanHash);
6830                         assert(recentRejects);
6831                         recentRejects->insert(orphanHash);
6832                     }
6833                     mempool.check(pcoinsTip);
6834                 }
6835             }
6836
6837             BOOST_FOREACH(uint256 hash, vEraseQueue)
6838             EraseOrphanTx(hash);
6839         }
6840         // TODO: currently, prohibit joinsplits and shielded spends/outputs from entering mapOrphans
6841         else if (fMissingInputs &&
6842                  tx.vjoinsplit.empty() &&
6843                  tx.vShieldedSpend.empty() &&
6844                  tx.vShieldedOutput.empty())
6845         {
6846             AddOrphanTx(tx, pfrom->GetId());
6847
6848             // DoS prevention: do not allow mapOrphanTransactions to grow unbounded
6849             unsigned int nMaxOrphanTx = (unsigned int)std::max((int64_t)0, GetArg("-maxorphantx", DEFAULT_MAX_ORPHAN_TRANSACTIONS));
6850             unsigned int nEvicted = LimitOrphanTxSize(nMaxOrphanTx);
6851             if (nEvicted > 0)
6852                 LogPrint("mempool", "mapOrphan overflow, removed %u tx\n", nEvicted);
6853         } else {
6854             assert(recentRejects);
6855             recentRejects->insert(tx.GetHash());
6856
6857             if (pfrom->fWhitelisted) {
6858                 // Always relay transactions received from whitelisted peers, even
6859                 // if they were already in the mempool or rejected from it due
6860                 // to policy, allowing the node to function as a gateway for
6861                 // nodes hidden behind it.
6862                 //
6863                 // Never relay transactions that we would assign a non-zero DoS
6864                 // score for, as we expect peers to do the same with us in that
6865                 // case.
6866                 int nDoS = 0;
6867                 if (!state.IsInvalid(nDoS) || nDoS == 0) {
6868                     LogPrintf("Force relaying tx %s from whitelisted peer=%d\n", tx.GetHash().ToString(), pfrom->id);
6869                     RelayTransaction(tx);
6870                 } else {
6871                     LogPrintf("Not relaying invalid transaction %s from whitelisted peer=%d (%s (code %d))\n",
6872                               tx.GetHash().ToString(), pfrom->id, state.GetRejectReason(), state.GetRejectCode());
6873                 }
6874             }
6875         }
6876         int nDoS = 0;
6877         if (state.IsInvalid(nDoS))
6878         {
6879             LogPrint("mempool", "%s from peer=%d %s was not accepted into the memory pool: %s\n", tx.GetHash().ToString(),
6880                      pfrom->id, pfrom->cleanSubVer,
6881                      state.GetRejectReason());
6882             pfrom->PushMessage("reject", strCommand, state.GetRejectCode(),
6883                                state.GetRejectReason().substr(0, MAX_REJECT_MESSAGE_LENGTH), inv.hash);
6884             if (nDoS > 0)
6885                 Misbehaving(pfrom->GetId(), nDoS);
6886         }
6887     }
6888
6889     else if (strCommand == "headers" && !fImporting && !fReindex) // Ignore headers received while importing
6890     {
6891         std::vector<CBlockHeader> headers;
6892
6893         // Bypass the normal CBlock deserialization, as we don't want to risk deserializing 2000 full blocks.
6894         unsigned int nCount = ReadCompactSize(vRecv);
6895         if (nCount > MAX_HEADERS_RESULTS) {
6896             Misbehaving(pfrom->GetId(), 20);
6897             return error("headers message size = %u", nCount);
6898         }
6899         headers.resize(nCount);
6900         for (unsigned int n = 0; n < nCount; n++) {
6901             vRecv >> headers[n];
6902             ReadCompactSize(vRecv); // ignore tx count; assume it is 0.
6903         }
6904
6905         LOCK(cs_main);
6906
6907         if (nCount == 0) {
6908             // Nothing interesting. Stop asking this peers for more headers.
6909             return true;
6910         }
6911
6912         CBlockIndex *pindexLast = NULL;
6913         BOOST_FOREACH(const CBlockHeader& header, headers) {
6914             //printf("size.%i, solution size.%i\n", (int)sizeof(header), (int)header.nSolution.size());
6915             //printf("hash.%s prevhash.%s nonce.%s\n", header.GetHash().ToString().c_str(), header.hashPrevBlock.ToString().c_str(), header.nNonce.ToString().c_str());
6916
6917             CValidationState state;
6918             if (pindexLast != NULL && header.hashPrevBlock != pindexLast->GetBlockHash()) {
6919                 Misbehaving(pfrom->GetId(), 20);
6920                 return error("non-continuous headers sequence");
6921             }
6922             int32_t futureblock;
6923             if (!AcceptBlockHeader(&futureblock,header, state, &pindexLast)) {
6924                 int nDoS;
6925                 if (state.IsInvalid(nDoS) && futureblock == 0)
6926                 {
6927                     if (nDoS > 0 && futureblock == 0)
6928                         Misbehaving(pfrom->GetId(), nDoS/nDoS);
6929                     return error("invalid header received");
6930                 }
6931             }
6932         }
6933
6934         if (pindexLast)
6935             UpdateBlockAvailability(pfrom->GetId(), pindexLast->GetBlockHash());
6936
6937         if (nCount == MAX_HEADERS_RESULTS && pindexLast) {
6938             // Headers message had its maximum size; the peer may have more headers.
6939             // TODO: optimize: if pindexLast is an ancestor of chainActive.Tip or pindexBestHeader, continue
6940             // from there instead.
6941             if ( pfrom->sendhdrsreq >= chainActive.Height()-MAX_HEADERS_RESULTS || pindexLast->GetHeight() != pfrom->sendhdrsreq )
6942             {
6943                 pfrom->sendhdrsreq = (int32_t)pindexLast->GetHeight();
6944                 LogPrint("net", "more getheaders (%d) to end to peer=%d (startheight:%d)\n", pindexLast->GetHeight(), pfrom->id, pfrom->nStartingHeight);
6945                 pfrom->PushMessage("getheaders", chainActive.GetLocator(pindexLast), uint256());
6946             }
6947         }
6948
6949         CheckBlockIndex();
6950     }
6951
6952     else if (strCommand == "block" && !fImporting && !fReindex) // Ignore blocks received while importing
6953     {
6954         CBlock block;
6955         vRecv >> block;
6956
6957         CInv inv(MSG_BLOCK, block.GetHash());
6958         LogPrint("net", "received block %s peer=%d\n", inv.hash.ToString(), pfrom->id);
6959
6960         pfrom->AddInventoryKnown(inv);
6961
6962         CValidationState state;
6963         // Process all blocks from whitelisted peers, even if not requested,
6964         // unless we're still syncing with the network.
6965         // Such an unrequested block may still be processed, subject to the
6966         // conditions in AcceptBlock().
6967         bool forceProcessing = pfrom->fWhitelisted && !IsInitialBlockDownload();
6968         ProcessNewBlock(0,0,state, pfrom, &block, forceProcessing, NULL);
6969         int nDoS;
6970         if (state.IsInvalid(nDoS)) {
6971             pfrom->PushMessage("reject", strCommand, state.GetRejectCode(),
6972                                state.GetRejectReason().substr(0, MAX_REJECT_MESSAGE_LENGTH), inv.hash);
6973             if (nDoS > 0) {
6974                 LOCK(cs_main);
6975                 Misbehaving(pfrom->GetId(), nDoS);
6976             }
6977         }
6978
6979     }
6980
6981
6982     // This asymmetric behavior for inbound and outbound connections was introduced
6983     // to prevent a fingerprinting attack: an attacker can send specific fake addresses
6984     // to users' AddrMan and later request them by sending getaddr messages.
6985     // Making nodes which are behind NAT and can only make outgoing connections ignore
6986     // the getaddr message mitigates the attack.
6987     else if ((strCommand == "getaddr") && (pfrom->fInbound))
6988     {
6989         // Only send one GetAddr response per connection to reduce resource waste
6990         //  and discourage addr stamping of INV announcements.
6991         if (pfrom->fSentAddr) {
6992             LogPrint("net", "Ignoring repeated \"getaddr\". peer=%d\n", pfrom->id);
6993             return true;
6994         }
6995         pfrom->fSentAddr = true;
6996
6997         pfrom->vAddrToSend.clear();
6998         vector<CAddress> vAddr = addrman.GetAddr();
6999         BOOST_FOREACH(const CAddress &addr, vAddr)
7000         pfrom->PushAddress(addr);
7001     }
7002
7003
7004     else if (strCommand == "mempool")
7005     {
7006         LOCK2(cs_main, pfrom->cs_filter);
7007
7008         std::vector<uint256> vtxid;
7009         mempool.queryHashes(vtxid);
7010         vector<CInv> vInv;
7011         BOOST_FOREACH(uint256& hash, vtxid) {
7012             CInv inv(MSG_TX, hash);
7013             if (pfrom->pfilter) {
7014                 CTransaction tx;
7015                 bool fInMemPool = mempool.lookup(hash, tx);
7016                 if (!fInMemPool) continue; // another thread removed since queryHashes, maybe...
7017                 if (!pfrom->pfilter->IsRelevantAndUpdate(tx)) continue;
7018             }
7019             vInv.push_back(inv);
7020             if (vInv.size() == MAX_INV_SZ) {
7021                 pfrom->PushMessage("inv", vInv);
7022                 vInv.clear();
7023             }
7024         }
7025         if (vInv.size() > 0)
7026             pfrom->PushMessage("inv", vInv);
7027     }
7028
7029
7030     else if (strCommand == "ping")
7031     {
7032         if (pfrom->nVersion > BIP0031_VERSION)
7033         {
7034             uint64_t nonce = 0;
7035             vRecv >> nonce;
7036             // Echo the message back with the nonce. This allows for two useful features:
7037             //
7038             // 1) A remote node can quickly check if the connection is operational
7039             // 2) Remote nodes can measure the latency of the network thread. If this node
7040             //    is overloaded it won't respond to pings quickly and the remote node can
7041             //    avoid sending us more work, like chain download requests.
7042             //
7043             // The nonce stops the remote getting confused between different pings: without
7044             // it, if the remote node sends a ping once per second and this node takes 5
7045             // seconds to respond to each, the 5th ping the remote sends would appear to
7046             // return very quickly.
7047             pfrom->PushMessage("pong", nonce);
7048         }
7049     }
7050
7051
7052     else if (strCommand == "pong")
7053     {
7054         int64_t pingUsecEnd = nTimeReceived;
7055         uint64_t nonce = 0;
7056         size_t nAvail = vRecv.in_avail();
7057         bool bPingFinished = false;
7058         std::string sProblem;
7059
7060         if (nAvail >= sizeof(nonce)) {
7061             vRecv >> nonce;
7062
7063             // Only process pong message if there is an outstanding ping (old ping without nonce should never pong)
7064             if (pfrom->nPingNonceSent != 0) {
7065                 if (nonce == pfrom->nPingNonceSent) {
7066                     // Matching pong received, this ping is no longer outstanding
7067                     bPingFinished = true;
7068                     int64_t pingUsecTime = pingUsecEnd - pfrom->nPingUsecStart;
7069                     if (pingUsecTime > 0) {
7070                         // Successful ping time measurement, replace previous
7071                         pfrom->nPingUsecTime = pingUsecTime;
7072                         pfrom->nMinPingUsecTime = std::min(pfrom->nMinPingUsecTime, pingUsecTime);
7073                     } else {
7074                         // This should never happen
7075                         sProblem = "Timing mishap";
7076                     }
7077                 } else {
7078                     // Nonce mismatches are normal when pings are overlapping
7079                     sProblem = "Nonce mismatch";
7080                     if (nonce == 0) {
7081                         // This is most likely a bug in another implementation somewhere; cancel this ping
7082                         bPingFinished = true;
7083                         sProblem = "Nonce zero";
7084                     }
7085                 }
7086             } else {
7087                 sProblem = "Unsolicited pong without ping";
7088             }
7089         } else {
7090             // This is most likely a bug in another implementation somewhere; cancel this ping
7091             bPingFinished = true;
7092             sProblem = "Short payload";
7093         }
7094
7095         if (!(sProblem.empty())) {
7096             LogPrint("net", "pong peer=%d %s: %s, %x expected, %x received, %u bytes\n",
7097                      pfrom->id,
7098                      pfrom->cleanSubVer,
7099                      sProblem,
7100                      pfrom->nPingNonceSent,
7101                      nonce,
7102                      nAvail);
7103         }
7104         if (bPingFinished) {
7105             pfrom->nPingNonceSent = 0;
7106         }
7107     }
7108
7109
7110     else if (fAlerts && strCommand == "alert")
7111     {
7112         CAlert alert;
7113         vRecv >> alert;
7114
7115         uint256 alertHash = alert.GetHash();
7116         if (pfrom->setKnown.count(alertHash) == 0)
7117         {
7118             if (alert.ProcessAlert(Params().AlertKey()))
7119             {
7120                 // Relay
7121                 pfrom->setKnown.insert(alertHash);
7122                 {
7123                     LOCK(cs_vNodes);
7124                     BOOST_FOREACH(CNode* pnode, vNodes)
7125                     alert.RelayTo(pnode);
7126                 }
7127             }
7128             else {
7129                 // Small DoS penalty so peers that send us lots of
7130                 // duplicate/expired/invalid-signature/whatever alerts
7131                 // eventually get banned.
7132                 // This isn't a Misbehaving(100) (immediate ban) because the
7133                 // peer might be an older or different implementation with
7134                 // a different signature key, etc.
7135                 Misbehaving(pfrom->GetId(), 10);
7136             }
7137         }
7138     }
7139
7140     else if (!(nLocalServices & NODE_BLOOM) &&
7141               (strCommand == "filterload" ||
7142                strCommand == "filteradd"))
7143     {
7144         if (pfrom->nVersion >= NO_BLOOM_VERSION) {
7145             Misbehaving(pfrom->GetId(), 100);
7146             return false;
7147         } else if (GetBoolArg("-enforcenodebloom", false)) {
7148             pfrom->fDisconnect = true;
7149             return false;
7150         }
7151     }
7152
7153
7154     else if (strCommand == "filterload")
7155     {
7156         CBloomFilter filter;
7157         vRecv >> filter;
7158
7159         if (!filter.IsWithinSizeConstraints())
7160             // There is no excuse for sending a too-large filter
7161             Misbehaving(pfrom->GetId(), 100);
7162         else
7163         {
7164             LOCK(pfrom->cs_filter);
7165             delete pfrom->pfilter;
7166             pfrom->pfilter = new CBloomFilter(filter);
7167             pfrom->pfilter->UpdateEmptyFull();
7168         }
7169         pfrom->fRelayTxes = true;
7170     }
7171
7172
7173     else if (strCommand == "filteradd")
7174     {
7175         vector<unsigned char> vData;
7176         vRecv >> vData;
7177
7178         // Nodes must NEVER send a data item > 520 bytes (the max size for a script data object,
7179         // and thus, the maximum size any matched object can have) in a filteradd message
7180         if (vData.size() > MAX_SCRIPT_ELEMENT_SIZE)
7181         {
7182             Misbehaving(pfrom->GetId(), 100);
7183         } else {
7184             LOCK(pfrom->cs_filter);
7185             if (pfrom->pfilter)
7186                 pfrom->pfilter->insert(vData);
7187             else
7188                 Misbehaving(pfrom->GetId(), 100);
7189         }
7190     }
7191
7192
7193     else if (strCommand == "filterclear")
7194     {
7195         LOCK(pfrom->cs_filter);
7196         if (nLocalServices & NODE_BLOOM) {
7197             delete pfrom->pfilter;
7198             pfrom->pfilter = new CBloomFilter();
7199         }
7200         pfrom->fRelayTxes = true;
7201     }
7202
7203
7204     else if (strCommand == "reject")
7205     {
7206         if (fDebug) {
7207             try {
7208                 string strMsg; unsigned char ccode; string strReason;
7209                 vRecv >> LIMITED_STRING(strMsg, CMessageHeader::COMMAND_SIZE) >> ccode >> LIMITED_STRING(strReason, MAX_REJECT_MESSAGE_LENGTH);
7210
7211                 ostringstream ss;
7212                 ss << strMsg << " code " << itostr(ccode) << ": " << strReason;
7213
7214                 if (strMsg == "block" || strMsg == "tx")
7215                 {
7216                     uint256 hash;
7217                     vRecv >> hash;
7218                     ss << ": hash " << hash.ToString();
7219                 }
7220                 LogPrint("net", "Reject %s\n", SanitizeString(ss.str()));
7221             } catch (const std::ios_base::failure&) {
7222                 // Avoid feedback loops by preventing reject messages from triggering a new reject message.
7223                 LogPrint("net", "Unparseable reject message received\n");
7224             }
7225         }
7226     }
7227     else if (strCommand == "notfound") {
7228         // We do not care about the NOTFOUND message, but logging an Unknown Command
7229         // message would be undesirable as we transmit it ourselves.
7230     }
7231
7232     else {
7233         // Ignore unknown commands for extensibility
7234         LogPrint("net", "Unknown command \"%s\" from peer=%d\n", SanitizeString(strCommand), pfrom->id);
7235     }
7236
7237
7238
7239     return true;
7240 }
7241
7242 // requires LOCK(cs_vRecvMsg)
7243 bool ProcessMessages(CNode* pfrom)
7244 {
7245     //if (fDebug)
7246     //    LogPrintf("%s(%u messages)\n", __func__, pfrom->vRecvMsg.size());
7247
7248     //
7249     // Message format
7250     //  (4) message start
7251     //  (12) command
7252     //  (4) size
7253     //  (4) checksum
7254     //  (x) data
7255     //
7256     bool fOk = true;
7257
7258     if (!pfrom->vRecvGetData.empty())
7259         ProcessGetData(pfrom);
7260
7261     // this maintains the order of responses
7262     if (!pfrom->vRecvGetData.empty()) return fOk;
7263
7264     std::deque<CNetMessage>::iterator it = pfrom->vRecvMsg.begin();
7265     while (!pfrom->fDisconnect && it != pfrom->vRecvMsg.end()) {
7266         // Don't bother if send buffer is too full to respond anyway
7267         if (pfrom->nSendSize >= SendBufferSize())
7268             break;
7269
7270         // get next message
7271         CNetMessage& msg = *it;
7272
7273         //if (fDebug)
7274         //    LogPrintf("%s(message %u msgsz, %u bytes, complete:%s)\n", __func__,
7275         //            msg.hdr.nMessageSize, msg.vRecv.size(),
7276         //            msg.complete() ? "Y" : "N");
7277
7278         // end, if an incomplete message is found
7279         if (!msg.complete())
7280             break;
7281
7282         // at this point, any failure means we can delete the current message
7283         it++;
7284
7285         // Scan for message start
7286         if (memcmp(msg.hdr.pchMessageStart, Params().MessageStart(), MESSAGE_START_SIZE) != 0) {
7287             LogPrintf("PROCESSMESSAGE: INVALID MESSAGESTART %s peer=%d\n", SanitizeString(msg.hdr.GetCommand()), pfrom->id);
7288             fOk = false;
7289             break;
7290         }
7291
7292         // Read header
7293         CMessageHeader& hdr = msg.hdr;
7294         if (!hdr.IsValid(Params().MessageStart()))
7295         {
7296             LogPrintf("PROCESSMESSAGE: ERRORS IN HEADER %s peer=%d\n", SanitizeString(hdr.GetCommand()), pfrom->id);
7297             continue;
7298         }
7299         string strCommand = hdr.GetCommand();
7300
7301         // Message size
7302         unsigned int nMessageSize = hdr.nMessageSize;
7303
7304         // Checksum
7305         CDataStream& vRecv = msg.vRecv;
7306         uint256 hash = Hash(vRecv.begin(), vRecv.begin() + nMessageSize);
7307         unsigned int nChecksum = ReadLE32((unsigned char*)&hash);
7308         if (nChecksum != hdr.nChecksum)
7309         {
7310             LogPrintf("%s(%s, %u bytes): CHECKSUM ERROR nChecksum=%08x hdr.nChecksum=%08x\n", __func__,
7311                       SanitizeString(strCommand), nMessageSize, nChecksum, hdr.nChecksum);
7312             continue;
7313         }
7314
7315         // Process message
7316         bool fRet = false;
7317         try
7318         {
7319             fRet = ProcessMessage(pfrom, strCommand, vRecv, msg.nTime);
7320             boost::this_thread::interruption_point();
7321         }
7322         catch (const std::ios_base::failure& e)
7323         {
7324             pfrom->PushMessage("reject", strCommand, REJECT_MALFORMED, string("error parsing message"));
7325             if (strstr(e.what(), "end of data"))
7326             {
7327                 // Allow exceptions from under-length message on vRecv
7328                 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());
7329             }
7330             else if (strstr(e.what(), "size too large"))
7331             {
7332                 // Allow exceptions from over-long size
7333                 LogPrintf("%s(%s, %u bytes): Exception '%s' caught\n", __func__, SanitizeString(strCommand), nMessageSize, e.what());
7334             }
7335             else
7336             {
7337                 //PrintExceptionContinue(&e, "ProcessMessages()");
7338             }
7339         }
7340         catch (const boost::thread_interrupted&) {
7341             throw;
7342         }
7343         catch (const std::exception& e) {
7344             PrintExceptionContinue(&e, "ProcessMessages()");
7345         } catch (...) {
7346             PrintExceptionContinue(NULL, "ProcessMessages()");
7347         }
7348
7349         if (!fRet)
7350             LogPrintf("%s(%s, %u bytes) FAILED peer=%d\n", __func__, SanitizeString(strCommand), nMessageSize, pfrom->id);
7351
7352         break;
7353     }
7354
7355     // In case the connection got shut down, its receive buffer was wiped
7356     if (!pfrom->fDisconnect)
7357         pfrom->vRecvMsg.erase(pfrom->vRecvMsg.begin(), it);
7358
7359     return fOk;
7360 }
7361
7362
7363 bool SendMessages(CNode* pto, bool fSendTrickle)
7364 {
7365     const Consensus::Params& consensusParams = Params().GetConsensus();
7366     {
7367         // Don't send anything until we get its version message
7368         if (pto->nVersion == 0)
7369             return true;
7370
7371         //
7372         // Message: ping
7373         //
7374         bool pingSend = false;
7375         if (pto->fPingQueued) {
7376             // RPC ping request by user
7377             pingSend = true;
7378         }
7379         if (pto->nPingNonceSent == 0 && pto->nPingUsecStart + PING_INTERVAL * 1000000 < GetTimeMicros()) {
7380             // Ping automatically sent as a latency probe & keepalive.
7381             pingSend = true;
7382         }
7383         if (pingSend) {
7384             uint64_t nonce = 0;
7385             while (nonce == 0) {
7386                 GetRandBytes((unsigned char*)&nonce, sizeof(nonce));
7387             }
7388             pto->fPingQueued = false;
7389             pto->nPingUsecStart = GetTimeMicros();
7390             if (pto->nVersion > BIP0031_VERSION) {
7391                 pto->nPingNonceSent = nonce;
7392                 pto->PushMessage("ping", nonce);
7393             } else {
7394                 // Peer is too old to support ping command with nonce, pong will never arrive.
7395                 pto->nPingNonceSent = 0;
7396                 pto->PushMessage("ping");
7397             }
7398         }
7399
7400         TRY_LOCK(cs_main, lockMain); // Acquire cs_main for IsInitialBlockDownload() and CNodeState()
7401         if (!lockMain)
7402             return true;
7403
7404         // Address refresh broadcast
7405         static int64_t nLastRebroadcast;
7406         if (!IsInitialBlockDownload() && (GetTime() - nLastRebroadcast > 24 * 60 * 60))
7407         {
7408             LOCK(cs_vNodes);
7409             BOOST_FOREACH(CNode* pnode, vNodes)
7410             {
7411                 // Periodically clear addrKnown to allow refresh broadcasts
7412                 if (nLastRebroadcast)
7413                     pnode->addrKnown.reset();
7414
7415                 // Rebroadcast our address
7416                 AdvertizeLocal(pnode);
7417             }
7418             if (!vNodes.empty())
7419                 nLastRebroadcast = GetTime();
7420         }
7421
7422         //
7423         // Message: addr
7424         //
7425         if (fSendTrickle)
7426         {
7427             vector<CAddress> vAddr;
7428             vAddr.reserve(pto->vAddrToSend.size());
7429             BOOST_FOREACH(const CAddress& addr, pto->vAddrToSend)
7430             {
7431                 if (!pto->addrKnown.contains(addr.GetKey()))
7432                 {
7433                     pto->addrKnown.insert(addr.GetKey());
7434                     vAddr.push_back(addr);
7435                     // receiver rejects addr messages larger than 1000
7436                     if (vAddr.size() >= 1000)
7437                     {
7438                         pto->PushMessage("addr", vAddr);
7439                         vAddr.clear();
7440                     }
7441                 }
7442             }
7443             pto->vAddrToSend.clear();
7444             if (!vAddr.empty())
7445                 pto->PushMessage("addr", vAddr);
7446         }
7447
7448         CNodeState &state = *State(pto->GetId());
7449         if (state.fShouldBan) {
7450             if (pto->fWhitelisted)
7451                 LogPrintf("Warning: not punishing whitelisted peer %s!\n", pto->addr.ToString());
7452             else {
7453                 pto->fDisconnect = true;
7454                 if (pto->addr.IsLocal())
7455                     LogPrintf("Warning: not banning local peer %s!\n", pto->addr.ToString());
7456                 else
7457                 {
7458                     CNode::Ban(pto->addr);
7459                 }
7460             }
7461             state.fShouldBan = false;
7462         }
7463
7464         BOOST_FOREACH(const CBlockReject& reject, state.rejects)
7465         pto->PushMessage("reject", (string)"block", reject.chRejectCode, reject.strRejectReason, reject.hashBlock);
7466         state.rejects.clear();
7467
7468         // Start block sync
7469         if (pindexBestHeader == NULL)
7470             pindexBestHeader = chainActive.Tip();
7471         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.
7472         if (!state.fSyncStarted && !pto->fClient && !fImporting && !fReindex) {
7473             // Only actively request headers from a single peer, unless we're close to today.
7474             if ((nSyncStarted == 0 && fFetch) || pindexBestHeader->GetBlockTime() > GetAdjustedTime() - 24 * 60 * 60) {
7475                 state.fSyncStarted = true;
7476                 nSyncStarted++;
7477                 CBlockIndex *pindexStart = pindexBestHeader->pprev ? pindexBestHeader->pprev : pindexBestHeader;
7478                 LogPrint("net", "initial getheaders (%d) to peer=%d (startheight:%d)\n", pindexStart->GetHeight(), pto->id, pto->nStartingHeight);
7479                 pto->PushMessage("getheaders", chainActive.GetLocator(pindexStart), uint256());
7480             }
7481         }
7482
7483         // Resend wallet transactions that haven't gotten in a block yet
7484         // Except during reindex, importing and IBD, when old wallet
7485         // transactions become unconfirmed and spams other nodes.
7486         if (!fReindex && !fImporting && !IsInitialBlockDownload())
7487         {
7488             GetMainSignals().Broadcast(nTimeBestReceived);
7489         }
7490
7491         //
7492         // Message: inventory
7493         //
7494         vector<CInv> vInv;
7495         vector<CInv> vInvWait;
7496         {
7497             LOCK(pto->cs_inventory);
7498             vInv.reserve(pto->vInventoryToSend.size());
7499             vInvWait.reserve(pto->vInventoryToSend.size());
7500             BOOST_FOREACH(const CInv& inv, pto->vInventoryToSend)
7501             {
7502                 if (pto->setInventoryKnown.count(inv))
7503                     continue;
7504
7505                 // trickle out tx inv to protect privacy
7506                 if (inv.type == MSG_TX && !fSendTrickle)
7507                 {
7508                     // 1/4 of tx invs blast to all immediately
7509                     static uint256 hashSalt;
7510                     if (hashSalt.IsNull())
7511                         hashSalt = GetRandHash();
7512                     uint256 hashRand = ArithToUint256(UintToArith256(inv.hash) ^ UintToArith256(hashSalt));
7513                     hashRand = Hash(BEGIN(hashRand), END(hashRand));
7514                     bool fTrickleWait = ((UintToArith256(hashRand) & 3) != 0);
7515
7516                     if (fTrickleWait)
7517                     {
7518                         vInvWait.push_back(inv);
7519                         continue;
7520                     }
7521                 }
7522
7523                 // returns true if wasn't already contained in the set
7524                 if (pto->setInventoryKnown.insert(inv).second)
7525                 {
7526                     vInv.push_back(inv);
7527                     if (vInv.size() >= 1000)
7528                     {
7529                         pto->PushMessage("inv", vInv);
7530                         vInv.clear();
7531                     }
7532                 }
7533             }
7534             pto->vInventoryToSend = vInvWait;
7535         }
7536         if (!vInv.empty())
7537             pto->PushMessage("inv", vInv);
7538
7539         // Detect whether we're stalling
7540         int64_t nNow = GetTimeMicros();
7541         if (!pto->fDisconnect && state.nStallingSince && state.nStallingSince < nNow - 1000000 * BLOCK_STALLING_TIMEOUT) {
7542             // Stalling only triggers when the block download window cannot move. During normal steady state,
7543             // the download window should be much larger than the to-be-downloaded set of blocks, so disconnection
7544             // should only happen during initial block download.
7545             LogPrintf("Peer=%d is stalling block download, disconnecting\n", pto->id);
7546             pto->fDisconnect = true;
7547         }
7548         // In case there is a block that has been in flight from this peer for (2 + 0.5 * N) times the block interval
7549         // (with N the number of validated blocks that were in flight at the time it was requested), disconnect due to
7550         // timeout. We compensate for in-flight blocks to prevent killing off peers due to our own downstream link
7551         // being saturated. We only count validated in-flight blocks so peers can't advertise non-existing block hashes
7552         // to unreasonably increase our timeout.
7553         // We also compare the block download timeout originally calculated against the time at which we'd disconnect
7554         // if we assumed the block were being requested now (ignoring blocks we've requested from this peer, since we're
7555         // only looking at this peer's oldest request).  This way a large queue in the past doesn't result in a
7556         // permanently large window for this block to be delivered (ie if the number of blocks in flight is decreasing
7557         // more quickly than once every 5 minutes, then we'll shorten the download window for this block).
7558         if (!pto->fDisconnect && state.vBlocksInFlight.size() > 0) {
7559             QueuedBlock &queuedBlock = state.vBlocksInFlight.front();
7560             int64_t nTimeoutIfRequestedNow = GetBlockTimeout(nNow, nQueuedValidatedHeaders - state.nBlocksInFlightValidHeaders, consensusParams);
7561             if (queuedBlock.nTimeDisconnect > nTimeoutIfRequestedNow) {
7562                 LogPrint("net", "Reducing block download timeout for peer=%d block=%s, orig=%d new=%d\n", pto->id, queuedBlock.hash.ToString(), queuedBlock.nTimeDisconnect, nTimeoutIfRequestedNow);
7563                 queuedBlock.nTimeDisconnect = nTimeoutIfRequestedNow;
7564             }
7565             if (queuedBlock.nTimeDisconnect < nNow) {
7566                 LogPrintf("Timeout downloading block %s from peer=%d, disconnecting\n", queuedBlock.hash.ToString(), pto->id);
7567                 pto->fDisconnect = true;
7568             }
7569         }
7570
7571         //
7572         // Message: getdata (blocks)
7573         //
7574         static uint256 zero;
7575         vector<CInv> vGetData;
7576         if (!pto->fDisconnect && !pto->fClient && (fFetch || !IsInitialBlockDownload()) && state.nBlocksInFlight < MAX_BLOCKS_IN_TRANSIT_PER_PEER) {
7577             vector<CBlockIndex*> vToDownload;
7578             NodeId staller = -1;
7579             FindNextBlocksToDownload(pto->GetId(), MAX_BLOCKS_IN_TRANSIT_PER_PEER - state.nBlocksInFlight, vToDownload, staller);
7580             BOOST_FOREACH(CBlockIndex *pindex, vToDownload) {
7581                 vGetData.push_back(CInv(MSG_BLOCK, pindex->GetBlockHash()));
7582                 MarkBlockAsInFlight(pto->GetId(), pindex->GetBlockHash(), consensusParams, pindex);
7583                 LogPrint("net", "Requesting block %s (%d) peer=%d\n", pindex->GetBlockHash().ToString(),
7584                          pindex->GetHeight(), pto->id);
7585             }
7586             if (state.nBlocksInFlight == 0 && staller != -1) {
7587                 if (State(staller)->nStallingSince == 0) {
7588                     State(staller)->nStallingSince = nNow;
7589                     LogPrint("net", "Stall started peer=%d\n", staller);
7590                 }
7591             }
7592         }
7593         /*CBlockIndex *pindex;
7594         if ( komodo_requestedhash != zero && komodo_requestedcount < 16 && (pindex= mapBlockIndex[komodo_requestedhash]) != 0 )
7595         {
7596             LogPrint("net","komodo_requestedhash.%d request %s to nodeid.%d\n",komodo_requestedcount,komodo_requestedhash.ToString().c_str(),pto->GetId());
7597             fprintf(stderr,"komodo_requestedhash.%d request %s to nodeid.%d\n",komodo_requestedcount,komodo_requestedhash.ToString().c_str(),pto->GetId());
7598             vGetData.push_back(CInv(MSG_BLOCK, komodo_requestedhash));
7599             MarkBlockAsInFlight(pto->GetId(), komodo_requestedhash, consensusParams, pindex);
7600             komodo_requestedcount++;
7601             if ( komodo_requestedcount > 16 )
7602             {
7603                 memset(&komodo_requestedhash,0,sizeof(komodo_requestedhash));
7604                 komodo_requestedcount = 0;
7605             }
7606         }*/
7607
7608         //
7609         // Message: getdata (non-blocks)
7610         //
7611         while (!pto->fDisconnect && !pto->mapAskFor.empty() && (*pto->mapAskFor.begin()).first <= nNow)
7612         {
7613             const CInv& inv = (*pto->mapAskFor.begin()).second;
7614             if (!AlreadyHave(inv))
7615             {
7616                 if (fDebug)
7617                     LogPrint("net", "Requesting %s peer=%d\n", inv.ToString(), pto->id);
7618                 vGetData.push_back(inv);
7619                 if (vGetData.size() >= 1000)
7620                 {
7621                     pto->PushMessage("getdata", vGetData);
7622                     vGetData.clear();
7623                 }
7624             } else {
7625                 //If we're not going to ask, don't expect a response.
7626                 pto->setAskFor.erase(inv.hash);
7627             }
7628             pto->mapAskFor.erase(pto->mapAskFor.begin());
7629         }
7630         if (!vGetData.empty())
7631             pto->PushMessage("getdata", vGetData);
7632
7633     }
7634     return true;
7635 }
7636
7637 std::string CBlockFileInfo::ToString() const {
7638     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));
7639 }
7640
7641
7642
7643 static class CMainCleanup
7644 {
7645 public:
7646     CMainCleanup() {}
7647     ~CMainCleanup() {
7648         // block headers
7649         BlockMap::iterator it1 = mapBlockIndex.begin();
7650         for (; it1 != mapBlockIndex.end(); it1++)
7651             delete (*it1).second;
7652         mapBlockIndex.clear();
7653
7654         // orphan transactions
7655         mapOrphanTransactions.clear();
7656         mapOrphanTransactionsByPrev.clear();
7657     }
7658 } instance_of_cmaincleanup;
7659
7660 extern "C" const char* getDataDir()
7661 {
7662     return GetDataDir().string().c_str();
7663 }
7664
7665
7666 // Set default values of new CMutableTransaction based on consensus rules at given height.
7667 CMutableTransaction CreateNewContextualCMutableTransaction(const Consensus::Params& consensusParams, int nHeight)
7668 {
7669     CMutableTransaction mtx;
7670
7671     bool isOverwintered = NetworkUpgradeActive(nHeight, consensusParams, Consensus::UPGRADE_OVERWINTER);
7672     if (isOverwintered) {
7673         mtx.fOverwintered = true;
7674         mtx.nExpiryHeight = nHeight + expiryDelta;
7675
7676         if (NetworkUpgradeActive(nHeight, consensusParams, Consensus::UPGRADE_SAPLING)) {
7677             mtx.nVersionGroupId = SAPLING_VERSION_GROUP_ID;
7678             mtx.nVersion = SAPLING_TX_VERSION;
7679         } else {
7680             mtx.nVersionGroupId = OVERWINTER_VERSION_GROUP_ID;
7681             mtx.nVersion = OVERWINTER_TX_VERSION;
7682             mtx.nExpiryHeight = std::min(
7683                 mtx.nExpiryHeight,
7684                 static_cast<uint32_t>(consensusParams.vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight - 1));
7685         }
7686     }
7687     return mtx;
7688 }