2010-08-29 09:58:15 -07:00
|
|
|
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
2014-12-16 17:47:57 -08:00
|
|
|
// Copyright (c) 2009-2014 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"
|
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;
|
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;
|
2011-05-14 14:20:30 -07:00
|
|
|
|
2015-06-12 03:00:39 -07:00
|
|
|
/** Default for accepting alerts from the P2P network. */
|
|
|
|
static const bool DEFAULT_ALERTS = true;
|
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;
|
2015-07-15 11:47:45 -07:00
|
|
|
/** 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;
|
2015-10-02 14:19:55 -07:00
|
|
|
/** Default for -maxmempool, maximum megabytes of mempool memory usage */
|
|
|
|
static const unsigned int DEFAULT_MAX_MEMPOOL_SIZE = 300;
|
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
|
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;
|
2014-01-10 04:23:26 -08:00
|
|
|
|
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;
|
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;
|
2014-07-03 11:25:32 -07:00
|
|
|
extern CFeeRate minRelayTxFee;
|
2015-06-12 03:00:39 -07:00
|
|
|
extern bool fAlerts;
|
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
|
|
|
|
|
|
|
// 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.
|
2014-11-30 17:39:44 -08:00
|
|
|
* @param[out] dbp If pblock is stored to disk (or already there), this will be set to its location.
|
|
|
|
* @return True if state.IsValid()
|
|
|
|
*/
|
2015-08-08 09:18:41 -07:00
|
|
|
bool ProcessNewBlock(CValidationState &state, const CNode* pfrom, const CBlock* pblock, bool fForceProcessing, 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 */
|
2012-10-21 12:23:13 -07:00
|
|
|
bool LoadExternalBlockFile(FILE* fileIn, CDiskBlockPos *dbp = NULL);
|
2013-01-30 12:43:36 -08:00
|
|
|
/** Initialize a new block tree database + block data on disk */
|
|
|
|
bool InitBlockIndex();
|
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.
|
|
|
|
* @param[in] fSendTrickle When true send the trickled data, otherwise trickle the data until true.
|
|
|
|
*/
|
2010-08-29 09:58:15 -07:00
|
|
|
bool SendMessages(CNode* pto, bool fSendTrickle);
|
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();
|
2015-03-26 08:20:59 -07:00
|
|
|
/** Try to detect Partition (network isolation) attacks against us */
|
2015-06-08 13:34:58 -07:00
|
|
|
void PartitionCheck(bool (*initialDownloadCheck)(), CCriticalSection& cs, const CBlockIndex *const &bestHeader, int64_t nPowTargetSpacing);
|
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();
|
2012-11-04 04:18:04 -08:00
|
|
|
/** Format a string that describes several potential problems detected by the core */
|
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) */
|
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
|
|
|
bool GetTransaction(const uint256 &hash, CTransaction &tx, 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-08-08 09:18:41 -07:00
|
|
|
bool ActivateBestChain(CValidationState &state, 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.)
|
|
|
|
* 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);
|
|
|
|
|
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,
|
2015-10-02 14:20:38 -07:00
|
|
|
bool* pfMissingInputs, bool fOverrideMempoolLimit=false, bool fRejectAbsurdFee=false);
|
2010-08-29 09:58:15 -07:00
|
|
|
|
|
|
|
|
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
|
|
|
};
|
|
|
|
|
2013-01-10 16:47:57 -08:00
|
|
|
struct CDiskTxPos : public CDiskBlockPos
|
|
|
|
{
|
|
|
|
unsigned int nTxOffset; // after header
|
|
|
|
|
2014-09-02 00:58:09 -07:00
|
|
|
ADD_SERIALIZE_METHODS;
|
overhaul serialization code
The implementation of each class' serialization/deserialization is no longer
passed within a macro. The implementation now lies within a template of form:
template <typename T, typename Stream, typename Operation>
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) {
size_t nSerSize = 0;
/* CODE */
return nSerSize;
}
In cases when codepath should depend on whether or not we are just deserializing
(old fGetSize, fWrite, fRead flags) an additional clause can be used:
bool fRead = boost::is_same<Operation, CSerActionUnserialize>();
The IMPLEMENT_SERIALIZE macro will now be a freestanding clause added within
class' body (similiar to Qt's Q_OBJECT) to implement GetSerializeSize,
Serialize and Unserialize. These are now wrappers around
the "SerializationOp" template.
2014-08-19 23:42:31 -07:00
|
|
|
|
2014-08-20 13:44:38 -07:00
|
|
|
template <typename Stream, typename Operation>
|
2014-08-20 15:49:32 -07:00
|
|
|
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
|
2013-01-10 16:47:57 -08:00
|
|
|
READWRITE(*(CDiskBlockPos*)this);
|
|
|
|
READWRITE(VARINT(nTxOffset));
|
overhaul serialization code
The implementation of each class' serialization/deserialization is no longer
passed within a macro. The implementation now lies within a template of form:
template <typename T, typename Stream, typename Operation>
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) {
size_t nSerSize = 0;
/* CODE */
return nSerSize;
}
In cases when codepath should depend on whether or not we are just deserializing
(old fGetSize, fWrite, fRead flags) an additional clause can be used:
bool fRead = boost::is_same<Operation, CSerActionUnserialize>();
The IMPLEMENT_SERIALIZE macro will now be a freestanding clause added within
class' body (similiar to Qt's Q_OBJECT) to implement GetSerializeSize,
Serialize and Unserialize. These are now wrappers around
the "SerializationOp" template.
2014-08-19 23:42:31 -07:00
|
|
|
}
|
2013-01-10 16:47:57 -08:00
|
|
|
|
|
|
|
CDiskTxPos(const CDiskBlockPos &blockIn, unsigned int nTxOffsetIn) : CDiskBlockPos(blockIn.nFile, blockIn.nPos), nTxOffset(nTxOffsetIn) {
|
|
|
|
}
|
|
|
|
|
|
|
|
CDiskTxPos() {
|
|
|
|
SetNull();
|
|
|
|
}
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2013-01-10 16:47:57 -08:00
|
|
|
void SetNull() {
|
|
|
|
CDiskBlockPos::SetNull();
|
|
|
|
nTxOffset = 0;
|
|
|
|
}
|
|
|
|
};
|
2010-08-29 09:58:15 -07:00
|
|
|
|
|
|
|
|
2014-04-22 15:46:19 -07:00
|
|
|
CAmount GetMinRelayFee(const CTransaction& tx, unsigned int nBytes, bool fAllowFree);
|
2013-01-08 03:42:22 -08: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
|
|
|
|
|
|
|
|
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 */
|
2014-10-27 08:07:50 -07:00
|
|
|
void UpdateCoins(const CTransaction& tx, CValidationState &state, 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-01 12:05:18 -08:00
|
|
|
bool CheckFinalTx(const CTransaction &tx);
|
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
|
|
|
|
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;
|
|
|
|
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:
|
2014-11-29 07:01:37 -08:00
|
|
|
CScriptCheck(): 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) :
|
2012-12-01 13:30:06 -08:00
|
|
|
scriptPubKey(txFromIn.vout[txToIn.vin[nInIn].prevout.n].scriptPubKey),
|
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);
|
|
|
|
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);
|
2013-06-23 18:21:33 -07:00
|
|
|
bool ReadBlockFromDisk(CBlock& block, const CDiskBlockPos& pos);
|
2013-06-23 18:10:02 -07:00
|
|
|
bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex);
|
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 */
|
|
|
|
|
|
|
|
/** 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. */
|
2015-08-08 09:18:41 -07:00
|
|
|
bool DisconnectBlock(const CBlock& block, CValidationState& state, const CBlockIndex* pindex, CCoinsViewCache& coins, bool* pfClean = NULL);
|
2013-06-23 18:32:58 -07:00
|
|
|
|
2014-11-30 17:39:44 -08:00
|
|
|
/** Apply the effects of this block (with given index) on the UTXO set represented by coins */
|
2014-10-19 19:10:03 -07:00
|
|
|
bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pindex, CCoinsViewCache& coins, bool fJustCheck = false);
|
2013-06-23 18:50:06 -07:00
|
|
|
|
2014-11-30 17:39:44 -08:00
|
|
|
/** Context-independent validity checks */
|
2014-03-11 09:36:21 -07:00
|
|
|
bool CheckBlockHeader(const CBlockHeader& block, CValidationState& state, bool fCheckPOW = true);
|
2013-06-23 19:14:11 -07:00
|
|
|
bool CheckBlock(const CBlock& block, CValidationState& state, bool fCheckPOW = true, bool fCheckMerkleRoot = true);
|
|
|
|
|
2014-11-30 17:39:44 -08:00
|
|
|
/** Context-dependent validity checks */
|
2014-10-19 16:09:50 -07:00
|
|
|
bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationState& state, CBlockIndex *pindexPrev);
|
|
|
|
bool ContextualCheckBlock(const CBlock& block, CValidationState& state, CBlockIndex *pindexPrev);
|
|
|
|
|
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) */
|
2014-10-19 19:10:03 -07:00
|
|
|
bool TestBlockValidity(CValidationState &state, const CBlock& block, CBlockIndex *pindexPrev, bool fCheckPOW = true, bool fCheckMerkleRoot = true);
|
|
|
|
|
2015-04-09 10:21:11 -07:00
|
|
|
/** Store block on disk. If dbp is non-NULL, the file is known to already reside on disk */
|
2015-08-08 09:18:41 -07:00
|
|
|
bool AcceptBlock(const CBlock& block, CValidationState& state, CBlockIndex **pindex, bool fRequested, CDiskBlockPos* dbp);
|
2014-07-11 15:02:35 -07:00
|
|
|
bool AcceptBlockHeader(const CBlockHeader& block, CValidationState& state, CBlockIndex **ppindex= NULL);
|
2013-06-23 19:27:02 -07:00
|
|
|
|
2013-06-23 18:32:58 -07:00
|
|
|
|
|
|
|
|
2012-08-13 10:11:05 -07:00
|
|
|
class CBlockFileInfo
|
|
|
|
{
|
|
|
|
public:
|
2014-11-30 17:39:44 -08:00
|
|
|
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
|
2012-08-13 10:11:05 -07:00
|
|
|
|
2014-09-02 00:58:09 -07:00
|
|
|
ADD_SERIALIZE_METHODS;
|
overhaul serialization code
The implementation of each class' serialization/deserialization is no longer
passed within a macro. The implementation now lies within a template of form:
template <typename T, typename Stream, typename Operation>
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) {
size_t nSerSize = 0;
/* CODE */
return nSerSize;
}
In cases when codepath should depend on whether or not we are just deserializing
(old fGetSize, fWrite, fRead flags) an additional clause can be used:
bool fRead = boost::is_same<Operation, CSerActionUnserialize>();
The IMPLEMENT_SERIALIZE macro will now be a freestanding clause added within
class' body (similiar to Qt's Q_OBJECT) to implement GetSerializeSize,
Serialize and Unserialize. These are now wrappers around
the "SerializationOp" template.
2014-08-19 23:42:31 -07:00
|
|
|
|
2014-08-20 13:44:38 -07:00
|
|
|
template <typename Stream, typename Operation>
|
2014-08-20 15:49:32 -07:00
|
|
|
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
|
2012-08-13 10:11:05 -07:00
|
|
|
READWRITE(VARINT(nBlocks));
|
|
|
|
READWRITE(VARINT(nSize));
|
|
|
|
READWRITE(VARINT(nUndoSize));
|
|
|
|
READWRITE(VARINT(nHeightFirst));
|
|
|
|
READWRITE(VARINT(nHeightLast));
|
|
|
|
READWRITE(VARINT(nTimeFirst));
|
|
|
|
READWRITE(VARINT(nTimeLast));
|
overhaul serialization code
The implementation of each class' serialization/deserialization is no longer
passed within a macro. The implementation now lies within a template of form:
template <typename T, typename Stream, typename Operation>
inline static size_t SerializationOp(T thisPtr, Stream& s, Operation ser_action, int nType, int nVersion) {
size_t nSerSize = 0;
/* CODE */
return nSerSize;
}
In cases when codepath should depend on whether or not we are just deserializing
(old fGetSize, fWrite, fRead flags) an additional clause can be used:
bool fRead = boost::is_same<Operation, CSerActionUnserialize>();
The IMPLEMENT_SERIALIZE macro will now be a freestanding clause added within
class' body (similiar to Qt's Q_OBJECT) to implement GetSerializeSize,
Serialize and Unserialize. These are now wrappers around
the "SerializationOp" template.
2014-08-19 23:42:31 -07:00
|
|
|
}
|
2012-08-13 10:11:05 -07:00
|
|
|
|
|
|
|
void SetNull() {
|
|
|
|
nBlocks = 0;
|
|
|
|
nSize = 0;
|
|
|
|
nUndoSize = 0;
|
|
|
|
nHeightFirst = 0;
|
|
|
|
nHeightLast = 0;
|
|
|
|
nTimeFirst = 0;
|
|
|
|
nTimeLast = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
CBlockFileInfo() {
|
|
|
|
SetNull();
|
|
|
|
}
|
|
|
|
|
2014-08-20 20:17:21 -07:00
|
|
|
std::string ToString() const;
|
2012-08-13 10:11:05 -07:00
|
|
|
|
2014-11-30 17:39:44 -08:00
|
|
|
/** update statistics (does not update nSize) */
|
2013-04-12 22:13:08 -07:00
|
|
|
void AddBlock(unsigned int nHeightIn, uint64_t nTimeIn) {
|
2012-08-13 10:11:05 -07:00
|
|
|
if (nBlocks==0 || nHeightFirst > nHeightIn)
|
|
|
|
nHeightFirst = nHeightIn;
|
|
|
|
if (nBlocks==0 || nTimeFirst > nTimeIn)
|
|
|
|
nTimeFirst = nTimeIn;
|
|
|
|
nBlocks++;
|
2013-09-19 01:44:35 -07:00
|
|
|
if (nHeightIn > nHeightLast)
|
2012-08-13 10:11:05 -07:00
|
|
|
nHeightLast = nHeightIn;
|
|
|
|
if (nTimeIn > nTimeLast)
|
|
|
|
nTimeLast = nTimeIn;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
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();
|
2014-08-27 00:20:33 -07:00
|
|
|
bool VerifyDB(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. */
|
|
|
|
bool InvalidateBlock(CValidationState& state, CBlockIndex *pindex);
|
|
|
|
|
|
|
|
/** Remove invalidity status from a block and its descendants. */
|
|
|
|
bool ReconsiderBlock(CValidationState& state, CBlockIndex *pindex);
|
|
|
|
|
2013-10-10 14:07:44 -07:00
|
|
|
/** The currently-connected chain of blocks. */
|
|
|
|
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);
|
|
|
|
|
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
|