785adad57e
* slightly refactor IS: - the only place where logic is changed: `ProcessTxLockVote()` - it should first try to find mn and fail if none was found and only then try to call `GetMasternodeRank()` (which is heavy) - fixed few `cs_main` - slightly optimized number of `tx.GetHash()` calls - lots of `const` (fixed few related functions in main.cpp) - few smaller fixes: iterators, log output, comments, etc - use thread safe methods of mnodeman - safety check in GetAverageUnknownVoteTime
866 lines
33 KiB
C++
866 lines
33 KiB
C++
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|
// Copyright (c) 2009-2015 The Bitcoin Core developers
|
|
// Copyright (c) 2014-2016 The Dash 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/dash-config.h"
|
|
#endif
|
|
|
|
#include "amount.h"
|
|
#include "chain.h"
|
|
#include "coins.h"
|
|
#include "net.h"
|
|
#include "script/script_error.h"
|
|
#include "sync.h"
|
|
#include "versionbits.h"
|
|
#include "spentindex.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 CChainParams;
|
|
class CInv;
|
|
class CScriptCheck;
|
|
class CTxMemPool;
|
|
class CValidationInterface;
|
|
class CValidationState;
|
|
|
|
struct CNodeStateStats;
|
|
struct LockPoints;
|
|
|
|
/** Default for accepting alerts from the P2P network. */
|
|
static const bool DEFAULT_ALERTS = false;
|
|
/** Default for DEFAULT_WHITELISTRELAY. */
|
|
static const bool DEFAULT_WHITELISTRELAY = true;
|
|
/** Default for DEFAULT_WHITELISTFORCERELAY. */
|
|
static const bool DEFAULT_WHITELISTFORCERELAY = true;
|
|
/** Default for -minrelaytxfee, minimum relay fee for transactions
|
|
* We are ~100 times smaller then bitcoin now (2016-03-01), set minRelayTxFee only 10 times higher
|
|
* so it's still 10 times lower comparing to bitcoin.
|
|
*/
|
|
static const unsigned int DEFAULT_MIN_RELAY_TX_FEE = 10000; // was 1000
|
|
/** 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 = 25;
|
|
/** Default for -limitancestorsize, maximum kilobytes of tx + all in-mempool ancestors */
|
|
static const unsigned int DEFAULT_ANCESTOR_SIZE_LIMIT = 101;
|
|
/** Default for -limitdescendantcount, max number of in-mempool descendants */
|
|
static const unsigned int DEFAULT_DESCENDANT_LIMIT = 25;
|
|
/** Default for -limitdescendantsize, maximum kilobytes of in-mempool descendants */
|
|
static const unsigned int DEFAULT_DESCENDANT_SIZE_LIMIT = 101;
|
|
/** 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;
|
|
/** Average delay between local address broadcasts in seconds. */
|
|
static const unsigned int AVG_LOCAL_ADDRESS_BROADCAST_INTERVAL = 24 * 24 * 60;
|
|
/** Average delay between peer address broadcasts in seconds. */
|
|
static const unsigned int AVG_ADDRESS_BROADCAST_INTERVAL = 30;
|
|
/** Average delay between trickled inventory broadcasts in seconds.
|
|
* Blocks, whitelisted receivers, and a random 25% of transactions bypass this. */
|
|
static const unsigned int AVG_INVENTORY_BROADCAST_INTERVAL = 5;
|
|
/** Block download timeout base, expressed in millionths of the block interval (i.e. 2.5 min) */
|
|
static const int64_t BLOCK_DOWNLOAD_TIMEOUT_BASE = 250000;
|
|
/** Additional block download timeout per parallel downloading peer (i.e. 1.25 min) */
|
|
static const int64_t BLOCK_DOWNLOAD_TIMEOUT_PER_PEER = 125000;
|
|
|
|
static const unsigned int DEFAULT_LIMITFREERELAY = 15;
|
|
static const bool DEFAULT_RELAYPRIORITY = true;
|
|
|
|
/** Default for -permitbaremultisig */
|
|
static const bool DEFAULT_PERMIT_BAREMULTISIG = true;
|
|
static const unsigned int DEFAULT_BYTES_PER_SIGOP = 20;
|
|
static const bool DEFAULT_CHECKPOINTS_ENABLED = true;
|
|
static const bool DEFAULT_TXINDEX = true;
|
|
static const bool DEFAULT_ADDRESSINDEX = false;
|
|
static const bool DEFAULT_TIMESTAMPINDEX = false;
|
|
static const bool DEFAULT_SPENTINDEX = false;
|
|
static const unsigned int DEFAULT_BANSCORE_THRESHOLD = 100;
|
|
|
|
static const bool DEFAULT_TESTSAFEMODE = false;
|
|
/** Default for -mempoolreplacement */
|
|
static const bool DEFAULT_ENABLE_REPLACEMENT = false;
|
|
|
|
/** Maximum number of headers to announce when relaying blocks with headers message.*/
|
|
static const unsigned int MAX_BLOCKS_TO_ANNOUNCE = 8;
|
|
|
|
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 unsigned int nBytesPerSigOp;
|
|
extern bool fCheckBlockIndex;
|
|
extern bool fCheckpointsEnabled;
|
|
extern size_t nCoinCacheUsage;
|
|
extern CFeeRate minRelayTxFee;
|
|
extern bool fAlerts;
|
|
extern bool fEnableReplacement;
|
|
|
|
extern std::map<uint256, int64_t> mapRejectedBlocks;
|
|
|
|
/** 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 CChainParams& chainparams, 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(const CChainParams& chainparams, FILE* fileIn, CDiskBlockPos *dbp = NULL);
|
|
/** Initialize a new block tree database + block data on disk */
|
|
bool InitBlockIndex(const CChainParams& chainparams);
|
|
/** 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.
|
|
*/
|
|
bool SendMessages(CNode* pto);
|
|
/** 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.
|
|
* strFor can have three values:
|
|
* - "rpc": get critical warnings, which should put the client in safe mode if non-empty
|
|
* - "statusbar": get all warnings
|
|
* - "gui": get all warnings, translated (where possible) for GUI
|
|
* This function only returns the highest priority warning of the set selected by strFor.
|
|
*/
|
|
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 CChainParams& chainparams, const CBlock* pblock = NULL);
|
|
|
|
double ConvertBitsToDouble(unsigned int nBits);
|
|
int64_t GetTotalCoinEstimate(int nHeight);
|
|
CAmount GetBlockSubsidy(int nBits, int nHeight, const Consensus::Params& consensusParams, bool fSuperblockPartOnly = false);
|
|
CAmount GetMasternodePayment(int nHeight, CAmount blockValue);
|
|
|
|
/**
|
|
* 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, 1000 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, uint64_t nPruneAfterHeight);
|
|
|
|
/**
|
|
* 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, bool fDryRun=false);
|
|
|
|
int GetInputAge(const CTxIn &txin);
|
|
int GetInputAgeIX(const uint256 &nTXHash, const CTxIn &txin);
|
|
int GetIXConfirmations(const uint256 &nTXHash);
|
|
|
|
/** Convert CValidationState to a human-readable message for logging */
|
|
std::string FormatStateMessage(const CValidationState &state);
|
|
|
|
/** Get the BIP9 state for a given deployment at the current tip. */
|
|
ThresholdState VersionBitsTipState(const Consensus::Params& params, Consensus::DeploymentPos pos);
|
|
|
|
struct CNodeStateStats {
|
|
int nMisbehavior;
|
|
int nSyncHeight;
|
|
int nCommonHeight;
|
|
std::vector<int> vHeightInFlight;
|
|
};
|
|
|
|
struct CTimestampIndexIteratorKey {
|
|
unsigned int timestamp;
|
|
|
|
size_t GetSerializeSize(int nType, int nVersion) const {
|
|
return 4;
|
|
}
|
|
template<typename Stream>
|
|
void Serialize(Stream& s, int nType, int nVersion) const {
|
|
ser_writedata32be(s, timestamp);
|
|
}
|
|
template<typename Stream>
|
|
void Unserialize(Stream& s, int nType, int nVersion) {
|
|
timestamp = ser_readdata32be(s);
|
|
}
|
|
|
|
CTimestampIndexIteratorKey(unsigned int time) {
|
|
timestamp = time;
|
|
}
|
|
|
|
CTimestampIndexIteratorKey() {
|
|
SetNull();
|
|
}
|
|
|
|
void SetNull() {
|
|
timestamp = 0;
|
|
}
|
|
};
|
|
|
|
struct CTimestampIndexKey {
|
|
unsigned int timestamp;
|
|
uint256 blockHash;
|
|
|
|
size_t GetSerializeSize(int nType, int nVersion) const {
|
|
return 36;
|
|
}
|
|
template<typename Stream>
|
|
void Serialize(Stream& s, int nType, int nVersion) const {
|
|
ser_writedata32be(s, timestamp);
|
|
blockHash.Serialize(s, nType, nVersion);
|
|
}
|
|
template<typename Stream>
|
|
void Unserialize(Stream& s, int nType, int nVersion) {
|
|
timestamp = ser_readdata32be(s);
|
|
blockHash.Unserialize(s, nType, nVersion);
|
|
}
|
|
|
|
CTimestampIndexKey(unsigned int time, uint256 hash) {
|
|
timestamp = time;
|
|
blockHash = hash;
|
|
}
|
|
|
|
CTimestampIndexKey() {
|
|
SetNull();
|
|
}
|
|
|
|
void SetNull() {
|
|
timestamp = 0;
|
|
blockHash.SetNull();
|
|
}
|
|
};
|
|
|
|
struct CAddressUnspentKey {
|
|
unsigned int type;
|
|
uint160 hashBytes;
|
|
uint256 txhash;
|
|
size_t index;
|
|
|
|
size_t GetSerializeSize(int nType, int nVersion) const {
|
|
return 57;
|
|
}
|
|
template<typename Stream>
|
|
void Serialize(Stream& s, int nType, int nVersion) const {
|
|
ser_writedata8(s, type);
|
|
hashBytes.Serialize(s, nType, nVersion);
|
|
txhash.Serialize(s, nType, nVersion);
|
|
ser_writedata32(s, index);
|
|
}
|
|
template<typename Stream>
|
|
void Unserialize(Stream& s, int nType, int nVersion) {
|
|
type = ser_readdata8(s);
|
|
hashBytes.Unserialize(s, nType, nVersion);
|
|
txhash.Unserialize(s, nType, nVersion);
|
|
index = ser_readdata32(s);
|
|
}
|
|
|
|
CAddressUnspentKey(unsigned int addressType, uint160 addressHash, uint256 txid, size_t indexValue) {
|
|
type = addressType;
|
|
hashBytes = addressHash;
|
|
txhash = txid;
|
|
index = indexValue;
|
|
}
|
|
|
|
CAddressUnspentKey() {
|
|
SetNull();
|
|
}
|
|
|
|
void SetNull() {
|
|
type = 0;
|
|
hashBytes.SetNull();
|
|
txhash.SetNull();
|
|
index = 0;
|
|
}
|
|
};
|
|
|
|
struct CAddressUnspentValue {
|
|
CAmount satoshis;
|
|
CScript script;
|
|
int blockHeight;
|
|
|
|
ADD_SERIALIZE_METHODS;
|
|
|
|
template <typename Stream, typename Operation>
|
|
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
|
|
READWRITE(satoshis);
|
|
READWRITE(*(CScriptBase*)(&script));
|
|
READWRITE(blockHeight);
|
|
}
|
|
|
|
CAddressUnspentValue(CAmount sats, CScript scriptPubKey, int height) {
|
|
satoshis = sats;
|
|
script = scriptPubKey;
|
|
blockHeight = height;
|
|
}
|
|
|
|
CAddressUnspentValue() {
|
|
SetNull();
|
|
}
|
|
|
|
void SetNull() {
|
|
satoshis = -1;
|
|
script.clear();
|
|
blockHeight = 0;
|
|
}
|
|
|
|
bool IsNull() const {
|
|
return (satoshis == -1);
|
|
}
|
|
};
|
|
|
|
struct CAddressIndexKey {
|
|
unsigned int type;
|
|
uint160 hashBytes;
|
|
int blockHeight;
|
|
unsigned int txindex;
|
|
uint256 txhash;
|
|
size_t index;
|
|
bool spending;
|
|
|
|
size_t GetSerializeSize(int nType, int nVersion) const {
|
|
return 66;
|
|
}
|
|
template<typename Stream>
|
|
void Serialize(Stream& s, int nType, int nVersion) const {
|
|
ser_writedata8(s, type);
|
|
hashBytes.Serialize(s, nType, nVersion);
|
|
// Heights are stored big-endian for key sorting in LevelDB
|
|
ser_writedata32be(s, blockHeight);
|
|
ser_writedata32be(s, txindex);
|
|
txhash.Serialize(s, nType, nVersion);
|
|
ser_writedata32(s, index);
|
|
char f = spending;
|
|
ser_writedata8(s, f);
|
|
}
|
|
template<typename Stream>
|
|
void Unserialize(Stream& s, int nType, int nVersion) {
|
|
type = ser_readdata8(s);
|
|
hashBytes.Unserialize(s, nType, nVersion);
|
|
blockHeight = ser_readdata32be(s);
|
|
txindex = ser_readdata32be(s);
|
|
txhash.Unserialize(s, nType, nVersion);
|
|
index = ser_readdata32(s);
|
|
char f = ser_readdata8(s);
|
|
spending = f;
|
|
}
|
|
|
|
CAddressIndexKey(unsigned int addressType, uint160 addressHash, int height, int blockindex,
|
|
uint256 txid, size_t indexValue, bool isSpending) {
|
|
type = addressType;
|
|
hashBytes = addressHash;
|
|
blockHeight = height;
|
|
txindex = blockindex;
|
|
txhash = txid;
|
|
index = indexValue;
|
|
spending = isSpending;
|
|
}
|
|
|
|
CAddressIndexKey() {
|
|
SetNull();
|
|
}
|
|
|
|
void SetNull() {
|
|
type = 0;
|
|
hashBytes.SetNull();
|
|
blockHeight = 0;
|
|
txindex = 0;
|
|
txhash.SetNull();
|
|
index = 0;
|
|
spending = false;
|
|
}
|
|
|
|
};
|
|
|
|
struct CAddressIndexIteratorKey {
|
|
unsigned int type;
|
|
uint160 hashBytes;
|
|
|
|
size_t GetSerializeSize(int nType, int nVersion) const {
|
|
return 21;
|
|
}
|
|
template<typename Stream>
|
|
void Serialize(Stream& s, int nType, int nVersion) const {
|
|
ser_writedata8(s, type);
|
|
hashBytes.Serialize(s, nType, nVersion);
|
|
}
|
|
template<typename Stream>
|
|
void Unserialize(Stream& s, int nType, int nVersion) {
|
|
type = ser_readdata8(s);
|
|
hashBytes.Unserialize(s, nType, nVersion);
|
|
}
|
|
|
|
CAddressIndexIteratorKey(unsigned int addressType, uint160 addressHash) {
|
|
type = addressType;
|
|
hashBytes = addressHash;
|
|
}
|
|
|
|
CAddressIndexIteratorKey() {
|
|
SetNull();
|
|
}
|
|
|
|
void SetNull() {
|
|
type = 0;
|
|
hashBytes.SetNull();
|
|
}
|
|
};
|
|
|
|
struct CAddressIndexIteratorHeightKey {
|
|
unsigned int type;
|
|
uint160 hashBytes;
|
|
int blockHeight;
|
|
|
|
size_t GetSerializeSize(int nType, int nVersion) const {
|
|
return 25;
|
|
}
|
|
template<typename Stream>
|
|
void Serialize(Stream& s, int nType, int nVersion) const {
|
|
ser_writedata8(s, type);
|
|
hashBytes.Serialize(s, nType, nVersion);
|
|
ser_writedata32be(s, blockHeight);
|
|
}
|
|
template<typename Stream>
|
|
void Unserialize(Stream& s, int nType, int nVersion) {
|
|
type = ser_readdata8(s);
|
|
hashBytes.Unserialize(s, nType, nVersion);
|
|
blockHeight = ser_readdata32be(s);
|
|
}
|
|
|
|
CAddressIndexIteratorHeightKey(unsigned int addressType, uint160 addressHash, int height) {
|
|
type = addressType;
|
|
hashBytes = addressHash;
|
|
blockHeight = height;
|
|
}
|
|
|
|
CAddressIndexIteratorHeightKey() {
|
|
SetNull();
|
|
}
|
|
|
|
void SetNull() {
|
|
type = 0;
|
|
hashBytes.SetNull();
|
|
blockHeight = 0;
|
|
}
|
|
};
|
|
|
|
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;
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* 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);
|
|
|
|
/**
|
|
* Test whether the LockPoints height and time are still valid on the current chain
|
|
*/
|
|
bool TestLockPointValidity(const LockPoints* lp);
|
|
|
|
/**
|
|
* Check if transaction is final per BIP 68 sequence numbers and can be included in a block.
|
|
* Consensus critical. Takes as input a list of heights at which tx's inputs (in order) confirmed.
|
|
*/
|
|
bool SequenceLocks(const CTransaction &tx, int flags, std::vector<int>* prevHeights, const CBlockIndex& block);
|
|
|
|
/**
|
|
* Check if transaction will be BIP 68 final in the next block to be created.
|
|
*
|
|
* Simulates calling SequenceLocks() with data from the tip of the current active chain.
|
|
* Optionally stores in LockPoints the resulting height and time calculated and the hash
|
|
* of the block needed for calculation or skips the calculation and uses the LockPoints
|
|
* passed in for evaluation.
|
|
* The LockPoints should not be considered valid if CheckSequenceLocks returns false.
|
|
*
|
|
* See consensus/consensus.h for flag definitions.
|
|
*/
|
|
bool CheckSequenceLocks(const CTransaction &tx, int flags, LockPoints* lp = NULL, bool useExistingLockPoints = false);
|
|
|
|
/**
|
|
* 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; }
|
|
};
|
|
|
|
bool GetTimestampIndex(const unsigned int &high, const unsigned int &low, std::vector<uint256> &hashes);
|
|
bool GetSpentIndex(CSpentIndexKey &key, CSpentIndexValue &value);
|
|
bool GetAddressIndex(uint160 addressHash, int type,
|
|
std::vector<std::pair<CAddressIndexKey, CAmount> > &addressIndex,
|
|
int start = 0, int end = 0);
|
|
bool GetAddressUnspent(uint160 addressHash, int type,
|
|
std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > &unspentOutputs);
|
|
|
|
/** 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);
|
|
|
|
/** Reprocess a number of blocks to try and get on the correct chain again **/
|
|
bool DisconnectBlocks(int blocks);
|
|
void ReprocessBlocks(int nBlocks);
|
|
|
|
/** 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 CChainParams& chainparams, const CBlock& block, CBlockIndex* pindexPrev, bool fCheckPOW = true, bool fCheckMerkleRoot = true);
|
|
|
|
|
|
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(const CChainParams& chainparams, 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 (protected by cs_main). */
|
|
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);
|
|
|
|
/**
|
|
* Determine what nVersion a new block should use.
|
|
*/
|
|
int32_t ComputeBlockVersion(const CBlockIndex* pindexPrev, const Consensus::Params& params);
|
|
|
|
/**
|
|
* Return true if hash can be found in chainActive at nBlockHeight height.
|
|
* Fills hashRet with found hash, if no nBlockHeight is specified - chainActive.Height() is used.
|
|
*/
|
|
bool GetBlockHash(uint256& hashRet, int nBlockHeight = -1);
|
|
|
|
/** 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
|