2010-08-29 09:58:15 -07:00
|
|
|
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
2015-12-13 08:58:29 -08:00
|
|
|
// Copyright (c) 2009-2015 The Bitcoin Core developers
|
2014-11-30 17:39:44 -08:00
|
|
|
// Distributed under the MIT software license, see the accompanying
|
2012-05-18 07:02:28 -07:00
|
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
2013-04-12 22:13:08 -07:00
|
|
|
|
2011-05-15 00:11:04 -07:00
|
|
|
#ifndef BITCOIN_MAIN_H
|
|
|
|
#define BITCOIN_MAIN_H
|
|
|
|
|
2013-05-27 16:55:01 -07:00
|
|
|
#if defined(HAVE_CONFIG_H)
|
2014-06-23 11:04:24 -07:00
|
|
|
#include "config/bitcoin-config.h"
|
2013-05-27 16:55:01 -07:00
|
|
|
#endif
|
|
|
|
|
2014-10-22 17:05:11 -07:00
|
|
|
#include "amount.h"
|
2014-09-02 17:20:09 -07:00
|
|
|
#include "chain.h"
|
2013-11-04 17:47:07 -08:00
|
|
|
#include "coins.h"
|
2015-01-24 06:29:29 -08:00
|
|
|
#include "net.h"
|
2015-07-05 05:17:46 -07:00
|
|
|
#include "script/script_error.h"
|
2013-04-12 22:13:08 -07:00
|
|
|
#include "sync.h"
|
2016-03-03 12:00:03 -08:00
|
|
|
#include "versionbits.h"
|
2011-05-15 00:11:04 -07:00
|
|
|
|
2013-04-12 22:13:08 -07:00
|
|
|
#include <algorithm>
|
|
|
|
#include <exception>
|
|
|
|
#include <map>
|
|
|
|
#include <set>
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <string>
|
|
|
|
#include <utility>
|
|
|
|
#include <vector>
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2014-09-03 17:03:17 -07:00
|
|
|
#include <boost/unordered_map.hpp>
|
|
|
|
|
2010-08-29 09:58:15 -07:00
|
|
|
class CBlockIndex;
|
2014-10-31 01:36:30 -07:00
|
|
|
class CBlockTreeDB;
|
2013-04-12 22:13:08 -07:00
|
|
|
class CBloomFilter;
|
2015-04-19 15:17:11 -07:00
|
|
|
class CChainParams;
|
2011-05-14 14:20:30 -07:00
|
|
|
class CInv;
|
2014-10-31 01:36:30 -07:00
|
|
|
class CScriptCheck;
|
2015-07-05 05:30:07 -07:00
|
|
|
class CTxMemPool;
|
2014-10-31 01:36:30 -07:00
|
|
|
class CValidationInterface;
|
|
|
|
class CValidationState;
|
|
|
|
|
|
|
|
struct CNodeStateStats;
|
2015-12-04 12:01:22 -08:00
|
|
|
struct LockPoints;
|
2011-05-14 14:20:30 -07:00
|
|
|
|
2015-11-25 15:00:23 -08:00
|
|
|
/** Default for DEFAULT_WHITELISTRELAY. */
|
|
|
|
static const bool DEFAULT_WHITELISTRELAY = true;
|
|
|
|
/** Default for DEFAULT_WHITELISTFORCERELAY. */
|
|
|
|
static const bool DEFAULT_WHITELISTFORCERELAY = true;
|
2015-10-27 09:21:43 -07:00
|
|
|
/** Default for -minrelaytxfee, minimum relay fee for transactions */
|
|
|
|
static const unsigned int DEFAULT_MIN_RELAY_TX_FEE = 1000;
|
2015-11-23 11:32:36 -08:00
|
|
|
//! -maxtxfee default
|
|
|
|
static const CAmount DEFAULT_TRANSACTION_MAXFEE = 0.1 * COIN;
|
|
|
|
//! Discourage users to set fees higher than this amount (in satoshis) per kB
|
|
|
|
static const CAmount HIGH_TX_FEE_PER_KB = 0.01 * COIN;
|
|
|
|
//! -maxtxfee will warn if called with a higher fee than this amount (in satoshis)
|
|
|
|
static const CAmount HIGH_MAX_TX_FEE = 100 * HIGH_TX_FEE_PER_KB;
|
2014-09-10 11:08:03 -07:00
|
|
|
/** Default for -maxorphantx, maximum number of orphan transactions kept in memory */
|
|
|
|
static const unsigned int DEFAULT_MAX_ORPHAN_TRANSACTIONS = 100;
|
2016-06-10 17:26:16 -07:00
|
|
|
/** Expiration time for orphan transactions in seconds */
|
|
|
|
static const int64_t ORPHAN_TX_EXPIRE_TIME = 20 * 60;
|
|
|
|
/** Minimum time between orphan transactions expire time checks in seconds */
|
|
|
|
static const int64_t ORPHAN_TX_EXPIRE_INTERVAL = 5 * 60;
|
2015-07-15 11:47:45 -07:00
|
|
|
/** Default for -limitancestorcount, max number of in-mempool ancestors */
|
2015-10-05 19:16:15 -07:00
|
|
|
static const unsigned int DEFAULT_ANCESTOR_LIMIT = 25;
|
2015-07-15 11:47:45 -07:00
|
|
|
/** Default for -limitancestorsize, maximum kilobytes of tx + all in-mempool ancestors */
|
2015-10-05 19:16:15 -07:00
|
|
|
static const unsigned int DEFAULT_ANCESTOR_SIZE_LIMIT = 101;
|
2015-07-15 11:47:45 -07:00
|
|
|
/** Default for -limitdescendantcount, max number of in-mempool descendants */
|
2015-10-05 19:16:15 -07:00
|
|
|
static const unsigned int DEFAULT_DESCENDANT_LIMIT = 25;
|
2015-07-15 11:47:45 -07:00
|
|
|
/** Default for -limitdescendantsize, maximum kilobytes of in-mempool descendants */
|
2015-10-05 19:16:15 -07:00
|
|
|
static const unsigned int DEFAULT_DESCENDANT_SIZE_LIMIT = 101;
|
2015-10-02 14:43:30 -07:00
|
|
|
/** Default for -mempoolexpiry, expiration time for mempool transactions in hours */
|
|
|
|
static const unsigned int DEFAULT_MEMPOOL_EXPIRY = 72;
|
2012-11-02 16:14:43 -07:00
|
|
|
/** The maximum size of a blk?????.dat file (since 0.8) */
|
2012-08-13 10:11:05 -07:00
|
|
|
static const unsigned int MAX_BLOCKFILE_SIZE = 0x8000000; // 128 MiB
|
2012-11-02 16:14:43 -07:00
|
|
|
/** The pre-allocation chunk size for blk?????.dat files (since 0.8) */
|
2012-08-15 17:21:28 -07:00
|
|
|
static const unsigned int BLOCKFILE_CHUNK_SIZE = 0x1000000; // 16 MiB
|
2012-11-02 16:14:43 -07:00
|
|
|
/** The pre-allocation chunk size for rev?????.dat files (since 0.8) */
|
2012-08-15 17:21:28 -07:00
|
|
|
static const unsigned int UNDOFILE_CHUNK_SIZE = 0x100000; // 1 MiB
|
2015-11-09 10:16:38 -08:00
|
|
|
|
2012-12-01 14:04:14 -08:00
|
|
|
/** Maximum number of script-checking threads allowed */
|
|
|
|
static const int MAX_SCRIPTCHECK_THREADS = 16;
|
2014-02-18 03:48:16 -08:00
|
|
|
/** -par default (number of script-checking threads, 0 = auto) */
|
|
|
|
static const int DEFAULT_SCRIPTCHECK_THREADS = 0;
|
2014-01-10 04:23:26 -08:00
|
|
|
/** Number of blocks that can be requested at any given time from a single peer. */
|
2014-07-11 15:02:35 -07:00
|
|
|
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
|
2015-04-28 07:48:28 -07:00
|
|
|
* less than this number, we reached its tip. Changing this value is a protocol upgrade. */
|
2014-07-11 15:02:35 -07:00
|
|
|
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;
|
2015-05-04 13:00:19 -07:00
|
|
|
/** 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;
|
2014-11-29 07:01:37 -08:00
|
|
|
/** Maximum length of reject messages. */
|
|
|
|
static const unsigned int MAX_REJECT_MESSAGE_LENGTH = 111;
|
2015-04-08 11:20:00 -07:00
|
|
|
/** 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;
|
2016-04-03 19:36:47 -07:00
|
|
|
/** Average delay between trickled inventory transmissions in seconds.
|
|
|
|
* Blocks and whitelisted receivers bypass this, outbound peers get half this delay. */
|
|
|
|
static const unsigned int INVENTORY_BROADCAST_INTERVAL = 5;
|
|
|
|
/** Maximum number of inventory items to send per transmission.
|
|
|
|
* Limits the impact of low-fee transaction floods. */
|
|
|
|
static const unsigned int INVENTORY_BROADCAST_MAX = 7 * INVENTORY_BROADCAST_INTERVAL;
|
2016-02-12 12:57:15 -08:00
|
|
|
/** Average delay between feefilter broadcasts in seconds. */
|
|
|
|
static const unsigned int AVG_FEEFILTER_BROADCAST_INTERVAL = 10 * 60;
|
|
|
|
/** Maximum feefilter broadcast delay after significant change. */
|
|
|
|
static const unsigned int MAX_FEEFILTER_CHANGE_DELAY = 5 * 60;
|
2016-04-07 04:18:11 -07:00
|
|
|
/** Block download timeout base, expressed in millionths of the block interval (i.e. 10 min) */
|
|
|
|
static const int64_t BLOCK_DOWNLOAD_TIMEOUT_BASE = 1000000;
|
2016-04-03 06:24:09 -07:00
|
|
|
/** Additional block download timeout per parallel downloading peer (i.e. 5 min) */
|
|
|
|
static const int64_t BLOCK_DOWNLOAD_TIMEOUT_PER_PEER = 500000;
|
2015-04-08 11:20:00 -07:00
|
|
|
|
2015-06-27 12:21:41 -07:00
|
|
|
static const unsigned int DEFAULT_LIMITFREERELAY = 15;
|
|
|
|
static const bool DEFAULT_RELAYPRIORITY = true;
|
2015-12-14 04:23:45 -08:00
|
|
|
static const int64_t DEFAULT_MAX_TIP_AGE = 24 * 60 * 60;
|
2015-06-27 12:21:41 -07:00
|
|
|
|
2015-11-09 10:16:38 -08:00
|
|
|
/** Default for -permitbaremultisig */
|
|
|
|
static const bool DEFAULT_PERMIT_BAREMULTISIG = true;
|
|
|
|
static const bool DEFAULT_CHECKPOINTS_ENABLED = true;
|
2015-06-27 12:21:41 -07:00
|
|
|
static const bool DEFAULT_TXINDEX = false;
|
|
|
|
static const unsigned int DEFAULT_BANSCORE_THRESHOLD = 100;
|
|
|
|
|
|
|
|
static const bool DEFAULT_TESTSAFEMODE = false;
|
2016-02-01 11:30:37 -08:00
|
|
|
/** Default for -mempoolreplacement */
|
2016-01-27 21:09:29 -08:00
|
|
|
static const bool DEFAULT_ENABLE_REPLACEMENT = true;
|
2016-02-12 12:57:15 -08:00
|
|
|
/** Default for using fee filter */
|
|
|
|
static const bool DEFAULT_FEEFILTER = true;
|
2014-01-10 04:23:26 -08:00
|
|
|
|
2014-11-18 13:16:32 -08:00
|
|
|
/** Maximum number of headers to announce when relaying blocks with headers message.*/
|
|
|
|
static const unsigned int MAX_BLOCKS_TO_ANNOUNCE = 8;
|
|
|
|
|
2016-07-06 18:18:38 -07:00
|
|
|
/** Maximum number of unconnecting headers announcements before DoS score */
|
|
|
|
static const int MAX_UNCONNECTING_HEADERS = 10;
|
|
|
|
|
2016-02-10 22:35:25 -08:00
|
|
|
static const bool DEFAULT_PEERBLOOMFILTERS = true;
|
|
|
|
|
2014-09-03 17:03:17 -07:00
|
|
|
struct BlockHasher
|
|
|
|
{
|
2014-12-15 00:12:11 -08:00
|
|
|
size_t operator()(const uint256& hash) const { return hash.GetCheapHash(); }
|
2014-09-03 17:03:17 -07:00
|
|
|
};
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2012-02-06 12:48:00 -08:00
|
|
|
extern CScript COINBASE_FLAGS;
|
2010-08-29 09:58:15 -07:00
|
|
|
extern CCriticalSection cs_main;
|
2013-08-26 22:51:57 -07:00
|
|
|
extern CTxMemPool mempool;
|
2014-09-03 17:03:17 -07:00
|
|
|
typedef boost::unordered_map<uint256, CBlockIndex*, BlockHasher> BlockMap;
|
2014-09-03 17:02:44 -07:00
|
|
|
extern BlockMap mapBlockIndex;
|
2013-04-12 22:13:08 -07:00
|
|
|
extern uint64_t nLastBlockTx;
|
|
|
|
extern uint64_t nLastBlockSize;
|
2016-07-18 10:28:26 -07:00
|
|
|
extern uint64_t nLastBlockWeight;
|
2011-12-23 07:14:57 -08:00
|
|
|
extern const std::string strMessageMagic;
|
2012-05-12 21:43:24 -07:00
|
|
|
extern CWaitableCriticalSection csBestBlock;
|
|
|
|
extern CConditionVariable cvBlockChange;
|
2012-09-13 05:33:52 -07:00
|
|
|
extern bool fImporting;
|
2012-10-21 12:23:13 -07:00
|
|
|
extern bool fReindex;
|
2012-12-01 14:04:14 -08:00
|
|
|
extern int nScriptCheckThreads;
|
2013-01-10 16:47:57 -08:00
|
|
|
extern bool fTxIndex;
|
2014-07-16 17:04:04 -07:00
|
|
|
extern bool fIsBareMultisigStd;
|
2015-06-23 20:36:22 -07:00
|
|
|
extern bool fRequireStandard;
|
2015-03-13 09:25:34 -07:00
|
|
|
extern bool fCheckBlockIndex;
|
2015-04-22 20:22:36 -07:00
|
|
|
extern bool fCheckpointsEnabled;
|
2015-05-03 16:38:08 -07:00
|
|
|
extern size_t nCoinCacheUsage;
|
2015-11-23 11:32:36 -08:00
|
|
|
/** A fee rate smaller than this is considered zero fee (for relaying, mining and transaction creation) */
|
2014-07-03 11:25:32 -07:00
|
|
|
extern CFeeRate minRelayTxFee;
|
2015-11-23 11:32:36 -08:00
|
|
|
/** Absolute maximum transaction fee (in satoshis) used by wallet and mempool (rejects high fee in sendrawtransaction) */
|
|
|
|
extern CAmount maxTxFee;
|
2016-02-02 04:40:54 -08:00
|
|
|
/** If the tip is older than this (in seconds), the node is considered to be in initial block download. */
|
2015-12-14 04:23:45 -08:00
|
|
|
extern int64_t nMaxTipAge;
|
2016-01-27 21:09:29 -08:00
|
|
|
extern bool fEnableReplacement;
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2014-11-30 17:39:44 -08:00
|
|
|
/** Best header we've seen so far (used for getheaders queries' starting points). */
|
2014-07-11 15:03:10 -07:00
|
|
|
extern CBlockIndex *pindexBestHeader;
|
|
|
|
|
2014-11-30 17:39:44 -08:00
|
|
|
/** Minimum disk space required - used in CheckDiskSpace() */
|
2013-04-12 22:13:08 -07:00
|
|
|
static const uint64_t nMinDiskSpace = 52428800;
|
2010-08-29 09:58:15 -07:00
|
|
|
|
Add block pruning functionality
This adds a -prune=N option to bitcoind, which if set to N>0 will enable block
file pruning. When pruning is enabled, block and undo files will be deleted to
try to keep total space used by those files to below the prune target (N, in
MB) specified by the user, subject to some constraints:
- The last 288 blocks on the main chain are always kept (MIN_BLOCKS_TO_KEEP),
- N must be at least 550MB (chosen as a value for the target that could
reasonably be met, with some assumptions about block sizes, orphan rates,
etc; see comment in main.h),
- No blocks are pruned until chainActive is at least 100,000 blocks long (on
mainnet; defined separately for mainnet, testnet, and regtest in chainparams
as nPruneAfterHeight).
This unsets NODE_NETWORK if pruning is enabled.
Also included is an RPC test for pruning (pruning.py).
Thanks to @rdponticelli for earlier work on this feature; this is based in
part off that work.
2015-02-23 11:27:44 -08:00
|
|
|
/** 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. */
|
2015-05-13 13:04:39 -07:00
|
|
|
static const unsigned int MIN_BLOCKS_TO_KEEP = 288;
|
Add block pruning functionality
This adds a -prune=N option to bitcoind, which if set to N>0 will enable block
file pruning. When pruning is enabled, block and undo files will be deleted to
try to keep total space used by those files to below the prune target (N, in
MB) specified by the user, subject to some constraints:
- The last 288 blocks on the main chain are always kept (MIN_BLOCKS_TO_KEEP),
- N must be at least 550MB (chosen as a value for the target that could
reasonably be met, with some assumptions about block sizes, orphan rates,
etc; see comment in main.h),
- No blocks are pruned until chainActive is at least 100,000 blocks long (on
mainnet; defined separately for mainnet, testnet, and regtest in chainparams
as nPruneAfterHeight).
This unsets NODE_NETWORK if pruning is enabled.
Also included is an RPC test for pruning (pruning.py).
Thanks to @rdponticelli for earlier work on this feature; this is based in
part off that work.
2015-02-23 11:27:44 -08:00
|
|
|
|
2015-06-27 12:08:36 -07:00
|
|
|
static const signed int DEFAULT_CHECKBLOCKS = MIN_BLOCKS_TO_KEEP;
|
|
|
|
static const unsigned int DEFAULT_CHECKLEVEL = 3;
|
|
|
|
|
Add block pruning functionality
This adds a -prune=N option to bitcoind, which if set to N>0 will enable block
file pruning. When pruning is enabled, block and undo files will be deleted to
try to keep total space used by those files to below the prune target (N, in
MB) specified by the user, subject to some constraints:
- The last 288 blocks on the main chain are always kept (MIN_BLOCKS_TO_KEEP),
- N must be at least 550MB (chosen as a value for the target that could
reasonably be met, with some assumptions about block sizes, orphan rates,
etc; see comment in main.h),
- No blocks are pruned until chainActive is at least 100,000 blocks long (on
mainnet; defined separately for mainnet, testnet, and regtest in chainparams
as nPruneAfterHeight).
This unsets NODE_NETWORK if pruning is enabled.
Also included is an RPC test for pruning (pruning.py).
Thanks to @rdponticelli for earlier work on this feature; this is based in
part off that work.
2015-02-23 11:27:44 -08:00
|
|
|
// 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.
|
2015-05-13 13:04:39 -07:00
|
|
|
static const uint64_t MIN_DISK_SPACE_FOR_BLOCK_FILES = 550 * 1024 * 1024;
|
Add block pruning functionality
This adds a -prune=N option to bitcoind, which if set to N>0 will enable block
file pruning. When pruning is enabled, block and undo files will be deleted to
try to keep total space used by those files to below the prune target (N, in
MB) specified by the user, subject to some constraints:
- The last 288 blocks on the main chain are always kept (MIN_BLOCKS_TO_KEEP),
- N must be at least 550MB (chosen as a value for the target that could
reasonably be met, with some assumptions about block sizes, orphan rates,
etc; see comment in main.h),
- No blocks are pruned until chainActive is at least 100,000 blocks long (on
mainnet; defined separately for mainnet, testnet, and regtest in chainparams
as nPruneAfterHeight).
This unsets NODE_NETWORK if pruning is enabled.
Also included is an RPC test for pruning (pruning.py).
Thanks to @rdponticelli for earlier work on this feature; this is based in
part off that work.
2015-02-23 11:27:44 -08:00
|
|
|
|
2013-06-05 20:21:41 -07:00
|
|
|
/** Register with a network node to receive its signals */
|
|
|
|
void RegisterNodeSignals(CNodeSignals& nodeSignals);
|
|
|
|
/** Unregister a network node */
|
|
|
|
void UnregisterNodeSignals(CNodeSignals& nodeSignals);
|
|
|
|
|
2014-11-30 17:39:44 -08:00
|
|
|
/**
|
|
|
|
* 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!
|
|
|
|
*
|
2015-02-04 16:11:44 -08:00
|
|
|
* @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.
|
2014-11-30 17:39:44 -08:00
|
|
|
* @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.
|
2015-04-09 10:21:11 -07:00
|
|
|
* @param[in] fForceProcessing Process this block even if unrequested; used for non-network block sources and whitelisted peers.
|
2016-04-20 05:53:36 -07:00
|
|
|
* @param[out] dbp The already known disk position of pblock, or NULL if not yet stored.
|
2014-11-30 17:39:44 -08:00
|
|
|
* @return True if state.IsValid()
|
|
|
|
*/
|
2016-05-21 22:55:15 -07:00
|
|
|
bool ProcessNewBlock(CValidationState& state, const CChainParams& chainparams, CNode* pfrom, const CBlock* pblock, bool fForceProcessing, const CDiskBlockPos* dbp);
|
2012-11-04 04:18:04 -08:00
|
|
|
/** Check whether enough disk space is available for an incoming block */
|
2013-04-12 22:13:08 -07:00
|
|
|
bool CheckDiskSpace(uint64_t nAdditionalBytes = 0);
|
2012-11-04 04:18:04 -08:00
|
|
|
/** Open a block file (blk?????.dat) */
|
2012-08-13 10:11:05 -07:00
|
|
|
FILE* OpenBlockFile(const CDiskBlockPos &pos, bool fReadOnly = false);
|
2012-11-04 04:18:04 -08:00
|
|
|
/** Open an undo file (rev?????.dat) */
|
2012-08-13 10:11:05 -07:00
|
|
|
FILE* OpenUndoFile(const CDiskBlockPos &pos, bool fReadOnly = false);
|
2014-09-08 10:29:14 -07:00
|
|
|
/** Translation to a filesystem path */
|
|
|
|
boost::filesystem::path GetBlockPosFilename(const CDiskBlockPos &pos, const char *prefix);
|
2012-11-04 04:18:04 -08:00
|
|
|
/** Import blocks from an external file */
|
2015-04-17 05:40:24 -07:00
|
|
|
bool LoadExternalBlockFile(const CChainParams& chainparams, FILE* fileIn, CDiskBlockPos *dbp = NULL);
|
2013-01-30 12:43:36 -08:00
|
|
|
/** Initialize a new block tree database + block data on disk */
|
2015-04-17 05:40:24 -07:00
|
|
|
bool InitBlockIndex(const CChainParams& chainparams);
|
2012-11-04 04:18:04 -08:00
|
|
|
/** Load the block tree and coins database from disk */
|
2012-10-21 12:23:13 -07:00
|
|
|
bool LoadBlockIndex();
|
2013-02-16 08:58:45 -08:00
|
|
|
/** Unload database information */
|
|
|
|
void UnloadBlockIndex();
|
2012-11-04 04:18:04 -08:00
|
|
|
/** Process protocol messages received from a given node */
|
2010-08-29 09:58:15 -07:00
|
|
|
bool ProcessMessages(CNode* pfrom);
|
2015-03-24 06:29:13 -07:00
|
|
|
/**
|
|
|
|
* Send queued protocol messages to be sent to a give node.
|
|
|
|
*
|
|
|
|
* @param[in] pto The node which we are sending messages to.
|
|
|
|
*/
|
2015-04-08 11:20:00 -07:00
|
|
|
bool SendMessages(CNode* pto);
|
2012-12-01 14:04:14 -08:00
|
|
|
/** Run an instance of the script checking thread */
|
2013-03-06 19:31:26 -08:00
|
|
|
void ThreadScriptCheck();
|
2012-12-17 02:09:53 -08:00
|
|
|
/** Check whether we are doing an initial block download (synchronizing from disk or network) */
|
2010-08-29 09:58:15 -07:00
|
|
|
bool IsInitialBlockDownload();
|
2015-12-01 00:47:13 -08:00
|
|
|
/** 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.
|
|
|
|
*/
|
2015-05-31 06:36:44 -07:00
|
|
|
std::string GetWarnings(const std::string& strFor);
|
2012-11-04 04:18:04 -08:00
|
|
|
/** Retrieve a transaction (from memory pool, or from disk, if possible) */
|
2015-04-17 05:19:21 -07:00
|
|
|
bool GetTransaction(const uint256 &hash, CTransaction &tx, const Consensus::Params& params, uint256 &hashBlock, bool fAllowSlow = false);
|
2012-11-04 04:18:04 -08:00
|
|
|
/** Find the best known block, and make it the tip of the block chain */
|
2015-04-17 05:40:24 -07:00
|
|
|
bool ActivateBestChain(CValidationState& state, const CChainParams& chainparams, const CBlock* pblock = NULL);
|
2015-04-01 07:03:11 -07:00
|
|
|
CAmount GetBlockSubsidy(int nHeight, const Consensus::Params& consensusParams);
|
2013-01-08 14:58:06 -08:00
|
|
|
|
Add block pruning functionality
This adds a -prune=N option to bitcoind, which if set to N>0 will enable block
file pruning. When pruning is enabled, block and undo files will be deleted to
try to keep total space used by those files to below the prune target (N, in
MB) specified by the user, subject to some constraints:
- The last 288 blocks on the main chain are always kept (MIN_BLOCKS_TO_KEEP),
- N must be at least 550MB (chosen as a value for the target that could
reasonably be met, with some assumptions about block sizes, orphan rates,
etc; see comment in main.h),
- No blocks are pruned until chainActive is at least 100,000 blocks long (on
mainnet; defined separately for mainnet, testnet, and regtest in chainparams
as nPruneAfterHeight).
This unsets NODE_NETWORK if pruning is enabled.
Also included is an RPC test for pruning (pruning.py).
Thanks to @rdponticelli for earlier work on this feature; this is based in
part off that work.
2015-02-23 11:27:44 -08:00
|
|
|
/**
|
|
|
|
* 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.)
|
2015-11-27 06:12:08 -08:00
|
|
|
* Pruning cannot take place until the longest chain is at least a certain length (100000 on mainnet, 1000 on testnet, 1000 on regtest).
|
Add block pruning functionality
This adds a -prune=N option to bitcoind, which if set to N>0 will enable block
file pruning. When pruning is enabled, block and undo files will be deleted to
try to keep total space used by those files to below the prune target (N, in
MB) specified by the user, subject to some constraints:
- The last 288 blocks on the main chain are always kept (MIN_BLOCKS_TO_KEEP),
- N must be at least 550MB (chosen as a value for the target that could
reasonably be met, with some assumptions about block sizes, orphan rates,
etc; see comment in main.h),
- No blocks are pruned until chainActive is at least 100,000 blocks long (on
mainnet; defined separately for mainnet, testnet, and regtest in chainparams
as nPruneAfterHeight).
This unsets NODE_NETWORK if pruning is enabled.
Also included is an RPC test for pruning (pruning.py).
Thanks to @rdponticelli for earlier work on this feature; this is based in
part off that work.
2015-02-23 11:27:44 -08:00
|
|
|
* 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
|
|
|
|
*/
|
2015-04-17 05:40:24 -07:00
|
|
|
void FindFilesToPrune(std::set<int>& setFilesToPrune, uint64_t nPruneAfterHeight);
|
Add block pruning functionality
This adds a -prune=N option to bitcoind, which if set to N>0 will enable block
file pruning. When pruning is enabled, block and undo files will be deleted to
try to keep total space used by those files to below the prune target (N, in
MB) specified by the user, subject to some constraints:
- The last 288 blocks on the main chain are always kept (MIN_BLOCKS_TO_KEEP),
- N must be at least 550MB (chosen as a value for the target that could
reasonably be met, with some assumptions about block sizes, orphan rates,
etc; see comment in main.h),
- No blocks are pruned until chainActive is at least 100,000 blocks long (on
mainnet; defined separately for mainnet, testnet, and regtest in chainparams
as nPruneAfterHeight).
This unsets NODE_NETWORK if pruning is enabled.
Also included is an RPC test for pruning (pruning.py).
Thanks to @rdponticelli for earlier work on this feature; this is based in
part off that work.
2015-02-23 11:27:44 -08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Actually unlink the specified files
|
|
|
|
*/
|
|
|
|
void UnlinkPrunedFiles(std::set<int>& setFilesToPrune);
|
|
|
|
|
2012-11-04 04:18:04 -08:00
|
|
|
/** Create a new block index entry for a given block hash */
|
2012-09-03 12:14:03 -07:00
|
|
|
CBlockIndex * InsertBlockIndex(uint256 hash);
|
2013-11-17 16:25:17 -08:00
|
|
|
/** Get statistics from node state */
|
|
|
|
bool GetNodeStateStats(NodeId nodeid, CNodeStateStats &stats);
|
2014-01-10 04:23:26 -08:00
|
|
|
/** Increase a node's misbehavior score. */
|
|
|
|
void Misbehaving(NodeId nodeid, int howmuch);
|
Improve chainstate/blockindex disk writing policy
There are 3 pieces of data that are maintained on disk. The actual block
and undo data, the block index (which can refer to positions on disk),
and the chainstate (which refers to the best block hash).
Earlier, there was no guarantee that blocks were written to disk before
block index entries referring to them were written. This commit introduces
dirty flags for block index data, and delays writing entries until the actual
block data is flushed.
With this stricter ordering in writes, it is now safe to not always flush
after every block, so there is no need for the IsInitialBlockDownload()
check there - instead we just write whenever enough time has passed or
the cache size grows too large. Also updating the wallet's best known block
is delayed until this is done, otherwise the wallet may end up referring to an
unknown block.
In addition, only do a write inside the block processing loop if necessary
(because of cache size exceeded). Otherwise, move the writing to a point
after processing is done, after relaying.
2014-11-07 02:38:35 -08:00
|
|
|
/** Flush all state, indexes and buffers to disk. */
|
|
|
|
void FlushStateToDisk();
|
Add block pruning functionality
This adds a -prune=N option to bitcoind, which if set to N>0 will enable block
file pruning. When pruning is enabled, block and undo files will be deleted to
try to keep total space used by those files to below the prune target (N, in
MB) specified by the user, subject to some constraints:
- The last 288 blocks on the main chain are always kept (MIN_BLOCKS_TO_KEEP),
- N must be at least 550MB (chosen as a value for the target that could
reasonably be met, with some assumptions about block sizes, orphan rates,
etc; see comment in main.h),
- No blocks are pruned until chainActive is at least 100,000 blocks long (on
mainnet; defined separately for mainnet, testnet, and regtest in chainparams
as nPruneAfterHeight).
This unsets NODE_NETWORK if pruning is enabled.
Also included is an RPC test for pruning (pruning.py).
Thanks to @rdponticelli for earlier work on this feature; this is based in
part off that work.
2015-02-23 11:27:44 -08:00
|
|
|
/** Prune block files and flush state to disk. */
|
|
|
|
void PruneAndFlush();
|
2012-08-18 15:33:01 -07:00
|
|
|
|
2013-08-26 22:51:57 -07:00
|
|
|
/** (try to) add transaction to memory pool **/
|
|
|
|
bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransaction &tx, bool fLimitFree,
|
2016-04-20 12:38:19 -07:00
|
|
|
bool* pfMissingInputs, bool fOverrideMempoolLimit=false, const CAmount nAbsurdFee=0);
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2015-10-28 11:56:28 -07:00
|
|
|
/** Convert CValidationState to a human-readable message for logging */
|
|
|
|
std::string FormatStateMessage(const CValidationState &state);
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2016-03-03 12:00:03 -08:00
|
|
|
/** Get the BIP9 state for a given deployment at the current tip. */
|
|
|
|
ThresholdState VersionBitsTipState(const Consensus::Params& params, Consensus::DeploymentPos pos);
|
|
|
|
|
2013-11-17 16:25:17 -08:00
|
|
|
struct CNodeStateStats {
|
|
|
|
int nMisbehavior;
|
2014-06-22 15:00:26 -07:00
|
|
|
int nSyncHeight;
|
2014-07-11 15:03:10 -07:00
|
|
|
int nCommonHeight;
|
|
|
|
std::vector<int> vHeightInFlight;
|
2013-11-17 16:25:17 -08:00
|
|
|
};
|
|
|
|
|
2010-08-29 09:58:15 -07:00
|
|
|
|
|
|
|
|
2014-11-30 17:39:44 -08:00
|
|
|
/**
|
|
|
|
* 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
|
|
|
|
*/
|
2013-01-08 04:17:15 -08:00
|
|
|
unsigned int GetLegacySigOpCount(const CTransaction& tx);
|
2010-12-07 05:43:31 -08:00
|
|
|
|
2014-11-30 17:39:44 -08:00
|
|
|
/**
|
|
|
|
* 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
|
2013-01-08 04:17:15 -08:00
|
|
|
*/
|
2014-07-19 08:14:23 -07:00
|
|
|
unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewCache& mapInputs);
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2016-05-28 10:22:13 -07:00
|
|
|
/**
|
|
|
|
* Compute total signature operation cost of a transaction.
|
|
|
|
* @param[in] tx Transaction for which we are computing the cost
|
|
|
|
* @param[in] inputs Map of previous transactions that have outputs we're spending
|
|
|
|
* @param[out] flags Script verification flags
|
|
|
|
* @return Total signature operation cost of tx
|
|
|
|
*/
|
|
|
|
int64_t GetTransactionSigOpCost(const CTransaction& tx, const CCoinsViewCache& inputs, int flags);
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2014-11-30 17:39:44 -08:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2014-09-13 19:48:32 -07:00
|
|
|
bool CheckInputs(const CTransaction& tx, CValidationState &state, const CCoinsViewCache &view, bool fScriptChecks,
|
|
|
|
unsigned int flags, bool cacheStore, std::vector<CScriptCheck> *pvChecks = NULL);
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2014-11-30 17:39:44 -08:00
|
|
|
/** Apply the effects of this transaction on the UTXO set represented by view */
|
2016-04-29 20:45:20 -07:00
|
|
|
void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, int nHeight);
|
2012-01-10 17:18:00 -08:00
|
|
|
|
2014-11-30 17:39:44 -08:00
|
|
|
/** Context-independent validity checks */
|
2013-01-08 04:17:15 -08:00
|
|
|
bool CheckTransaction(const CTransaction& tx, CValidationState& state);
|
Ultraprune
This switches bitcoin's transaction/block verification logic to use a
"coin database", which contains all unredeemed transaction output scripts,
amounts and heights.
The name ultraprune comes from the fact that instead of a full transaction
index, we only (need to) keep an index with unspent outputs. For now, the
blocks themselves are kept as usual, although they are only necessary for
serving, rescanning and reorganizing.
The basic datastructures are CCoins (representing the coins of a single
transaction), and CCoinsView (representing a state of the coins database).
There are several implementations for CCoinsView. A dummy, one backed by
the coins database (coins.dat), one backed by the memory pool, and one
that adds a cache on top of it. FetchInputs, ConnectInputs, ConnectBlock,
DisconnectBlock, ... now operate on a generic CCoinsView.
The block switching logic now builds a single cached CCoinsView with
changes to be committed to the database before any changes are made.
This means no uncommitted changes are ever read from the database, and
should ease the transition to another database layer which does not
support transactions (but does support atomic writes), like LevelDB.
For the getrawtransaction() RPC call, access to a txid-to-disk index
would be preferable. As this index is not necessary or even useful
for any other part of the implementation, it is not provided. Instead,
getrawtransaction() uses the coin database to find the block height,
and then scans that block to find the requested transaction. This is
slow, but should suffice for debug purposes.
2012-07-01 09:54:00 -07:00
|
|
|
|
2015-05-24 21:48:33 -07:00
|
|
|
/**
|
|
|
|
* 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.
|
2015-11-03 09:12:36 -08:00
|
|
|
*
|
|
|
|
* See consensus/consensus.h for flag definitions.
|
2015-05-24 21:48:33 -07:00
|
|
|
*/
|
2015-11-03 09:12:36 -08:00
|
|
|
bool CheckFinalTx(const CTransaction &tx, int flags = -1);
|
Ultraprune
This switches bitcoin's transaction/block verification logic to use a
"coin database", which contains all unredeemed transaction output scripts,
amounts and heights.
The name ultraprune comes from the fact that instead of a full transaction
index, we only (need to) keep an index with unspent outputs. For now, the
blocks themselves are kept as usual, although they are only necessary for
serving, rescanning and reorganizing.
The basic datastructures are CCoins (representing the coins of a single
transaction), and CCoinsView (representing a state of the coins database).
There are several implementations for CCoinsView. A dummy, one backed by
the coins database (coins.dat), one backed by the memory pool, and one
that adds a cache on top of it. FetchInputs, ConnectInputs, ConnectBlock,
DisconnectBlock, ... now operate on a generic CCoinsView.
The block switching logic now builds a single cached CCoinsView with
changes to be committed to the database before any changes are made.
This means no uncommitted changes are ever read from the database, and
should ease the transition to another database layer which does not
support transactions (but does support atomic writes), like LevelDB.
For the getrawtransaction() RPC call, access to a txid-to-disk index
would be preferable. As this index is not necessary or even useful
for any other part of the implementation, it is not provided. Instead,
getrawtransaction() uses the coin database to find the block height,
and then scans that block to find the requested transaction. This is
slow, but should suffice for debug purposes.
2012-07-01 09:54:00 -07:00
|
|
|
|
2015-12-04 12:01:22 -08:00
|
|
|
/**
|
|
|
|
* Test whether the LockPoints height and time are still valid on the current chain
|
|
|
|
*/
|
|
|
|
bool TestLockPointValidity(const LockPoints* lp);
|
|
|
|
|
2015-12-07 12:44:16 -08:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*
|
2016-02-11 12:34:04 -08:00
|
|
|
* Simulates calling SequenceLocks() with data from the tip of the current active chain.
|
2015-12-04 12:01:22 -08:00
|
|
|
* 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.
|
2015-12-07 12:44:16 -08:00
|
|
|
*
|
|
|
|
* See consensus/consensus.h for flag definitions.
|
|
|
|
*/
|
2015-12-04 12:01:22 -08:00
|
|
|
bool CheckSequenceLocks(const CTransaction &tx, int flags, LockPoints* lp = NULL, bool useExistingLockPoints = false);
|
2015-12-07 12:44:16 -08:00
|
|
|
|
|
|
|
/**
|
2014-11-30 17:39:44 -08:00
|
|
|
* Closure representing one script verification
|
|
|
|
* Note that this stores references to the spending transaction
|
|
|
|
*/
|
2012-12-01 13:30:06 -08:00
|
|
|
class CScriptCheck
|
|
|
|
{
|
|
|
|
private:
|
|
|
|
CScript scriptPubKey;
|
2016-03-31 05:51:29 -07:00
|
|
|
CAmount amount;
|
2012-12-01 13:30:06 -08:00
|
|
|
const CTransaction *ptxTo;
|
|
|
|
unsigned int nIn;
|
|
|
|
unsigned int nFlags;
|
2014-09-13 19:48:32 -07:00
|
|
|
bool cacheStore;
|
2014-11-29 07:01:37 -08:00
|
|
|
ScriptError error;
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2012-12-01 13:30:06 -08:00
|
|
|
public:
|
2016-03-31 05:51:29 -07:00
|
|
|
CScriptCheck(): amount(0), ptxTo(0), nIn(0), nFlags(0), cacheStore(false), error(SCRIPT_ERR_UNKNOWN_ERROR) {}
|
2014-09-13 19:48:32 -07:00
|
|
|
CScriptCheck(const CCoins& txFromIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, bool cacheIn) :
|
2016-03-31 05:51:29 -07:00
|
|
|
scriptPubKey(txFromIn.vout[txToIn.vin[nInIn].prevout.n].scriptPubKey), amount(txFromIn.vout[txToIn.vin[nInIn].prevout.n].nValue),
|
2014-11-29 07:01:37 -08:00
|
|
|
ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), cacheStore(cacheIn), error(SCRIPT_ERR_UNKNOWN_ERROR) { }
|
2012-12-01 13:30:06 -08:00
|
|
|
|
2014-11-29 07:01:37 -08:00
|
|
|
bool operator()();
|
2012-12-01 13:30:06 -08:00
|
|
|
|
|
|
|
void swap(CScriptCheck &check) {
|
|
|
|
scriptPubKey.swap(check.scriptPubKey);
|
|
|
|
std::swap(ptxTo, check.ptxTo);
|
2016-03-31 05:51:29 -07:00
|
|
|
std::swap(amount, check.amount);
|
2012-12-01 13:30:06 -08:00
|
|
|
std::swap(nIn, check.nIn);
|
|
|
|
std::swap(nFlags, check.nFlags);
|
2014-09-13 19:48:32 -07:00
|
|
|
std::swap(cacheStore, check.cacheStore);
|
2014-11-29 07:01:37 -08:00
|
|
|
std::swap(error, check.error);
|
2012-12-01 13:30:06 -08:00
|
|
|
}
|
2014-11-29 07:01:37 -08:00
|
|
|
|
|
|
|
ScriptError GetScriptError() const { return error; }
|
2012-12-01 13:30:06 -08:00
|
|
|
};
|
2010-08-29 09:58:15 -07:00
|
|
|
|
|
|
|
|
2013-06-23 17:35:01 -07:00
|
|
|
/** Functions for disk access for blocks */
|
2015-08-08 09:18:41 -07:00
|
|
|
bool WriteBlockToDisk(const CBlock& block, CDiskBlockPos& pos, const CMessageHeader::MessageStartChars& messageStart);
|
2015-04-17 05:19:21 -07:00
|
|
|
bool ReadBlockFromDisk(CBlock& block, const CDiskBlockPos& pos, const Consensus::Params& consensusParams);
|
|
|
|
bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex, const Consensus::Params& consensusParams);
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2013-06-23 18:32:58 -07:00
|
|
|
/** Functions for validating blocks and updating the block tree */
|
|
|
|
|
2014-11-30 17:39:44 -08:00
|
|
|
/** Context-independent validity checks */
|
2016-06-08 16:12:52 -07:00
|
|
|
bool CheckBlockHeader(const CBlockHeader& block, CValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW = true);
|
|
|
|
bool CheckBlock(const CBlock& block, CValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW = true, bool fCheckMerkleRoot = true);
|
2013-06-23 19:14:11 -07:00
|
|
|
|
2016-01-30 21:40:23 -08:00
|
|
|
/** Context-dependent validity checks.
|
|
|
|
* By "context", we mean only the previous block headers, but not the UTXO
|
|
|
|
* set; UTXO-related validity checks are done in ConnectBlock(). */
|
2016-07-16 16:34:35 -07:00
|
|
|
bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationState& state, const Consensus::Params& consensusParams, const CBlockIndex* pindexPrev, int64_t nAdjustedTime);
|
|
|
|
bool ContextualCheckBlock(const CBlock& block, CValidationState& state, const CBlockIndex* pindexPrev);
|
2014-10-19 16:09:50 -07:00
|
|
|
|
2016-01-30 21:40:23 -08:00
|
|
|
/** Apply the effects of this block (with given index) on the UTXO set represented by coins.
|
|
|
|
* Validity checks that depend on the UTXO set are also done; ConnectBlock()
|
|
|
|
* can fail if those validity checks fail (among other reasons). */
|
2016-04-19 06:16:39 -07:00
|
|
|
bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pindex, CCoinsViewCache& coins,
|
|
|
|
const CChainParams& chainparams, bool fJustCheck = false);
|
2016-01-30 21:40:23 -08:00
|
|
|
|
|
|
|
/** 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);
|
|
|
|
|
2014-11-30 17:39:44 -08:00
|
|
|
/** Check a block is completely valid from start to finish (only works on top of our current best block, with cs_main held) */
|
2015-04-19 15:17:11 -07:00
|
|
|
bool TestBlockValidity(CValidationState& state, const CChainParams& chainparams, const CBlock& block, CBlockIndex* pindexPrev, bool fCheckPOW = true, bool fCheckMerkleRoot = true);
|
2014-10-19 19:10:03 -07:00
|
|
|
|
2015-11-05 16:42:38 -08:00
|
|
|
/** Check whether witness commitments are required for block. */
|
|
|
|
bool IsWitnessEnabled(const CBlockIndex* pindexPrev, const Consensus::Params& params);
|
|
|
|
|
2016-03-18 09:20:12 -07:00
|
|
|
/** When there are blocks in the active chain with missing data, rewind the chainstate and remove them from the block index */
|
|
|
|
bool RewindBlockIndex(const CChainParams& params);
|
|
|
|
|
2015-11-05 16:42:38 -08:00
|
|
|
/** Update uncommitted block structures (currently: only the witness nonce). This is safe for submitted blocks. */
|
|
|
|
void UpdateUncommittedBlockStructures(CBlock& block, const CBlockIndex* pindexPrev, const Consensus::Params& consensusParams);
|
|
|
|
|
|
|
|
/** Produce the necessary coinbase commitment for a block (modifies the hash, don't call for mined blocks). */
|
|
|
|
std::vector<unsigned char> GenerateCoinbaseCommitment(CBlock& block, const CBlockIndex* pindexPrev, const Consensus::Params& consensusParams);
|
|
|
|
|
2014-05-23 09:04:09 -07:00
|
|
|
/** RAII wrapper for VerifyDB: Verify consistency of the block and coin databases */
|
|
|
|
class CVerifyDB {
|
|
|
|
public:
|
|
|
|
CVerifyDB();
|
|
|
|
~CVerifyDB();
|
2015-04-17 05:40:24 -07:00
|
|
|
bool VerifyDB(const CChainParams& chainparams, CCoinsView *coinsview, int nCheckLevel, int nCheckDepth);
|
2014-05-23 09:04:09 -07:00
|
|
|
};
|
|
|
|
|
2014-09-02 17:52:01 -07:00
|
|
|
/** Find the last common block between the parameter chain and a locator. */
|
|
|
|
CBlockIndex* FindForkInGlobalIndex(const CChain& chain, const CBlockLocator& locator);
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2014-11-19 00:39:42 -08:00
|
|
|
/** Mark a block as invalid. */
|
2016-04-17 00:58:50 -07:00
|
|
|
bool InvalidateBlock(CValidationState& state, const CChainParams& chainparams, CBlockIndex *pindex);
|
2014-11-19 00:39:42 -08:00
|
|
|
|
|
|
|
/** Remove invalidity status from a block and its descendants. */
|
2016-05-09 08:26:37 -07:00
|
|
|
bool ResetBlockFailureFlags(CBlockIndex *pindex);
|
2014-11-19 00:39:42 -08:00
|
|
|
|
2015-09-09 16:31:20 -07:00
|
|
|
/** The currently-connected chain of blocks (protected by cs_main). */
|
2013-10-10 14:07:44 -07:00
|
|
|
extern CChain chainActive;
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2012-09-03 06:26:57 -07:00
|
|
|
/** Global variable that points to the active CCoinsView (protected by cs_main) */
|
2012-07-06 07:33:34 -07:00
|
|
|
extern CCoinsViewCache *pcoinsTip;
|
|
|
|
|
2012-09-03 06:26:57 -07:00
|
|
|
/** Global variable that points to the active block tree (protected by cs_main) */
|
|
|
|
extern CBlockTreeDB *pblocktree;
|
|
|
|
|
2015-04-24 07:45:16 -07:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2016-04-23 16:30:20 -07:00
|
|
|
extern VersionBitsCache versionbitscache;
|
|
|
|
|
2016-02-14 20:13:27 -08:00
|
|
|
/**
|
|
|
|
* Determine what nVersion a new block should use.
|
|
|
|
*/
|
|
|
|
int32_t ComputeBlockVersion(const CBlockIndex* pindexPrev, const Consensus::Params& params);
|
|
|
|
|
2015-08-06 00:51:36 -07:00
|
|
|
/** 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 */
|
2015-03-16 18:36:43 -07:00
|
|
|
static const unsigned int REJECT_HIGHFEE = 0x100;
|
2015-08-06 00:51:36 -07:00
|
|
|
/** 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;
|
2015-03-16 18:36:43 -07:00
|
|
|
|
2014-08-28 13:21:03 -07:00
|
|
|
#endif // BITCOIN_MAIN_H
|