485 lines
21 KiB
C++
485 lines
21 KiB
C++
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|
// Copyright (c) 2009-2014 The Bitcoin Core developers
|
|
// Distributed under the MIT software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#ifndef BITCOIN_MAIN_H
|
|
#define BITCOIN_MAIN_H
|
|
|
|
#if defined(HAVE_CONFIG_H)
|
|
#include "config/bitcoin-config.h"
|
|
#endif
|
|
|
|
#include "amount.h"
|
|
#include "chain.h"
|
|
#include "coins.h"
|
|
#include "net.h"
|
|
#include "script/script_error.h"
|
|
#include "sync.h"
|
|
|
|
#include <algorithm>
|
|
#include <exception>
|
|
#include <map>
|
|
#include <set>
|
|
#include <stdint.h>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include <boost/unordered_map.hpp>
|
|
|
|
class CBlockIndex;
|
|
class CBlockTreeDB;
|
|
class CBloomFilter;
|
|
class CInv;
|
|
class CScriptCheck;
|
|
class CTxMemPool;
|
|
class CValidationInterface;
|
|
class CValidationState;
|
|
|
|
struct CNodeStateStats;
|
|
|
|
/** Default for accepting alerts from the P2P network. */
|
|
static const bool DEFAULT_ALERTS = true;
|
|
/** Default for -maxorphantx, maximum number of orphan transactions kept in memory */
|
|
static const unsigned int DEFAULT_MAX_ORPHAN_TRANSACTIONS = 100;
|
|
/** Default for -limitancestorcount, max number of in-mempool ancestors */
|
|
static const unsigned int DEFAULT_ANCESTOR_LIMIT = 100;
|
|
/** Default for -limitancestorsize, maximum kilobytes of tx + all in-mempool ancestors */
|
|
static const unsigned int DEFAULT_ANCESTOR_SIZE_LIMIT = 900;
|
|
/** Default for -limitdescendantcount, max number of in-mempool descendants */
|
|
static const unsigned int DEFAULT_DESCENDANT_LIMIT = 1000;
|
|
/** Default for -limitdescendantsize, maximum kilobytes of in-mempool descendants */
|
|
static const unsigned int DEFAULT_DESCENDANT_SIZE_LIMIT = 2500;
|
|
/** Default for -maxmempool, maximum megabytes of mempool memory usage */
|
|
static const unsigned int DEFAULT_MAX_MEMPOOL_SIZE = 300;
|
|
/** Default for -mempoolexpiry, expiration time for mempool transactions in hours */
|
|
static const unsigned int DEFAULT_MEMPOOL_EXPIRY = 72;
|
|
/** The maximum size of a blk?????.dat file (since 0.8) */
|
|
static const unsigned int MAX_BLOCKFILE_SIZE = 0x8000000; // 128 MiB
|
|
/** The pre-allocation chunk size for blk?????.dat files (since 0.8) */
|
|
static const unsigned int BLOCKFILE_CHUNK_SIZE = 0x1000000; // 16 MiB
|
|
/** The pre-allocation chunk size for rev?????.dat files (since 0.8) */
|
|
static const unsigned int UNDOFILE_CHUNK_SIZE = 0x100000; // 1 MiB
|
|
/** Maximum number of script-checking threads allowed */
|
|
static const int MAX_SCRIPTCHECK_THREADS = 16;
|
|
/** -par default (number of script-checking threads, 0 = auto) */
|
|
static const int DEFAULT_SCRIPTCHECK_THREADS = 0;
|
|
/** Number of blocks that can be requested at any given time from a single peer. */
|
|
static const int MAX_BLOCKS_IN_TRANSIT_PER_PEER = 16;
|
|
/** Timeout in seconds during which a peer must stall block download progress before being disconnected. */
|
|
static const unsigned int BLOCK_STALLING_TIMEOUT = 2;
|
|
/** Number of headers sent in one getheaders result. We rely on the assumption that if a peer sends
|
|
* less than this number, we reached its tip. Changing this value is a protocol upgrade. */
|
|
static const unsigned int MAX_HEADERS_RESULTS = 2000;
|
|
/** Size of the "block download window": how far ahead of our current height do we fetch?
|
|
* Larger windows tolerate larger download speed differences between peer, but increase the potential
|
|
* degree of disordering of blocks on disk (which make reindexing and in the future perhaps pruning
|
|
* harder). We'll probably want to make this a per-peer adaptive value at some point. */
|
|
static const unsigned int BLOCK_DOWNLOAD_WINDOW = 1024;
|
|
/** Time to wait (in seconds) between writing blocks/block index to disk. */
|
|
static const unsigned int DATABASE_WRITE_INTERVAL = 60 * 60;
|
|
/** Time to wait (in seconds) between flushing chainstate to disk. */
|
|
static const unsigned int DATABASE_FLUSH_INTERVAL = 24 * 60 * 60;
|
|
/** Maximum length of reject messages. */
|
|
static const unsigned int MAX_REJECT_MESSAGE_LENGTH = 111;
|
|
|
|
struct BlockHasher
|
|
{
|
|
size_t operator()(const uint256& hash) const { return hash.GetCheapHash(); }
|
|
};
|
|
|
|
extern CScript COINBASE_FLAGS;
|
|
extern CCriticalSection cs_main;
|
|
extern CTxMemPool mempool;
|
|
typedef boost::unordered_map<uint256, CBlockIndex*, BlockHasher> BlockMap;
|
|
extern BlockMap mapBlockIndex;
|
|
extern uint64_t nLastBlockTx;
|
|
extern uint64_t nLastBlockSize;
|
|
extern const std::string strMessageMagic;
|
|
extern CWaitableCriticalSection csBestBlock;
|
|
extern CConditionVariable cvBlockChange;
|
|
extern bool fImporting;
|
|
extern bool fReindex;
|
|
extern int nScriptCheckThreads;
|
|
extern bool fTxIndex;
|
|
extern bool fIsBareMultisigStd;
|
|
extern bool fRequireStandard;
|
|
extern bool fCheckBlockIndex;
|
|
extern bool fCheckpointsEnabled;
|
|
extern size_t nCoinCacheUsage;
|
|
extern CFeeRate minRelayTxFee;
|
|
extern bool fAlerts;
|
|
|
|
/** Best header we've seen so far (used for getheaders queries' starting points). */
|
|
extern CBlockIndex *pindexBestHeader;
|
|
|
|
/** Minimum disk space required - used in CheckDiskSpace() */
|
|
static const uint64_t nMinDiskSpace = 52428800;
|
|
|
|
/** Pruning-related variables and constants */
|
|
/** True if any block files have ever been pruned. */
|
|
extern bool fHavePruned;
|
|
/** True if we're running in -prune mode. */
|
|
extern bool fPruneMode;
|
|
/** Number of MiB of block files that we're trying to stay below. */
|
|
extern uint64_t nPruneTarget;
|
|
/** Block files containing a block-height within MIN_BLOCKS_TO_KEEP of chainActive.Tip() will not be pruned. */
|
|
static const unsigned int MIN_BLOCKS_TO_KEEP = 288;
|
|
|
|
static const signed int DEFAULT_CHECKBLOCKS = MIN_BLOCKS_TO_KEEP;
|
|
static const unsigned int DEFAULT_CHECKLEVEL = 3;
|
|
|
|
// Require that user allocate at least 550MB for block & undo files (blk???.dat and rev???.dat)
|
|
// At 1MB per block, 288 blocks = 288MB.
|
|
// Add 15% for Undo data = 331MB
|
|
// Add 20% for Orphan block rate = 397MB
|
|
// We want the low water mark after pruning to be at least 397 MB and since we prune in
|
|
// full block file chunks, we need the high water mark which triggers the prune to be
|
|
// one 128MB block file + added 15% undo data = 147MB greater for a total of 545MB
|
|
// Setting the target to > than 550MB will make it likely we can respect the target.
|
|
static const uint64_t MIN_DISK_SPACE_FOR_BLOCK_FILES = 550 * 1024 * 1024;
|
|
|
|
/** Register with a network node to receive its signals */
|
|
void RegisterNodeSignals(CNodeSignals& nodeSignals);
|
|
/** Unregister a network node */
|
|
void UnregisterNodeSignals(CNodeSignals& nodeSignals);
|
|
|
|
/**
|
|
* Process an incoming block. This only returns after the best known valid
|
|
* block is made active. Note that it does not, however, guarantee that the
|
|
* specific block passed to it has been checked for validity!
|
|
*
|
|
* @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.
|
|
* @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.
|
|
* @param[in] pblock The block we want to process.
|
|
* @param[in] fForceProcessing Process this block even if unrequested; used for non-network block sources and whitelisted peers.
|
|
* @param[out] dbp If pblock is stored to disk (or already there), this will be set to its location.
|
|
* @return True if state.IsValid()
|
|
*/
|
|
bool ProcessNewBlock(CValidationState &state, const CNode* pfrom, const CBlock* pblock, bool fForceProcessing, CDiskBlockPos *dbp);
|
|
/** Check whether enough disk space is available for an incoming block */
|
|
bool CheckDiskSpace(uint64_t nAdditionalBytes = 0);
|
|
/** Open a block file (blk?????.dat) */
|
|
FILE* OpenBlockFile(const CDiskBlockPos &pos, bool fReadOnly = false);
|
|
/** Open an undo file (rev?????.dat) */
|
|
FILE* OpenUndoFile(const CDiskBlockPos &pos, bool fReadOnly = false);
|
|
/** Translation to a filesystem path */
|
|
boost::filesystem::path GetBlockPosFilename(const CDiskBlockPos &pos, const char *prefix);
|
|
/** Import blocks from an external file */
|
|
bool LoadExternalBlockFile(FILE* fileIn, CDiskBlockPos *dbp = NULL);
|
|
/** Initialize a new block tree database + block data on disk */
|
|
bool InitBlockIndex();
|
|
/** Load the block tree and coins database from disk */
|
|
bool LoadBlockIndex();
|
|
/** Unload database information */
|
|
void UnloadBlockIndex();
|
|
/** Process protocol messages received from a given node */
|
|
bool ProcessMessages(CNode* pfrom);
|
|
/**
|
|
* Send queued protocol messages to be sent to a give node.
|
|
*
|
|
* @param[in] pto The node which we are sending messages to.
|
|
* @param[in] fSendTrickle When true send the trickled data, otherwise trickle the data until true.
|
|
*/
|
|
bool SendMessages(CNode* pto, bool fSendTrickle);
|
|
/** Run an instance of the script checking thread */
|
|
void ThreadScriptCheck();
|
|
/** Try to detect Partition (network isolation) attacks against us */
|
|
void PartitionCheck(bool (*initialDownloadCheck)(), CCriticalSection& cs, const CBlockIndex *const &bestHeader, int64_t nPowTargetSpacing);
|
|
/** Check whether we are doing an initial block download (synchronizing from disk or network) */
|
|
bool IsInitialBlockDownload();
|
|
/** Format a string that describes several potential problems detected by the core */
|
|
std::string GetWarnings(const std::string& strFor);
|
|
/** Retrieve a transaction (from memory pool, or from disk, if possible) */
|
|
bool GetTransaction(const uint256 &hash, CTransaction &tx, const Consensus::Params& params, uint256 &hashBlock, bool fAllowSlow = false);
|
|
/** Find the best known block, and make it the tip of the block chain */
|
|
bool ActivateBestChain(CValidationState &state, const CBlock *pblock = NULL);
|
|
CAmount GetBlockSubsidy(int nHeight, const Consensus::Params& consensusParams);
|
|
|
|
/**
|
|
* Prune block and undo files (blk???.dat and undo???.dat) so that the disk space used is less than a user-defined target.
|
|
* The user sets the target (in MB) on the command line or in config file. This will be run on startup and whenever new
|
|
* space is allocated in a block or undo file, staying below the target. Changing back to unpruned requires a reindex
|
|
* (which in this case means the blockchain must be re-downloaded.)
|
|
*
|
|
* Pruning functions are called from FlushStateToDisk when the global fCheckForPruning flag has been set.
|
|
* Block and undo files are deleted in lock-step (when blk00003.dat is deleted, so is rev00003.dat.)
|
|
* Pruning cannot take place until the longest chain is at least a certain length (100000 on mainnet, 1000 on testnet, 10 on regtest).
|
|
* Pruning will never delete a block within a defined distance (currently 288) from the active chain's tip.
|
|
* The block index is updated by unsetting HAVE_DATA and HAVE_UNDO for any blocks that were stored in the deleted files.
|
|
* A db flag records the fact that at least some block files have been pruned.
|
|
*
|
|
* @param[out] setFilesToPrune The set of file indices that can be unlinked will be returned
|
|
*/
|
|
void FindFilesToPrune(std::set<int>& setFilesToPrune);
|
|
|
|
/**
|
|
* Actually unlink the specified files
|
|
*/
|
|
void UnlinkPrunedFiles(std::set<int>& setFilesToPrune);
|
|
|
|
/** Create a new block index entry for a given block hash */
|
|
CBlockIndex * InsertBlockIndex(uint256 hash);
|
|
/** Get statistics from node state */
|
|
bool GetNodeStateStats(NodeId nodeid, CNodeStateStats &stats);
|
|
/** Increase a node's misbehavior score. */
|
|
void Misbehaving(NodeId nodeid, int howmuch);
|
|
/** Flush all state, indexes and buffers to disk. */
|
|
void FlushStateToDisk();
|
|
/** Prune block files and flush state to disk. */
|
|
void PruneAndFlush();
|
|
|
|
/** (try to) add transaction to memory pool **/
|
|
bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransaction &tx, bool fLimitFree,
|
|
bool* pfMissingInputs, bool fOverrideMempoolLimit=false, bool fRejectAbsurdFee=false);
|
|
|
|
|
|
struct CNodeStateStats {
|
|
int nMisbehavior;
|
|
int nSyncHeight;
|
|
int nCommonHeight;
|
|
std::vector<int> vHeightInFlight;
|
|
};
|
|
|
|
struct CDiskTxPos : public CDiskBlockPos
|
|
{
|
|
unsigned int nTxOffset; // after header
|
|
|
|
ADD_SERIALIZE_METHODS;
|
|
|
|
template <typename Stream, typename Operation>
|
|
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
|
|
READWRITE(*(CDiskBlockPos*)this);
|
|
READWRITE(VARINT(nTxOffset));
|
|
}
|
|
|
|
CDiskTxPos(const CDiskBlockPos &blockIn, unsigned int nTxOffsetIn) : CDiskBlockPos(blockIn.nFile, blockIn.nPos), nTxOffset(nTxOffsetIn) {
|
|
}
|
|
|
|
CDiskTxPos() {
|
|
SetNull();
|
|
}
|
|
|
|
void SetNull() {
|
|
CDiskBlockPos::SetNull();
|
|
nTxOffset = 0;
|
|
}
|
|
};
|
|
|
|
|
|
CAmount GetMinRelayFee(const CTransaction& tx, unsigned int nBytes, bool fAllowFree);
|
|
|
|
/**
|
|
* Count ECDSA signature operations the old-fashioned (pre-0.6) way
|
|
* @return number of sigops this transaction's outputs will produce when spent
|
|
* @see CTransaction::FetchInputs
|
|
*/
|
|
unsigned int GetLegacySigOpCount(const CTransaction& tx);
|
|
|
|
/**
|
|
* Count ECDSA signature operations in pay-to-script-hash inputs.
|
|
*
|
|
* @param[in] mapInputs Map of previous transactions that have outputs we're spending
|
|
* @return maximum number of sigops required to validate this transaction's inputs
|
|
* @see CTransaction::FetchInputs
|
|
*/
|
|
unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewCache& mapInputs);
|
|
|
|
|
|
/**
|
|
* Check whether all inputs of this transaction are valid (no double spends, scripts & sigs, amounts)
|
|
* This does not modify the UTXO set. If pvChecks is not NULL, script checks are pushed onto it
|
|
* instead of being performed inline.
|
|
*/
|
|
bool CheckInputs(const CTransaction& tx, CValidationState &state, const CCoinsViewCache &view, bool fScriptChecks,
|
|
unsigned int flags, bool cacheStore, std::vector<CScriptCheck> *pvChecks = NULL);
|
|
|
|
/** Apply the effects of this transaction on the UTXO set represented by view */
|
|
void UpdateCoins(const CTransaction& tx, CValidationState &state, CCoinsViewCache &inputs, int nHeight);
|
|
|
|
/** Context-independent validity checks */
|
|
bool CheckTransaction(const CTransaction& tx, CValidationState& state);
|
|
|
|
/**
|
|
* Check if transaction is final and can be included in a block with the
|
|
* specified height and time. Consensus critical.
|
|
*/
|
|
bool IsFinalTx(const CTransaction &tx, int nBlockHeight, int64_t nBlockTime);
|
|
|
|
/**
|
|
* Check if transaction will be final in the next block to be created.
|
|
*
|
|
* Calls IsFinalTx() with current block height and appropriate block time.
|
|
*
|
|
* See consensus/consensus.h for flag definitions.
|
|
*/
|
|
bool CheckFinalTx(const CTransaction &tx, int flags = -1);
|
|
|
|
/**
|
|
* Closure representing one script verification
|
|
* Note that this stores references to the spending transaction
|
|
*/
|
|
class CScriptCheck
|
|
{
|
|
private:
|
|
CScript scriptPubKey;
|
|
const CTransaction *ptxTo;
|
|
unsigned int nIn;
|
|
unsigned int nFlags;
|
|
bool cacheStore;
|
|
ScriptError error;
|
|
|
|
public:
|
|
CScriptCheck(): ptxTo(0), nIn(0), nFlags(0), cacheStore(false), error(SCRIPT_ERR_UNKNOWN_ERROR) {}
|
|
CScriptCheck(const CCoins& txFromIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, bool cacheIn) :
|
|
scriptPubKey(txFromIn.vout[txToIn.vin[nInIn].prevout.n].scriptPubKey),
|
|
ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), cacheStore(cacheIn), error(SCRIPT_ERR_UNKNOWN_ERROR) { }
|
|
|
|
bool operator()();
|
|
|
|
void swap(CScriptCheck &check) {
|
|
scriptPubKey.swap(check.scriptPubKey);
|
|
std::swap(ptxTo, check.ptxTo);
|
|
std::swap(nIn, check.nIn);
|
|
std::swap(nFlags, check.nFlags);
|
|
std::swap(cacheStore, check.cacheStore);
|
|
std::swap(error, check.error);
|
|
}
|
|
|
|
ScriptError GetScriptError() const { return error; }
|
|
};
|
|
|
|
|
|
/** Functions for disk access for blocks */
|
|
bool WriteBlockToDisk(const CBlock& block, CDiskBlockPos& pos, const CMessageHeader::MessageStartChars& messageStart);
|
|
bool ReadBlockFromDisk(CBlock& block, const CDiskBlockPos& pos, const Consensus::Params& consensusParams);
|
|
bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex, const Consensus::Params& consensusParams);
|
|
|
|
/** Functions for validating blocks and updating the block tree */
|
|
|
|
/** Undo the effects of this block (with given index) on the UTXO set represented by coins.
|
|
* In case pfClean is provided, operation will try to be tolerant about errors, and *pfClean
|
|
* will be true if no problems were found. Otherwise, the return value will be false in case
|
|
* of problems. Note that in any case, coins may be modified. */
|
|
bool DisconnectBlock(const CBlock& block, CValidationState& state, const CBlockIndex* pindex, CCoinsViewCache& coins, bool* pfClean = NULL);
|
|
|
|
/** Apply the effects of this block (with given index) on the UTXO set represented by coins */
|
|
bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pindex, CCoinsViewCache& coins, bool fJustCheck = false);
|
|
|
|
/** Context-independent validity checks */
|
|
bool CheckBlockHeader(const CBlockHeader& block, CValidationState& state, bool fCheckPOW = true);
|
|
bool CheckBlock(const CBlock& block, CValidationState& state, bool fCheckPOW = true, bool fCheckMerkleRoot = true);
|
|
|
|
/** Context-dependent validity checks */
|
|
bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationState& state, CBlockIndex *pindexPrev);
|
|
bool ContextualCheckBlock(const CBlock& block, CValidationState& state, CBlockIndex *pindexPrev);
|
|
|
|
/** Check a block is completely valid from start to finish (only works on top of our current best block, with cs_main held) */
|
|
bool TestBlockValidity(CValidationState &state, const CBlock& block, CBlockIndex *pindexPrev, bool fCheckPOW = true, bool fCheckMerkleRoot = true);
|
|
|
|
/** Store block on disk. If dbp is non-NULL, the file is known to already reside on disk */
|
|
bool AcceptBlock(const CBlock& block, CValidationState& state, CBlockIndex **pindex, bool fRequested, CDiskBlockPos* dbp);
|
|
bool AcceptBlockHeader(const CBlockHeader& block, CValidationState& state, const Consensus::Params& consensusParams, CBlockIndex **ppindex= NULL);
|
|
|
|
|
|
class CBlockFileInfo
|
|
{
|
|
public:
|
|
unsigned int nBlocks; //! number of blocks stored in file
|
|
unsigned int nSize; //! number of used bytes of block file
|
|
unsigned int nUndoSize; //! number of used bytes in the undo file
|
|
unsigned int nHeightFirst; //! lowest height of block in file
|
|
unsigned int nHeightLast; //! highest height of block in file
|
|
uint64_t nTimeFirst; //! earliest time of block in file
|
|
uint64_t nTimeLast; //! latest time of block in file
|
|
|
|
ADD_SERIALIZE_METHODS;
|
|
|
|
template <typename Stream, typename Operation>
|
|
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
|
|
READWRITE(VARINT(nBlocks));
|
|
READWRITE(VARINT(nSize));
|
|
READWRITE(VARINT(nUndoSize));
|
|
READWRITE(VARINT(nHeightFirst));
|
|
READWRITE(VARINT(nHeightLast));
|
|
READWRITE(VARINT(nTimeFirst));
|
|
READWRITE(VARINT(nTimeLast));
|
|
}
|
|
|
|
void SetNull() {
|
|
nBlocks = 0;
|
|
nSize = 0;
|
|
nUndoSize = 0;
|
|
nHeightFirst = 0;
|
|
nHeightLast = 0;
|
|
nTimeFirst = 0;
|
|
nTimeLast = 0;
|
|
}
|
|
|
|
CBlockFileInfo() {
|
|
SetNull();
|
|
}
|
|
|
|
std::string ToString() const;
|
|
|
|
/** update statistics (does not update nSize) */
|
|
void AddBlock(unsigned int nHeightIn, uint64_t nTimeIn) {
|
|
if (nBlocks==0 || nHeightFirst > nHeightIn)
|
|
nHeightFirst = nHeightIn;
|
|
if (nBlocks==0 || nTimeFirst > nTimeIn)
|
|
nTimeFirst = nTimeIn;
|
|
nBlocks++;
|
|
if (nHeightIn > nHeightLast)
|
|
nHeightLast = nHeightIn;
|
|
if (nTimeIn > nTimeLast)
|
|
nTimeLast = nTimeIn;
|
|
}
|
|
};
|
|
|
|
/** RAII wrapper for VerifyDB: Verify consistency of the block and coin databases */
|
|
class CVerifyDB {
|
|
public:
|
|
CVerifyDB();
|
|
~CVerifyDB();
|
|
bool VerifyDB(CCoinsView *coinsview, int nCheckLevel, int nCheckDepth);
|
|
};
|
|
|
|
/** Find the last common block between the parameter chain and a locator. */
|
|
CBlockIndex* FindForkInGlobalIndex(const CChain& chain, const CBlockLocator& locator);
|
|
|
|
/** Mark a block as invalid. */
|
|
bool InvalidateBlock(CValidationState& state, const Consensus::Params& consensusParams, CBlockIndex *pindex);
|
|
|
|
/** Remove invalidity status from a block and its descendants. */
|
|
bool ReconsiderBlock(CValidationState& state, CBlockIndex *pindex);
|
|
|
|
/** The currently-connected chain of blocks. */
|
|
extern CChain chainActive;
|
|
|
|
/** Global variable that points to the active CCoinsView (protected by cs_main) */
|
|
extern CCoinsViewCache *pcoinsTip;
|
|
|
|
/** Global variable that points to the active block tree (protected by cs_main) */
|
|
extern CBlockTreeDB *pblocktree;
|
|
|
|
/**
|
|
* Return the spend height, which is one more than the inputs.GetBestBlock().
|
|
* While checking, GetBestBlock() refers to the parent block. (protected by cs_main)
|
|
* This is also true for mempool checks.
|
|
*/
|
|
int GetSpendHeight(const CCoinsViewCache& inputs);
|
|
|
|
/** Reject codes greater or equal to this can be returned by AcceptToMemPool
|
|
* for transactions, to signal internal conditions. They cannot and should not
|
|
* be sent over the P2P network.
|
|
*/
|
|
static const unsigned int REJECT_INTERNAL = 0x100;
|
|
/** Too high fee. Can not be triggered by P2P transactions */
|
|
static const unsigned int REJECT_HIGHFEE = 0x100;
|
|
/** Transaction is already known (either in mempool or blockchain) */
|
|
static const unsigned int REJECT_ALREADY_KNOWN = 0x101;
|
|
/** Transaction conflicts with a transaction already known */
|
|
static const unsigned int REJECT_CONFLICT = 0x102;
|
|
|
|
#endif // BITCOIN_MAIN_H
|