src/main.h

   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 https://www.opensource.org/licenses/mit-license.php .
   5
   6 #ifndef BITCOIN_MAIN_H
   7 #define BITCOIN_MAIN_H
   8
   9 #if defined(HAVE_CONFIG_H)
  10 #include "config/bitcoin-config.h"
  11 #endif
  12
  13 #include "amount.h"
  14 #include "chain.h"
  15 #include "chainparams.h"
  16 #include "coins.h"
  17 #include "consensus/consensus.h"
  18 #include "consensus/upgrades.h"
  19 #include "net.h"
  20 #include "primitives/block.h"
  21 #include "primitives/transaction.h"
  22 #include "script/script.h"
  23 #include "script/serverchecker.h"
  24 #include "script/standard.h"
  25 #include "script/script_ext.h"
  26 #include "spentindex.h"
  27 #include "sync.h"
  28 #include "tinyformat.h"
  29 #include "txdb.h"
  30 #include "txmempool.h"
  31 #include "uint256.h"
  32 #include "cheatcatcher.h"
  33 #include "addressindex.h"
  34 #include "timestampindex.h"
  35
  36 #include <algorithm>
  37 #include <exception>
  38 #include <map>
  39 #include <set>
  40 #include <stdint.h>
  41 #include <string>
  42 #include <utility>
  43 #include <vector>
  44
  45 #include <boost/unordered_map.hpp>
  46
  47 class CBlockIndex;
  48 class CBlockTreeDB;
  49 class CBloomFilter;
  50 class CChainParams;
  51 class CInv;
  52 class CScriptCheck;
  53 class CValidationInterface;
  54 class CValidationState;
  55 class PrecomputedTransactionData;
  56
  57 struct CNodeStateStats;
  58 #define DEFAULT_MEMPOOL_EXPIRY 1
  59 #define _COINBASE_MATURITY 100
  60
  61 /** Default for -blockmaxsize and -blockminsize, which control the range of sizes the mining code will create **/
  62 static const unsigned int DEFAULT_BLOCK_MAX_SIZE = MAX_BLOCK_SIZE;
  63 static const unsigned int DEFAULT_BLOCK_MIN_SIZE = 0;
  64 /** Default for -blockprioritysize, maximum space for zero/low-fee transactions **/
  65 static const unsigned int DEFAULT_BLOCK_PRIORITY_SIZE = DEFAULT_BLOCK_MAX_SIZE / 2;
  66 /** Default for accepting alerts from the P2P network. */
  67 static const bool DEFAULT_ALERTS = true;
  68 /** Minimum alert priority for enabling safe mode. */
  69 static const int ALERT_PRIORITY_SAFE_MODE = 4000;
  70 /** Maximum reorg length we will accept before we shut down and alert the user. */
  71 static const unsigned int MAX_REORG_LENGTH = _COINBASE_MATURITY - 1;
  72 /** Maximum number of signature check operations in an IsStandard() P2SH script */
  73 static const unsigned int MAX_P2SH_SIGOPS = 15;
  74 /** The maximum number of sigops we're willing to relay/mine in a single tx */
  75 static const unsigned int MAX_STANDARD_TX_SIGOPS = MAX_BLOCK_SIGOPS/5;
  76 /** Default for -minrelaytxfee, minimum relay fee for transactions */
  77 static const unsigned int DEFAULT_MIN_RELAY_TX_FEE = 100;
  78 /** Default for -maxorphantx, maximum number of orphan transactions kept in memory */
  79 static const unsigned int DEFAULT_MAX_ORPHAN_TRANSACTIONS = 100;
  80 /** Default for -txexpirydelta, in number of blocks */
  81 static const unsigned int DEFAULT_PRE_BLOSSOM_TX_EXPIRY_DELTA = 20;
  82 static const unsigned int DEFAULT_POST_BLOSSOM_TX_EXPIRY_DELTA = DEFAULT_PRE_BLOSSOM_TX_EXPIRY_DELTA * Consensus::BLOSSOM_POW_TARGET_SPACING_RATIO;
  83 /** The number of blocks within expiry height when a tx is considered to be expiring soon */
  84 static constexpr uint32_t TX_EXPIRING_SOON_THRESHOLD = 3;
  85 /** The maximum size of a blk?????.dat file (since 0.8) */
  86 static const unsigned int MAX_BLOCKFILE_SIZE = 0x8000000; // 128 MiB
  87 /** The pre-allocation chunk size for blk?????.dat files (since 0.8) */
  88 static const unsigned int BLOCKFILE_CHUNK_SIZE = 0x1000000; // 16 MiB
  89 /** The pre-allocation chunk size for rev?????.dat files (since 0.8) */
  90 static const unsigned int UNDOFILE_CHUNK_SIZE = 0x100000; // 1 MiB
  91 /** Maximum number of script-checking threads allowed */
  92 static const int MAX_SCRIPTCHECK_THREADS = 16;
  93 /** -par default (number of script-checking threads, 0 = auto) */
  94 static const int DEFAULT_SCRIPTCHECK_THREADS = 0;
  95 /** Number of blocks that can be requested at any given time from a single peer. */
  96 static const int MAX_BLOCKS_IN_TRANSIT_PER_PEER = 16;
  97 /** Timeout in seconds during which a peer must stall block download progress before being disconnected. */
  98 static const unsigned int BLOCK_STALLING_TIMEOUT = 2;
  99 /** Number of headers sent in one getheaders result. We rely on the assumption that if a peer sends
 100  *  less than this number, we reached its tip. Changing this value is a protocol upgrade. */
 101 static const unsigned int MAX_HEADERS_RESULTS = 160;
 102 /** Size of the "block download window": how far ahead of our current height do we fetch?
 103  *  Larger windows tolerate larger download speed differences between peer, but increase the potential
 104  *  degree of disordering of blocks on disk (which make reindexing and in the future perhaps pruning
 105  *  harder). We'll probably want to make this a per-peer adaptive value at some point. */
 106 static const unsigned int BLOCK_DOWNLOAD_WINDOW = 1024;
 107 /** Time to wait (in seconds) between writing blocks/block index to disk. */
 108 static const unsigned int DATABASE_WRITE_INTERVAL = 60 * 60;
 109 /** Time to wait (in seconds) between flushing chainstate to disk. */
 110 static const unsigned int DATABASE_FLUSH_INTERVAL = 24 * 60 * 60;
 111 /** Maximum length of reject messages. */
 112 static const unsigned int MAX_REJECT_MESSAGE_LENGTH = 111;
 113 static const int64_t DEFAULT_MAX_TIP_AGE = 24 * 60 * 60;
 114
 115 //static const bool DEFAULT_ADDRESSINDEX = false;
 116 //static const bool DEFAULT_SPENTINDEX = false;
 117 #define DEFAULT_ADDRESSINDEX (GetArg("-ac_cc",0) != 0 || GetArg("-ac_ccactivate",0) != 0)
 118 #define DEFAULT_SPENTINDEX (GetArg("-ac_cc",0) != 0 || GetArg("-ac_ccactivate",0) != 0)
 119 static const bool DEFAULT_INSIGHTEXPLORER = false;
 120 static const bool DEFAULT_TIMESTAMPINDEX = false;
 121 static const unsigned int DEFAULT_DB_MAX_OPEN_FILES = 1000;
 122 static const bool DEFAULT_DB_COMPRESSION = true;
 123
 124 // Sanity check the magic numbers when we change them
 125 BOOST_STATIC_ASSERT(DEFAULT_BLOCK_MAX_SIZE <= MAX_BLOCK_SIZE);
 126 BOOST_STATIC_ASSERT(DEFAULT_BLOCK_PRIORITY_SIZE <= DEFAULT_BLOCK_MAX_SIZE);
 127
 128 #define equihash_parameters_acceptable(N, K) \
 129     ((CBlockHeader::HEADER_SIZE + equihash_solution_size(N, K))*MAX_HEADERS_RESULTS < \
 130      MAX_PROTOCOL_MESSAGE_LENGTH-1000)
 131
 132 struct BlockHasher
 133 {
 134     size_t operator()(const uint256& hash) const { return hash.GetCheapHash(); }
 135 };
 136
 137 extern boost::optional<unsigned int> expiryDeltaArg;
 138 extern CScript COINBASE_FLAGS;
 139 extern CCriticalSection cs_main;
 140 extern CTxMemPool mempool;
 141 typedef boost::unordered_map<uint256, CBlockIndex*, BlockHasher> BlockMap;
 142 extern BlockMap mapBlockIndex;
 143 extern uint64_t nLastBlockTx;
 144 extern uint64_t nLastBlockSize;
 145 extern const std::string verusDataSignaturePrefix;
 146 extern const std::string verusDataSignaturePrefix;
 147 extern CWaitableCriticalSection csBestBlock;
 148 extern CConditionVariable cvBlockChange;
 149 extern bool fExperimentalMode;
 150 extern bool fImporting;
 151 extern bool fReindex;
 152 extern int nScriptCheckThreads;
 153 extern bool fTxIndex;
 154
 155 // START insightexplorer
 156 extern bool fInsightExplorer;
 157
 158 // The following flags enable specific indices (DB tables), but are not exposed as
 159 // separate command-line options; instead they are enabled by experimental feature "-insightexplorer"
 160 // and are always equal to the overall controlling flag, fInsightExplorer.
 161
 162 // Maintain a full address index, used to query for the balance, txids and unspent outputs for addresses
 163 extern bool fAddressIndex;
 164
 165 // Maintain a full spent index, used to query the spending txid and input index for an outpoint
 166 extern bool fSpentIndex;
 167
 168 // Maintain a full timestamp index, used to query for blocks within a time range
 169 extern bool fTimestampIndex;
 170
 171 // END insightexplorer
 172
 173 extern bool fIsBareMultisigStd;
 174 extern bool fCheckBlockIndex;
 175 extern bool fCheckpointsEnabled;
 176 // TODO: remove this flag by structuring our code such that
 177 // it is unneeded for testing
 178 extern bool fCoinbaseEnforcedProtectionEnabled;
 179 extern size_t nCoinCacheUsage;
 180 extern CFeeRate minRelayTxFee;
 181 extern bool fAlerts;
 182 extern int64_t nMaxTipAge;
 183
 184 /** Best header we've seen so far (used for getheaders queries' starting points). */
 185 extern CBlockIndex *pindexBestHeader;
 186
 187 /** Minimum disk space required - used in CheckDiskSpace() */
 188 static const uint64_t nMinDiskSpace = 52428800;
 189
 190 /** Pruning-related variables and constants */
 191 /** True if any block files have ever been pruned. */
 192 extern bool fHavePruned;
 193 /** True if we're running in -prune mode. */
 194 extern bool fPruneMode;
 195 /** Number of MiB of block files that we're trying to stay below. */
 196 extern uint64_t nPruneTarget;
 197 /** Block files containing a block-height within MIN_BLOCKS_TO_KEEP of chainActive.Tip() will not be pruned. */
 198 static const unsigned int MIN_BLOCKS_TO_KEEP = 288;
 199
 200 // Require that user allocate at least 550MB for block & undo files (blk???.dat and rev???.dat)
 201 // At 1MB per block, 288 blocks = 288MB.
 202 // Add 15% for Undo data = 331MB
 203 // Add 20% for Orphan block rate = 397MB
 204 // We want the low water mark after pruning to be at least 397 MB and since we prune in
 205 // full block file chunks, we need the high water mark which triggers the prune to be
 206 // one 128MB block file + added 15% undo data = 147MB greater for a total of 545MB
 207 // Setting the target to > than 550MB will make it likely we can respect the target.
 208 static const uint64_t MIN_DISK_SPACE_FOR_BLOCK_FILES = 550 * 1024 * 1024;
 209
 210 /** Register with a network node to receive its signals */
 211 void RegisterNodeSignals(CNodeSignals& nodeSignals);
 212 /** Unregister a network node */
 213 void UnregisterNodeSignals(CNodeSignals& nodeSignals);
 214
 215 /**
 216  * Process an incoming block. This only returns after the best known valid
 217  * block is made active. Note that it does not, however, guarantee that the
 218  * specific block passed to it has been checked for validity!
 219  *
 220  * @param[out]  state   This may be set to an Error state if any error occurred processing it, including during validation/connection/etc of otherwise unrelated blocks during reorganisation; or it may be set to an Invalid state if pblock is itself invalid (but this is not guaranteed even when the block is checked). If you want to *possibly* get feedback on whether pblock is valid, you must also install a CValidationInterface (see validationinterface.h) - this will have its BlockChecked method called whenever *any* block completes validation.
 221  * @param[in]   pfrom   The node which we are receiving the block from; it is added to mapBlockSource and may be penalised if the block is invalid.
 222  * @param[in]   pblock  The block we want to process.
 223  * @param[in]   fForceProcessing Process this block even if unrequested; used for non-network block sources and whitelisted peers.
 224  * @param[out]  dbp     If pblock is stored to disk (or already there), this will be set to its location.
 225  * @return True if state.IsValid()
 226  */
 227 bool ProcessNewBlock(bool from_miner, int32_t height, CValidationState &state, const CChainParams& chainparams, CNode* pfrom, CBlock* pblock, bool fForceProcessing, CDiskBlockPos *dbp);
 228 /** Check whether enough disk space is available for an incoming block */
 229 bool CheckDiskSpace(uint64_t nAdditionalBytes = 0);
 230 /** Open a block file (blk?????.dat) */
 231 FILE* OpenBlockFile(const CDiskBlockPos &pos, bool fReadOnly = false);
 232 /** Open an undo file (rev?????.dat) */
 233 FILE* OpenUndoFile(const CDiskBlockPos &pos, bool fReadOnly = false);
 234 /** Translation to a filesystem path */
 235 boost::filesystem::path GetBlockPosFilename(const CDiskBlockPos &pos, const char *prefix);
 236 /** Import blocks from an external file */
 237 bool LoadExternalBlockFile(const CChainParams& chainparams, FILE* fileIn, CDiskBlockPos *dbp = NULL);
 238 /** Initialize a new block tree database + block data on disk */
 239 bool InitBlockIndex(const CChainParams& chainparams);
 240 /** Load the block tree and coins database from disk */
 241 bool LoadBlockIndex();
 242 /** Unload database information */
 243 void UnloadBlockIndex();
 244 /** Process protocol messages received from a given node */
 245 bool ProcessMessages(CNode* pfrom);
 246 /**
 247  * Send queued protocol messages to be sent to a give node.
 248  *
 249  * @param[in]   pto             The node which we are sending messages to.
 250  * @param[in]   fSendTrickle    When true send the trickled data, otherwise trickle the data until true.
 251  */
 252 bool SendMessages(CNode* pto, bool fSendTrickle);
 253 /** Run an instance of the script checking thread */
 254 void ThreadScriptCheck();
 255 /** Try to detect Partition (network isolation) attacks against us */
 256 void PartitionCheck(bool (*initialDownloadCheck)(const CChainParams&), CCriticalSection& cs, const CBlockIndex *const &bestHeader);
 257 /** Check whether we are doing an initial block download (synchronizing from disk or network) */
 258 bool IsInitialBlockDownload(const CChainParams& chainParams);
 259 /** Check if the daemon is in sync, if not, it returns 1 or if due to best header only, the difference in best
 260  * header and activeChain tip
 261  */
 262 int IsNotInSync();
 263 /** Format a string that describes several potential problems detected by the core */
 264 std::string GetWarnings(const std::string& strFor);
 265 /** Retrieve a transaction (from memory pool, or from disk, if possible) */
 266 bool GetTransaction(const uint256 &hash, CTransaction &tx, const Consensus::Params& params, uint256 &hashBlock, bool fAllowSlow = false);
 267 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock, bool fAllowSlow = false);
 268 /** Find the best known block, and make it the tip of the block chain */
 269 bool ActivateBestChain(CValidationState& state, const CChainParams& chainparams, const CBlock* pblock = NULL);
 270 CAmount GetBlockSubsidy(int nHeight, const Consensus::Params& consensusParams);
 271 CAmount GetBlockOnePremine();
 272 void SetBlockOnePremine(CAmount value);
 273
 274 /**
 275  * Prune block and undo files (blk???.dat and undo???.dat) so that the disk space used is less than a user-defined target.
 276  * The user sets the target (in MB) on the command line or in config file.  This will be run on startup and whenever new
 277  * space is allocated in a block or undo file, staying below the target. Changing back to unpruned requires a reindex
 278  * (which in this case means the blockchain must be re-downloaded.)
 279  *
 280  * Pruning functions are called from FlushStateToDisk when the global fCheckForPruning flag has been set.
 281  * Block and undo files are deleted in lock-step (when blk00003.dat is deleted, so is rev00003.dat.)
 282  * Pruning cannot take place until the longest chain is at least a certain length (100000 on mainnet, 1000 on testnet, 10 on regtest).
 283  * Pruning will never delete a block within a defined distance (currently 288) from the active chain's tip.
 284  * The block index is updated by unsetting HAVE_DATA and HAVE_UNDO for any blocks that were stored in the deleted files.
 285  * A db flag records the fact that at least some block files have been pruned.
 286  *
 287  * @param[out]   setFilesToPrune   The set of file indices that can be unlinked will be returned
 288  */
 289 void FindFilesToPrune(std::set<int>& setFilesToPrune, uint64_t nPruneAfterHeight);
 290
 291 /**
 292  *  Actually unlink the specified files
 293  */
 294 void UnlinkPrunedFiles(std::set<int>& setFilesToPrune);
 295
 296 /** Create a new block index entry for a given block hash */
 297 CBlockIndex * InsertBlockIndex(uint256 hash);
 298 /** Get statistics from node state */
 299 bool GetNodeStateStats(NodeId nodeid, CNodeStateStats &stats);
 300 /** Increase a node's misbehavior score. */
 301 void Misbehaving(NodeId nodeid, int howmuch);
 302 /** Flush all state, indexes and buffers to disk. */
 303 void FlushStateToDisk();
 304 /** Prune block files and flush state to disk. */
 305 void PruneAndFlush();
 306
 307 /** (try to) add transaction to memory pool **/
 308 bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransaction &tx, bool fLimitFree,
 309                         bool* pfMissingInputs, bool fRejectAbsurdFee=false, int dosLevel=-1);
 310 bool AcceptToMemoryPoolInt(CTxMemPool& pool, CValidationState &state, const CTransaction &tx, bool fLimitFree,
 311                            bool* pfMissingInputs, bool fRejectAbsurdFee=false, int dosLevel=-1, int32_t simHeight = 0);
 312
 313
 314 struct CNodeStateStats {
 315     int nMisbehavior;
 316     int nSyncHeight;
 317     int nCommonHeight;
 318     std::vector<int> vHeightInFlight;
 319 };
 320
 321 CAmount GetMinRelayFee(const CTransaction& tx, unsigned int nBytes, bool fAllowFree);
 322
 323 /**
 324  * Check transaction inputs, and make sure any
 325  * pay-to-script-hash transactions are evaluating IsStandard scripts
 326  *
 327  * Why bother? To avoid denial-of-service attacks; an attacker
 328  * can submit a standard HASH... OP_EQUAL transaction,
 329  * which will get accepted into blocks. The redemption
 330  * script can be anything; an attacker could use a very
 331  * expensive-to-check-upon-redemption script like:
 332  *   DUP CHECKSIG DROP ... repeated 100 times... OP_1
 333  */
 334
 335 /**
 336  * Check for standard transaction types
 337  * @param[in] mapInputs    Map of previous transactions that have outputs we're spending
 338  * @return True if all inputs (scriptSigs) use only standard transaction forms
 339  */
 340 bool AreInputsStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs, uint32_t consensusBranchId);
 341
 342 /**
 343  * Count ECDSA signature operations the old-fashioned (pre-0.6) way
 344  * @return number of sigops this transaction's outputs will produce when spent
 345  * @see CTransaction::FetchInputs
 346  */
 347 unsigned int GetLegacySigOpCount(const CTransaction& tx);
 348
 349 /**
 350  * Count ECDSA signature operations in pay-to-script-hash inputs.
 351  *
 352  * @param[in] mapInputs Map of previous transactions that have outputs we're spending
 353  * @return maximum number of sigops required to validate this transaction's inputs
 354  * @see CTransaction::FetchInputs
 355  */
 356 unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewCache& mapInputs);
 357
 358
 359 /**
 360  * Check whether all inputs of this transaction are valid (no double spends, scripts & sigs, amounts)
 361  * This does not modify the UTXO set. If pvChecks is not NULL, script checks are pushed onto it
 362  * instead of being performed inline.
 363  */
 364 bool ContextualCheckInputs(const CTransaction& tx, CValidationState &state, const CCoinsViewCache &view, uint32_t spendHeight, bool fScriptChecks,
 365                            unsigned int flags, bool cacheStore, PrecomputedTransactionData& txdata,
 366                            const Consensus::Params& consensusParams, uint32_t consensusBranchId,
 367                            std::vector<CScriptCheck> *pvChecks = NULL);
 368
 369 /** Check a transaction contextually against a set of consensus rules */
 370 bool ContextualCheckTransaction(const CTransaction& tx, CValidationState &state,
 371                                 const CChainParams& chainparams, int nHeight, int dosLevel,
 372                                 bool (*isInitBlockDownload)(const CChainParams&) = IsInitialBlockDownload);
 373
 374 /** Apply the effects of this transaction on the UTXO set represented by view */
 375 void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, int nHeight);
 376
 377 /** Transaction validation functions */
 378
 379 /** Context-independent validity checks */
 380 bool CheckTransaction(const CTransaction& tx, CValidationState& state, libzcash::ProofVerifier& verifier);
 381 bool CheckTransactionWithoutProofVerification(const CTransaction& tx, CValidationState &state);
 382
 383 /** Check for standard transaction types
 384  * @return True if all outputs (scriptPubKeys) use only standard transaction forms
 385  */
 386 bool IsStandardTx(const CTransaction& tx, std::string& reason, const CChainParams& chainparams, int nHeight = 0);
 387
 388 namespace Consensus {
 389
 390 /**
 391  * Check whether all inputs of this transaction are valid (no double spends and amounts)
 392  * This does not modify the UTXO set. This does not check scripts and sigs.
 393  * Preconditions: tx.IsCoinBase() is false.
 394  */
 395 bool CheckTxInputs(const CTransaction& tx, CValidationState& state, const CCoinsViewCache& inputs, uint32_t nSpendHeight, const Consensus::Params& consensusParams);
 396
 397 } // namespace Consensus
 398
 399 /**
 400  * Check if transaction is final and can be included in a block with the
 401  * specified height and time. Consensus critical.
 402  */
 403 bool IsFinalTx(const CTransaction &tx, int nBlockHeight, int64_t nBlockTime);
 404
 405 /**
 406  * Check if transaction is expired and can be included in a block with the
 407  * specified height. Consensus critical.
 408  */
 409 bool IsExpiredTx(const CTransaction &tx, int nBlockHeight);
 410
 411 /**
 412  * Check if transaction is expiring soon.  If yes, not propagating the transaction
 413  * can help DoS mitigation.  This is not consensus critical.
 414  */
 415 bool IsExpiringSoonTx(const CTransaction &tx, int nNextBlockHeight);
 416
 417 /**
 418  * Check if transaction will be final in the next block to be created.
 419  *
 420  * Calls IsFinalTx() with current block height and appropriate block time.
 421  *
 422  * See consensus/consensus.h for flag definitions.
 423  */
 424 bool CheckFinalTx(const CTransaction &tx, int flags = -1);
 425
 426 /**
 427  * Closure representing one script verification
 428  * Note that this stores references to the spending transaction
 429  */
 430 class CScriptCheck
 431 {
 432 private:
 433     CScript scriptPubKey;
 434     CAmount amount;
 435     const CTransaction *ptxTo;
 436     unsigned int nIn;
 437     unsigned int nFlags;
 438     bool cacheStore;
 439     uint32_t consensusBranchId;
 440     ScriptError error;
 441     PrecomputedTransactionData *txdata;
 442     std::map<uint160, std::pair<int, std::vector<std::vector<unsigned char>>>> idMap;
 443
 444 public:
 445     CScriptCheck(): amount(0), ptxTo(0), nIn(0), nFlags(0), cacheStore(false), consensusBranchId(0), error(SCRIPT_ERR_UNKNOWN_ERROR) {}
 446     CScriptCheck(const CCoins& txFromIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, bool cacheIn, uint32_t consensusBranchIdIn, PrecomputedTransactionData* txdataIn) :
 447         scriptPubKey(CCoinsViewCache::GetSpendFor(&txFromIn, txToIn.vin[nInIn])), amount(txFromIn.vout[txToIn.vin[nInIn].prevout.n].nValue),
 448         ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), cacheStore(cacheIn), consensusBranchId(consensusBranchIdIn), error(SCRIPT_ERR_UNKNOWN_ERROR), txdata(txdataIn) { }
 449
 450     bool operator()();
 451
 452     void swap(CScriptCheck &check) {
 453         scriptPubKey.swap(check.scriptPubKey);
 454         std::swap(ptxTo, check.ptxTo);
 455         std::swap(amount, check.amount);
 456         std::swap(nIn, check.nIn);
 457         std::swap(nFlags, check.nFlags);
 458         std::swap(cacheStore, check.cacheStore);
 459         std::swap(consensusBranchId, check.consensusBranchId);
 460         std::swap(error, check.error);
 461         std::swap(txdata, check.txdata);
 462         std::swap(idMap, check.idMap);
 463     }
 464
 465     void SetIDMap(const std::map<uint160, std::pair<int, std::vector<std::vector<unsigned char>>>> &map) { idMap = map; }
 466
 467     ScriptError GetScriptError() const { return error; }
 468 };
 469
 470 bool GetTimestampIndex(const unsigned int &high, const unsigned int &low, const bool fActiveOnly, std::vector<std::pair<uint256, unsigned int> > &hashes);
 471 bool GetSpentIndex(CSpentIndexKey &key, CSpentIndexValue &value);
 472 bool GetAddressIndex(const uint160& addressHash, int type, std::vector<CAddressIndexDbEntry> &addressIndex, int start = 0, int end = 0);
 473 bool GetAddressUnspent(const uint160& addressHash, int type, std::vector<CAddressUnspentDbEntry>& unspentOutputs);
 474
 475 /** Functions for disk access for blocks */
 476 bool WriteBlockToDisk(const CBlock& block, CDiskBlockPos& pos, const CMessageHeader::MessageStartChars& messageStart);
 477 bool ReadBlockFromDisk(int32_t height, CBlock& block, const CDiskBlockPos& pos, const Consensus::Params& consensusParams, bool checkPOW);
 478 bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex, const Consensus::Params& consensusParams, bool checkPOW);
 479 bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex, const Consensus::Params& consensusParams);
 480
 481 /** Functions for validating blocks and updating the block tree */
 482
 483 /** Undo the effects of this block (with given index) on the UTXO set represented by coins.
 484  *  In case pfClean is provided, operation will try to be tolerant about errors, and *pfClean
 485  *  will be true if no problems were found. Otherwise, the return value will be false in case
 486  *  of problems. Note that in any case, coins may be modified. */
 487 bool DisconnectBlock(CBlock& block, CValidationState& state, CBlockIndex* pindex, CCoinsViewCache& coins, bool* pfClean = NULL);
 488
 489 /** Apply the effects of this block (with given index) on the UTXO set represented by coins */
 490 bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pindex, CCoinsViewCache& coins,
 491                   const CChainParams& chainparams, bool fJustCheck = false,bool fCheckPOW = false);
 492
 493 /** Context-independent validity checks */
 494 bool CheckBlockHeader(int32_t *futureblockp,int32_t height,CBlockIndex *pindex,const CBlockHeader& block, CValidationState& state, const CChainParams& chainparams, bool fCheckPOW = true);
 495 bool CheckBlock(int32_t *futureblockp,int32_t height,CBlockIndex *pindex,const CBlock& block, CValidationState& state, const CChainParams& chainparams,
 496                 libzcash::ProofVerifier& verifier,
 497                 bool fCheckPOW = true, bool fCheckMerkleRoot = true, bool fCheckTxInputs = true);
 498
 499 /** Context-dependent validity checks.
 500  *  By "context", we mean only the previous block headers, but not the UTXO
 501  *  set; UTXO-related validity checks are done in ConnectBlock(). */
 502 bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationState& state,
 503                                 const CChainParams& chainparams, CBlockIndex *pindexPrev);
 504 bool ContextualCheckBlock(const CBlock& block, CValidationState& state,
 505                           const CChainParams& chainparams, CBlockIndex *pindexPrev);
 506
 507 /**
 508  * Store block on disk.
 509  * JoinSplit proofs are never verified, because:
 510  * - AcceptBlock doesn't perform script checks either.
 511  * - The only caller of AcceptBlock verifies JoinSplit proofs elsewhere.
 512  * If dbp is non-NULL, the file is known to already reside on disk
 513  */
 514 bool AcceptBlock(int32_t *futureblockp,CBlock& block, CValidationState& state, CBlockIndex **pindex, bool fRequested, CDiskBlockPos* dbp);
 515 bool AcceptBlockHeader(int32_t *futureblockp,const CBlockHeader& block, CValidationState& state, CBlockIndex **ppindex= NULL);
 516
 517 /** Check a block is completely valid from start to finish (only works on top of our current best block, with cs_main held) */
 518 bool TestBlockValidity(CValidationState& state, const CChainParams& chainparams, const CBlock& block, CBlockIndex* pindexPrev, bool fCheckPOW = true, bool fCheckMerkleRoot = true);
 519
 520
 521 /**
 522  * When there are blocks in the active chain with missing data (e.g. if the
 523  * activation height and branch ID of a particular upgrade have been altered),
 524  * rewind the chainstate and remove them from the block index.
 525  *
 526  * clearWitnessCaches is an output parameter that will be set to true iff
 527  * witness caches should be cleared in order to handle an intended long rewind.
 528  */
 529 bool RewindBlockIndex(const CChainParams& chainparams, bool& clearWitnessCaches);
 530
 531 /** RAII wrapper for VerifyDB: Verify consistency of the block and coin databases */
 532 class CVerifyDB {
 533 public:
 534     CVerifyDB();
 535     ~CVerifyDB();
 536     bool VerifyDB(const CChainParams& chainparams, CCoinsView *coinsview, int nCheckLevel, int nCheckDepth);
 537 };
 538
 539 /** Find the last common block between the parameter chain and a locator. */
 540 CBlockIndex* FindForkInGlobalIndex(const CChain& chain, const CBlockLocator& locator);
 541
 542 /** Mark a block as invalid. */
 543 bool InvalidateBlock(CValidationState& state, const CChainParams& chainparams, CBlockIndex *pindex);
 544
 545 /** Remove invalidity status from a block and its descendants. */
 546 bool ReconsiderBlock(CValidationState& state, CBlockIndex *pindex);
 547
 548 /** The currently-connected chain of blocks (protected by cs_main). */
 549 extern CChain chainActive;
 550
 551 /** Global variable that points to the active CCoinsView (protected by cs_main) */
 552 extern CCoinsViewCache *pcoinsTip;
 553
 554 /** Global variable that points to the active block tree (protected by cs_main) */
 555 extern CBlockTreeDB *pblocktree;
 556
 557 /**
 558  * Return the spend height, which is one more than the inputs.GetBestBlock().
 559  * While checking, GetBestBlock() refers to the parent block. (protected by cs_main)
 560  * This is also true for mempool checks.
 561  */
 562 int GetSpendHeight(const CCoinsViewCache& inputs);
 563
 564 uint64_t CalculateCurrentUsage();
 565
 566 /**
 567  * Return a CMutableTransaction with contextual default values based on set of consensus rules at nHeight. The expiryDelta will
 568  * either be based on the command-line argument '-txexpirydelta' or derived from consensusParams.
 569  */
 570 CMutableTransaction CreateNewContextualCMutableTransaction(const Consensus::Params& consensusParams, int nHeight);
 571
 572 /*
 573  * Ensures that this transaction has no outputs besides those related to earned notarization, which means it cannot be spent
 574  * to supply. This allows it to be safely included in a block, spending a normally unspendable output from the coinbase, without
 575  * actually increasing the available supply.
 576  */
 577 bool IsBlockBoundTransaction(const CTransaction &tx, const uint256 &cbHash);
 578
 579 /**
 580  * Sets the premine from chain definition
 581  */
 582 void InitializePremineSupply();
 583
 584 #endif // BITCOIN_MAIN_H