2010-08-29 09:58:15 -07:00
|
|
|
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
2014-02-08 13:50:24 -08:00
|
|
|
// Copyright (c) 2009-2014 The Bitcoin developers
|
2010-08-29 09:58:15 -07:00
|
|
|
// Distributed under the MIT/X11 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
|
|
|
|
|
2013-04-12 22:13:08 -07:00
|
|
|
#include "chainparams.h"
|
2013-11-04 17:47:07 -08:00
|
|
|
#include "coins.h"
|
2013-04-12 22:13:08 -07:00
|
|
|
#include "core.h"
|
2011-05-15 00:11:04 -07:00
|
|
|
#include "net.h"
|
|
|
|
#include "script.h"
|
2013-04-12 22:13:08 -07:00
|
|
|
#include "sync.h"
|
|
|
|
#include "txmempool.h"
|
|
|
|
#include "uint256.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
|
|
|
|
|
|
|
class CBlockIndex;
|
2013-04-12 22:13:08 -07:00
|
|
|
class CBloomFilter;
|
2011-05-14 14:20:30 -07:00
|
|
|
class CInv;
|
|
|
|
|
2012-11-02 16:14:43 -07:00
|
|
|
/** The maximum allowed size for a serialized block, in bytes (network rule) */
|
2010-08-29 09:58:15 -07:00
|
|
|
static const unsigned int MAX_BLOCK_SIZE = 1000000;
|
2014-03-10 10:59:12 -07:00
|
|
|
/** Default for -blockmaxsize and -blockminsize, which control the range of sizes the mining code will create **/
|
2013-11-27 19:03:41 -08:00
|
|
|
static const unsigned int DEFAULT_BLOCK_MAX_SIZE = 750000;
|
2014-03-10 10:59:12 -07:00
|
|
|
static const unsigned int DEFAULT_BLOCK_MIN_SIZE = 0;
|
2013-11-27 19:03:41 -08:00
|
|
|
/** Default for -blockprioritysize, maximum space for zero/low-fee transactions **/
|
|
|
|
static const unsigned int DEFAULT_BLOCK_PRIORITY_SIZE = 50000;
|
2013-01-18 06:07:05 -08:00
|
|
|
/** The maximum size for transactions we're willing to relay/mine */
|
2013-11-27 19:03:41 -08:00
|
|
|
static const unsigned int MAX_STANDARD_TX_SIZE = 100000;
|
2012-11-02 16:14:43 -07:00
|
|
|
/** The maximum allowed number of signature check operations in a block (network rule) */
|
2012-04-23 11:14:03 -07:00
|
|
|
static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
|
2014-06-17 11:18:13 -07:00
|
|
|
/** Maxiumum number of signature check operations in an IsStandard() P2SH script */
|
|
|
|
static const unsigned int MAX_P2SH_SIGOPS = 15;
|
2012-11-02 16:14:43 -07:00
|
|
|
/** The maximum number of orphan transactions kept in memory */
|
2012-04-23 11:14:03 -07:00
|
|
|
static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
|
2014-05-30 05:35:23 -07:00
|
|
|
/** Default for -maxorphanblocks, maximum number of orphan blocks kept in memory */
|
|
|
|
static const unsigned int DEFAULT_MAX_ORPHAN_BLOCKS = 750;
|
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-11-02 16:14:43 -07:00
|
|
|
/** Coinbase transaction outputs can only be spent after this number of new blocks (network rule) */
|
2010-08-29 09:58:15 -07:00
|
|
|
static const int COINBASE_MATURITY = 100;
|
2012-11-02 16:14:43 -07:00
|
|
|
/** Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp. */
|
2012-05-08 18:48:14 -07:00
|
|
|
static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC
|
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. */
|
|
|
|
static const int MAX_BLOCKS_IN_TRANSIT_PER_PEER = 128;
|
|
|
|
/** Timeout in seconds before considering a block download peer unresponsive. */
|
|
|
|
static const unsigned int BLOCK_DOWNLOAD_TIMEOUT = 60;
|
|
|
|
|
2013-10-27 23:36:11 -07:00
|
|
|
/** "reject" message codes **/
|
|
|
|
static const unsigned char REJECT_MALFORMED = 0x01;
|
|
|
|
static const unsigned char REJECT_INVALID = 0x10;
|
|
|
|
static const unsigned char REJECT_OBSOLETE = 0x11;
|
|
|
|
static const unsigned char REJECT_DUPLICATE = 0x12;
|
|
|
|
static const unsigned char REJECT_NONSTANDARD = 0x40;
|
|
|
|
static const unsigned char REJECT_DUST = 0x41;
|
|
|
|
static const unsigned char REJECT_INSUFFICIENTFEE = 0x42;
|
|
|
|
static const unsigned char REJECT_CHECKPOINT = 0x43;
|
|
|
|
|
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;
|
2011-05-15 00:11:04 -07:00
|
|
|
extern std::map<uint256, CBlockIndex*> 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;
|
2013-04-12 22:13:08 -07:00
|
|
|
extern int64_t nTimeBestReceived;
|
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 11:10:23 -08:00
|
|
|
extern bool fBenchmark;
|
2012-12-01 14:04:14 -08:00
|
|
|
extern int nScriptCheckThreads;
|
2013-01-10 16:47:57 -08:00
|
|
|
extern bool fTxIndex;
|
2012-11-04 08:11:48 -08:00
|
|
|
extern unsigned int nCoinCacheSize;
|
2014-07-03 11:25:32 -07:00
|
|
|
extern CFeeRate minRelayTxFee;
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2012-05-13 22:49:17 -07: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
|
|
|
|
|
|
|
|
2012-09-03 06:26:57 -07:00
|
|
|
class CBlockTreeDB;
|
2013-01-29 19:03:49 -08:00
|
|
|
struct CDiskBlockPos;
|
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
|
|
|
class CTxUndo;
|
2012-12-01 14:04:14 -08:00
|
|
|
class CScriptCheck;
|
2013-01-26 15:14:11 -08:00
|
|
|
class CValidationState;
|
2013-10-19 09:34:06 -07:00
|
|
|
class CWalletInterface;
|
2013-11-17 16:25:17 -08:00
|
|
|
struct CNodeStateStats;
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2012-12-19 12:21:21 -08:00
|
|
|
struct CBlockTemplate;
|
|
|
|
|
2014-07-02 09:27:29 -07:00
|
|
|
/** Initialize respend bloom filter **/
|
|
|
|
void InitRespendFilter();
|
2014-06-25 23:41:44 -07:00
|
|
|
|
2012-11-04 04:18:04 -08:00
|
|
|
/** Register a wallet to receive updates from core */
|
2013-10-19 09:34:06 -07:00
|
|
|
void RegisterWallet(CWalletInterface* pwalletIn);
|
2012-11-04 04:18:04 -08:00
|
|
|
/** Unregister a wallet from core */
|
2013-10-19 09:34:06 -07:00
|
|
|
void UnregisterWallet(CWalletInterface* pwalletIn);
|
2013-01-23 12:48:35 -08:00
|
|
|
/** Unregister all wallets from core */
|
|
|
|
void UnregisterAllWallets();
|
2012-11-04 04:18:04 -08:00
|
|
|
/** Push an updated transaction to all registered wallets */
|
2014-06-09 01:02:00 -07:00
|
|
|
void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL);
|
2013-01-07 06:39:53 -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);
|
|
|
|
|
2013-01-07 06:39:53 -08:00
|
|
|
void PushGetBlocks(CNode* pnode, CBlockIndex* pindexBegin, uint256 hashEnd);
|
|
|
|
|
2012-11-04 04:18:04 -08:00
|
|
|
/** Process an incoming block */
|
2013-01-26 15:14:11 -08:00
|
|
|
bool ProcessBlock(CValidationState &state, CNode* pfrom, CBlock* pblock, CDiskBlockPos *dbp = NULL);
|
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);
|
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
|
|
|
/** Print the loaded block tree */
|
2010-08-29 09:58:15 -07:00
|
|
|
void PrintBlockTree();
|
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);
|
2012-11-04 04:18:04 -08:00
|
|
|
/** Send queued protocol messages to be sent to a give node */
|
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();
|
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 */
|
2011-05-15 00:11:04 -07:00
|
|
|
std::string GetWarnings(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 */
|
2013-11-16 10:28:24 -08:00
|
|
|
bool ActivateBestChain(CValidationState &state);
|
2013-04-12 22:13:08 -07:00
|
|
|
int64_t GetBlockValue(int nHeight, int64_t nFees);
|
2013-01-08 14:58:06 -08:00
|
|
|
|
|
|
|
void UpdateTime(CBlockHeader& block, const CBlockIndex* pindexPrev);
|
|
|
|
|
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);
|
2012-09-08 08:33:10 -07:00
|
|
|
/** Verify a signature */
|
|
|
|
bool VerifySignature(const CCoins& txFrom, const CTransaction& txTo, unsigned int nIn, unsigned int flags, int nHashType);
|
2013-01-26 16:24:06 -08:00
|
|
|
/** Abort with a message */
|
|
|
|
bool AbortNode(const std::string &msg);
|
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);
|
|
|
|
|
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,
|
|
|
|
bool* pfMissingInputs, bool fRejectInsaneFee=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;
|
2013-11-17 16:25:17 -08:00
|
|
|
};
|
|
|
|
|
2013-01-10 16:47:57 -08:00
|
|
|
struct CDiskBlockPos
|
2012-06-18 16:36:43 -07:00
|
|
|
{
|
2012-08-13 10:11:05 -07:00
|
|
|
int nFile;
|
|
|
|
unsigned int nPos;
|
2012-06-18 16:36:43 -07:00
|
|
|
|
2012-08-13 10:11:05 -07:00
|
|
|
IMPLEMENT_SERIALIZE(
|
|
|
|
READWRITE(VARINT(nFile));
|
|
|
|
READWRITE(VARINT(nPos));
|
|
|
|
)
|
2012-06-18 16:36:43 -07:00
|
|
|
|
2012-12-03 01:14:54 -08:00
|
|
|
CDiskBlockPos() {
|
|
|
|
SetNull();
|
|
|
|
}
|
|
|
|
|
|
|
|
CDiskBlockPos(int nFileIn, unsigned int nPosIn) {
|
|
|
|
nFile = nFileIn;
|
|
|
|
nPos = nPosIn;
|
|
|
|
}
|
|
|
|
|
2012-06-18 16:36:43 -07:00
|
|
|
friend bool operator==(const CDiskBlockPos &a, const CDiskBlockPos &b) {
|
2012-08-13 10:11:05 -07:00
|
|
|
return (a.nFile == b.nFile && a.nPos == b.nPos);
|
2012-06-18 16:36:43 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
friend bool operator!=(const CDiskBlockPos &a, const CDiskBlockPos &b) {
|
|
|
|
return !(a == b);
|
|
|
|
}
|
|
|
|
|
2012-08-13 10:11:05 -07:00
|
|
|
void SetNull() { nFile = -1; nPos = 0; }
|
|
|
|
bool IsNull() const { return (nFile == -1); }
|
2012-06-18 16:36:43 -07:00
|
|
|
};
|
|
|
|
|
2013-01-10 16:47:57 -08:00
|
|
|
struct CDiskTxPos : public CDiskBlockPos
|
|
|
|
{
|
|
|
|
unsigned int nTxOffset; // after header
|
|
|
|
|
|
|
|
IMPLEMENT_SERIALIZE(
|
|
|
|
READWRITE(*(CDiskBlockPos*)this);
|
|
|
|
READWRITE(VARINT(nTxOffset));
|
|
|
|
)
|
|
|
|
|
|
|
|
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-05-27 12:44:57 -07:00
|
|
|
int64_t GetMinRelayFee(const CTransaction& tx, unsigned int nBytes, bool fAllowFree);
|
2013-01-08 03:42:22 -08:00
|
|
|
|
2013-01-08 04:17:15 -08:00
|
|
|
//
|
|
|
|
// Check transaction inputs, and make sure any
|
|
|
|
// pay-to-script-hash transactions are evaluating IsStandard scripts
|
|
|
|
//
|
|
|
|
// Why bother? To avoid denial-of-service attacks; an attacker
|
|
|
|
// can submit a standard HASH... OP_EQUAL transaction,
|
|
|
|
// which will get accepted into blocks. The redemption
|
|
|
|
// script can be anything; an attacker could use a very
|
|
|
|
// expensive-to-check-upon-redemption script like:
|
|
|
|
// DUP CHECKSIG DROP ... repeated 100 times... OP_1
|
|
|
|
//
|
2012-01-04 18:40:52 -08:00
|
|
|
|
2014-03-07 12:34:53 -08:00
|
|
|
/** Check for standard transaction types
|
|
|
|
@param[in] mapInputs Map of previous transactions that have outputs we're spending
|
|
|
|
@return True if all inputs (scriptSigs) use only standard transaction forms
|
|
|
|
*/
|
2013-01-08 04:17:15 -08:00
|
|
|
bool AreInputsStandard(const CTransaction& tx, CCoinsViewCache& mapInputs);
|
2012-01-10 17:18:00 -08:00
|
|
|
|
2013-01-08 04:17:15 -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
|
|
|
|
*/
|
|
|
|
unsigned int GetLegacySigOpCount(const CTransaction& tx);
|
2010-12-07 05:43:31 -08:00
|
|
|
|
2013-01-08 04:17:15 -08:00
|
|
|
/** Count ECDSA signature operations in pay-to-script-hash inputs.
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2013-01-08 04:17:15 -08:00
|
|
|
@param[in] mapInputs Map of previous transactions that have outputs we're spending
|
|
|
|
@return maximum number of sigops required to validate this transaction's inputs
|
|
|
|
@see CTransaction::FetchInputs
|
|
|
|
*/
|
|
|
|
unsigned int GetP2SHSigOpCount(const CTransaction& tx, CCoinsViewCache& mapInputs);
|
2010-08-29 09:58:15 -07:00
|
|
|
|
|
|
|
|
2013-01-08 04:17:15 -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.
|
|
|
|
bool CheckInputs(const CTransaction& tx, CValidationState &state, CCoinsViewCache &view, bool fScriptChecks = true,
|
2014-03-10 14:31:46 -07:00
|
|
|
unsigned int flags = STANDARD_SCRIPT_VERIFY_FLAGS,
|
2013-01-08 04:17:15 -08:00
|
|
|
std::vector<CScriptCheck> *pvChecks = NULL);
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2013-01-08 04:17:15 -08:00
|
|
|
// Apply the effects of this transaction on the UTXO set represented by view
|
2014-06-09 01:02:00 -07:00
|
|
|
void UpdateCoins(const CTransaction& tx, CValidationState &state, CCoinsViewCache &inputs, CTxUndo &txundo, int nHeight);
|
2012-01-10 17:18:00 -08:00
|
|
|
|
2013-01-08 04:17:15 -08:00
|
|
|
// Context-independent validity checks
|
|
|
|
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
|
|
|
|
2013-01-08 04:17:15 -08:00
|
|
|
/** Check for standard transaction types
|
|
|
|
@return True if all outputs (scriptPubKeys) use only standard transaction forms
|
|
|
|
*/
|
2013-06-22 23:05:25 -07:00
|
|
|
bool IsStandardTx(const CTransaction& tx, std::string& reason);
|
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
|
|
|
|
2013-04-12 22:13:08 -07:00
|
|
|
bool IsFinalTx(const CTransaction &tx, int nBlockHeight = 0, int64_t nBlockTime = 0);
|
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
|
|
|
|
2012-06-23 05:17:13 -07:00
|
|
|
/** Undo information for a CBlock */
|
|
|
|
class CBlockUndo
|
|
|
|
{
|
|
|
|
public:
|
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
|
|
|
std::vector<CTxUndo> vtxundo; // for all but the coinbase
|
2012-06-23 05:17:13 -07:00
|
|
|
|
|
|
|
IMPLEMENT_SERIALIZE(
|
|
|
|
READWRITE(vtxundo);
|
|
|
|
)
|
2012-08-13 10:11:05 -07:00
|
|
|
|
2012-12-30 14:41:41 -08:00
|
|
|
bool WriteToDisk(CDiskBlockPos &pos, const uint256 &hashBlock)
|
2012-08-13 10:11:05 -07:00
|
|
|
{
|
|
|
|
// Open history file to append
|
|
|
|
CAutoFile fileout = CAutoFile(OpenUndoFile(pos), SER_DISK, CLIENT_VERSION);
|
|
|
|
if (!fileout)
|
2014-01-06 06:09:26 -08:00
|
|
|
return error("CBlockUndo::WriteToDisk : OpenUndoFile failed");
|
2012-08-13 10:11:05 -07:00
|
|
|
|
|
|
|
// Write index header
|
|
|
|
unsigned int nSize = fileout.GetSerializeSize(*this);
|
2013-05-07 06:16:25 -07:00
|
|
|
fileout << FLATDATA(Params().MessageStart()) << nSize;
|
2012-08-13 10:11:05 -07:00
|
|
|
|
|
|
|
// Write undo data
|
|
|
|
long fileOutPos = ftell(fileout);
|
|
|
|
if (fileOutPos < 0)
|
2014-01-06 06:09:26 -08:00
|
|
|
return error("CBlockUndo::WriteToDisk : ftell failed");
|
2012-08-13 10:11:05 -07:00
|
|
|
pos.nPos = (unsigned int)fileOutPos;
|
|
|
|
fileout << *this;
|
|
|
|
|
2012-12-30 14:41:41 -08:00
|
|
|
// calculate & write checksum
|
|
|
|
CHashWriter hasher(SER_GETHASH, PROTOCOL_VERSION);
|
|
|
|
hasher << hashBlock;
|
|
|
|
hasher << *this;
|
|
|
|
fileout << hasher.GetHash();
|
|
|
|
|
2012-08-13 10:11:05 -07:00
|
|
|
// Flush stdio buffers and commit to disk before returning
|
|
|
|
fflush(fileout);
|
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
|
|
|
if (!IsInitialBlockDownload())
|
2012-08-13 10:11:05 -07:00
|
|
|
FileCommit(fileout);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2012-12-30 14:41:41 -08:00
|
|
|
|
|
|
|
bool ReadFromDisk(const CDiskBlockPos &pos, const uint256 &hashBlock)
|
|
|
|
{
|
|
|
|
// Open history file to read
|
|
|
|
CAutoFile filein = CAutoFile(OpenUndoFile(pos, true), SER_DISK, CLIENT_VERSION);
|
|
|
|
if (!filein)
|
2014-01-06 06:09:26 -08:00
|
|
|
return error("CBlockUndo::ReadFromDisk : OpenBlockFile failed");
|
2012-12-30 14:41:41 -08:00
|
|
|
|
|
|
|
// Read block
|
|
|
|
uint256 hashChecksum;
|
|
|
|
try {
|
|
|
|
filein >> *this;
|
2013-01-28 12:05:11 -08:00
|
|
|
filein >> hashChecksum;
|
2012-12-30 14:41:41 -08:00
|
|
|
}
|
|
|
|
catch (std::exception &e) {
|
2014-04-30 05:45:24 -07:00
|
|
|
return error("%s : Deserialize or I/O error - %s", __func__, e.what());
|
2012-12-30 14:41:41 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Verify checksum
|
|
|
|
CHashWriter hasher(SER_GETHASH, PROTOCOL_VERSION);
|
|
|
|
hasher << hashBlock;
|
|
|
|
hasher << *this;
|
|
|
|
if (hashChecksum != hasher.GetHash())
|
2014-01-06 06:09:26 -08:00
|
|
|
return error("CBlockUndo::ReadFromDisk : Checksum mismatch");
|
2012-12-30 14:41:41 -08:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2012-06-23 05:17:13 -07:00
|
|
|
};
|
|
|
|
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2012-12-01 13:30:06 -08:00
|
|
|
/** Closure representing one script verification
|
|
|
|
* Note that this stores references to the spending transaction */
|
|
|
|
class CScriptCheck
|
|
|
|
{
|
|
|
|
private:
|
|
|
|
CScript scriptPubKey;
|
|
|
|
const CTransaction *ptxTo;
|
|
|
|
unsigned int nIn;
|
|
|
|
unsigned int nFlags;
|
|
|
|
int nHashType;
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2012-12-01 13:30:06 -08:00
|
|
|
public:
|
|
|
|
CScriptCheck() {}
|
|
|
|
CScriptCheck(const CCoins& txFromIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, int nHashTypeIn) :
|
|
|
|
scriptPubKey(txFromIn.vout[txToIn.vin[nInIn].prevout.n].scriptPubKey),
|
|
|
|
ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), nHashType(nHashTypeIn) { }
|
|
|
|
|
|
|
|
bool operator()() const;
|
|
|
|
|
|
|
|
void swap(CScriptCheck &check) {
|
|
|
|
scriptPubKey.swap(check.scriptPubKey);
|
|
|
|
std::swap(ptxTo, check.ptxTo);
|
|
|
|
std::swap(nIn, check.nIn);
|
|
|
|
std::swap(nFlags, check.nFlags);
|
|
|
|
std::swap(nHashType, check.nHashType);
|
|
|
|
}
|
|
|
|
};
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2012-03-26 07:48:23 -07:00
|
|
|
/** A transaction with a merkle branch linking it to the block chain. */
|
2010-08-29 09:58:15 -07:00
|
|
|
class CMerkleTx : public CTransaction
|
|
|
|
{
|
2014-02-12 10:43:07 -08:00
|
|
|
private:
|
|
|
|
int GetDepthInMainChainINTERNAL(CBlockIndex* &pindexRet) const;
|
2014-02-10 07:31:06 -08:00
|
|
|
|
2010-08-29 09:58:15 -07:00
|
|
|
public:
|
|
|
|
uint256 hashBlock;
|
2011-05-15 00:11:04 -07:00
|
|
|
std::vector<uint256> vMerkleBranch;
|
2010-08-29 09:58:15 -07:00
|
|
|
int nIndex;
|
|
|
|
|
|
|
|
// memory only
|
2012-04-21 04:31:08 -07:00
|
|
|
mutable bool fMerkleVerified;
|
2010-08-29 09:58:15 -07:00
|
|
|
|
|
|
|
|
|
|
|
CMerkleTx()
|
|
|
|
{
|
|
|
|
Init();
|
|
|
|
}
|
|
|
|
|
|
|
|
CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
|
|
|
|
{
|
|
|
|
Init();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Init()
|
|
|
|
{
|
|
|
|
hashBlock = 0;
|
|
|
|
nIndex = -1;
|
|
|
|
fMerkleVerified = false;
|
|
|
|
}
|
|
|
|
|
2011-03-17 14:51:59 -07:00
|
|
|
|
2010-08-29 09:58:15 -07:00
|
|
|
IMPLEMENT_SERIALIZE
|
|
|
|
(
|
|
|
|
nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
|
|
|
|
nVersion = this->nVersion;
|
|
|
|
READWRITE(hashBlock);
|
|
|
|
READWRITE(vMerkleBranch);
|
|
|
|
READWRITE(nIndex);
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
|
|
int SetMerkleBranch(const CBlock* pblock=NULL);
|
2014-02-12 10:43:07 -08:00
|
|
|
|
|
|
|
// Return depth of transaction in blockchain:
|
|
|
|
// -1 : not in blockchain, and not in memory pool (conflicted transaction)
|
|
|
|
// 0 : in memory pool, waiting to be included in a block
|
|
|
|
// >=1 : this many blocks deep in the main chain
|
2011-07-11 12:49:45 -07:00
|
|
|
int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
|
|
|
|
int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
|
2014-02-12 10:43:07 -08:00
|
|
|
bool IsInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChainINTERNAL(pindexRet) > 0; }
|
2010-08-29 09:58:15 -07:00
|
|
|
int GetBlocksToMaturity() const;
|
2014-06-23 07:58:59 -07:00
|
|
|
bool AcceptToMemoryPool(bool fLimitFree=true, bool fRejectInsaneFee=true);
|
2010-08-29 09:58:15 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2012-10-27 12:08:45 -07:00
|
|
|
/** Data structure that represents a partial merkle tree.
|
|
|
|
*
|
|
|
|
* It respresents a subset of the txid's of a known block, in a way that
|
|
|
|
* allows recovery of the list of txid's and the merkle root, in an
|
|
|
|
* authenticated way.
|
|
|
|
*
|
|
|
|
* The encoding works as follows: we traverse the tree in depth-first order,
|
|
|
|
* storing a bit for each traversed node, signifying whether the node is the
|
|
|
|
* parent of at least one matched leaf txid (or a matched txid itself). In
|
|
|
|
* case we are at the leaf level, or this bit is 0, its merkle node hash is
|
|
|
|
* stored, and its children are not explorer further. Otherwise, no hash is
|
|
|
|
* stored, but we recurse into both (or the only) child branch. During
|
|
|
|
* decoding, the same depth-first traversal is performed, consuming bits and
|
|
|
|
* hashes as they written during encoding.
|
|
|
|
*
|
|
|
|
* The serialization is fixed and provides a hard guarantee about the
|
|
|
|
* encoded size:
|
|
|
|
*
|
|
|
|
* SIZE <= 10 + ceil(32.25*N)
|
|
|
|
*
|
|
|
|
* Where N represents the number of leaf nodes of the partial tree. N itself
|
|
|
|
* is bounded by:
|
|
|
|
*
|
|
|
|
* N <= total_transactions
|
|
|
|
* N <= 1 + matched_transactions*tree_height
|
|
|
|
*
|
|
|
|
* The serialization format:
|
|
|
|
* - uint32 total_transactions (4 bytes)
|
|
|
|
* - varint number of hashes (1-3 bytes)
|
|
|
|
* - uint256[] hashes in depth-first order (<= 32*N bytes)
|
|
|
|
* - varint number of bytes of flag bits (1-3 bytes)
|
|
|
|
* - byte[] flag bits, packed per 8 in a byte, least significant bit first (<= 2*N-1 bits)
|
|
|
|
* The size constraints follow from this.
|
|
|
|
*/
|
|
|
|
class CPartialMerkleTree
|
|
|
|
{
|
|
|
|
protected:
|
|
|
|
// the total number of transactions in the block
|
|
|
|
unsigned int nTransactions;
|
|
|
|
|
|
|
|
// node-is-parent-of-matched-txid bits
|
|
|
|
std::vector<bool> vBits;
|
|
|
|
|
|
|
|
// txids and internal hashes
|
|
|
|
std::vector<uint256> vHash;
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2012-10-27 12:08:45 -07:00
|
|
|
// flag set when encountering invalid data
|
|
|
|
bool fBad;
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2012-10-27 12:08:45 -07:00
|
|
|
// helper function to efficiently calculate the number of nodes at given height in the merkle tree
|
|
|
|
unsigned int CalcTreeWidth(int height) {
|
|
|
|
return (nTransactions+(1 << height)-1) >> height;
|
|
|
|
}
|
|
|
|
|
|
|
|
// calculate the hash of a node in the merkle tree (at leaf level: the txid's themself)
|
|
|
|
uint256 CalcHash(int height, unsigned int pos, const std::vector<uint256> &vTxid);
|
|
|
|
|
|
|
|
// recursive function that traverses tree nodes, storing the data as bits and hashes
|
|
|
|
void TraverseAndBuild(int height, unsigned int pos, const std::vector<uint256> &vTxid, const std::vector<bool> &vMatch);
|
|
|
|
|
|
|
|
// recursive function that traverses tree nodes, consuming the bits and hashes produced by TraverseAndBuild.
|
|
|
|
// it returns the hash of the respective node.
|
|
|
|
uint256 TraverseAndExtract(int height, unsigned int pos, unsigned int &nBitsUsed, unsigned int &nHashUsed, std::vector<uint256> &vMatch);
|
|
|
|
|
|
|
|
public:
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2012-10-27 12:08:45 -07:00
|
|
|
// serialization implementation
|
|
|
|
IMPLEMENT_SERIALIZE(
|
|
|
|
READWRITE(nTransactions);
|
|
|
|
READWRITE(vHash);
|
|
|
|
std::vector<unsigned char> vBytes;
|
|
|
|
if (fRead) {
|
|
|
|
READWRITE(vBytes);
|
|
|
|
CPartialMerkleTree &us = *(const_cast<CPartialMerkleTree*>(this));
|
|
|
|
us.vBits.resize(vBytes.size() * 8);
|
|
|
|
for (unsigned int p = 0; p < us.vBits.size(); p++)
|
|
|
|
us.vBits[p] = (vBytes[p / 8] & (1 << (p % 8))) != 0;
|
|
|
|
us.fBad = false;
|
|
|
|
} else {
|
|
|
|
vBytes.resize((vBits.size()+7)/8);
|
|
|
|
for (unsigned int p = 0; p < vBits.size(); p++)
|
|
|
|
vBytes[p / 8] |= vBits[p] << (p % 8);
|
|
|
|
READWRITE(vBytes);
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
// Construct a partial merkle tree from a list of transaction id's, and a mask that selects a subset of them
|
|
|
|
CPartialMerkleTree(const std::vector<uint256> &vTxid, const std::vector<bool> &vMatch);
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2012-10-27 12:08:45 -07:00
|
|
|
CPartialMerkleTree();
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2012-10-27 12:08:45 -07:00
|
|
|
// extract the matching txid's represented by this partial merkle tree.
|
|
|
|
// returns the merkle root, or 0 in case of failure
|
|
|
|
uint256 ExtractMatches(std::vector<uint256> &vMatch);
|
|
|
|
};
|
2010-08-29 09:58:15 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
2013-06-23 17:35:01 -07:00
|
|
|
/** Functions for disk access for blocks */
|
2013-06-23 17:47:47 -07:00
|
|
|
bool WriteBlockToDisk(CBlock& block, CDiskBlockPos& pos);
|
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. */
|
|
|
|
bool DisconnectBlock(CBlock& block, CValidationState& state, CBlockIndex* pindex, CCoinsViewCache& coins, bool* pfClean = NULL);
|
|
|
|
|
2013-06-23 18:50:06 -07:00
|
|
|
// Apply the effects of this block (with given index) on the UTXO set represented by coins
|
|
|
|
bool ConnectBlock(CBlock& block, CValidationState& state, CBlockIndex* pindex, CCoinsViewCache& coins, bool fJustCheck = false);
|
|
|
|
|
2013-06-23 19:00:18 -07:00
|
|
|
// Add this block to the block index, and if necessary, switch the active block chain to this
|
|
|
|
bool AddToBlockIndex(CBlock& block, CValidationState& state, const CDiskBlockPos& pos);
|
2013-06-23 18:50:06 -07:00
|
|
|
|
2013-06-23 19:14:11 -07: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);
|
|
|
|
|
2013-06-23 19:27:02 -07:00
|
|
|
// Store block on disk
|
|
|
|
// if dbp is provided, the file is known to already reside on disk
|
2014-03-12 19:48:27 -07:00
|
|
|
bool AcceptBlock(CBlock& block, CValidationState& state, CBlockIndex **pindex, CDiskBlockPos* dbp = NULL);
|
|
|
|
bool AcceptBlockHeader(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:
|
|
|
|
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
|
2013-04-12 22:13:08 -07:00
|
|
|
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
|
|
|
|
|
|
|
IMPLEMENT_SERIALIZE(
|
|
|
|
READWRITE(VARINT(nBlocks));
|
|
|
|
READWRITE(VARINT(nSize));
|
|
|
|
READWRITE(VARINT(nUndoSize));
|
|
|
|
READWRITE(VARINT(nHeightFirst));
|
|
|
|
READWRITE(VARINT(nHeightLast));
|
|
|
|
READWRITE(VARINT(nTimeFirst));
|
|
|
|
READWRITE(VARINT(nTimeLast));
|
|
|
|
)
|
|
|
|
|
|
|
|
void SetNull() {
|
|
|
|
nBlocks = 0;
|
|
|
|
nSize = 0;
|
|
|
|
nUndoSize = 0;
|
|
|
|
nHeightFirst = 0;
|
|
|
|
nHeightLast = 0;
|
|
|
|
nTimeFirst = 0;
|
|
|
|
nTimeLast = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
CBlockFileInfo() {
|
|
|
|
SetNull();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string ToString() const {
|
2013-01-18 06:07:05 -08:00
|
|
|
return strprintf("CBlockFileInfo(blocks=%u, size=%u, heights=%u...%u, time=%s...%s)", nBlocks, nSize, nHeightFirst, nHeightLast, DateTimeStrFormat("%Y-%m-%d", nTimeFirst).c_str(), DateTimeStrFormat("%Y-%m-%d", nTimeLast).c_str());
|
2012-08-13 10:11:05 -07: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;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2012-08-18 15:33:01 -07:00
|
|
|
enum BlockStatus {
|
|
|
|
BLOCK_VALID_UNKNOWN = 0,
|
|
|
|
BLOCK_VALID_HEADER = 1, // parsed, version ok, hash satisfies claimed PoW, 1 <= vtx count <= max, timestamp not in future
|
|
|
|
BLOCK_VALID_TREE = 2, // parent found, difficulty matches, timestamp >= median previous, checkpoint
|
|
|
|
BLOCK_VALID_TRANSACTIONS = 3, // only first tx is coinbase, 2 <= coinbase input script length <= 100, transactions valid, no duplicate txids, sigops, size, merkle root
|
|
|
|
BLOCK_VALID_CHAIN = 4, // outputs do not overspend inputs, no double spends, coinbase output ok, immature coinbase spends, BIP30
|
|
|
|
BLOCK_VALID_SCRIPTS = 5, // scripts/signatures ok
|
|
|
|
BLOCK_VALID_MASK = 7,
|
|
|
|
|
|
|
|
BLOCK_HAVE_DATA = 8, // full block available in blk*.dat
|
|
|
|
BLOCK_HAVE_UNDO = 16, // undo data available in rev*.dat
|
|
|
|
BLOCK_HAVE_MASK = 24,
|
|
|
|
|
|
|
|
BLOCK_FAILED_VALID = 32, // stage after last reached validness failed
|
|
|
|
BLOCK_FAILED_CHILD = 64, // descends from failed block
|
|
|
|
BLOCK_FAILED_MASK = 96
|
|
|
|
};
|
|
|
|
|
2012-03-26 07:48:23 -07:00
|
|
|
/** The block chain is a tree shaped structure starting with the
|
|
|
|
* genesis block at the root, with each block potentially having multiple
|
2013-05-12 06:50:22 -07:00
|
|
|
* candidates to be the next block. A blockindex may have multiple pprev pointing
|
|
|
|
* to it, but at most one of them can be part of the currently active branch.
|
2012-03-26 07:48:23 -07:00
|
|
|
*/
|
2010-08-29 09:58:15 -07:00
|
|
|
class CBlockIndex
|
|
|
|
{
|
|
|
|
public:
|
2012-08-18 15:33:01 -07:00
|
|
|
// pointer to the hash of the block, if any. memory is owned by this CBlockIndex
|
2010-08-29 09:58:15 -07:00
|
|
|
const uint256* phashBlock;
|
2012-08-18 15:33:01 -07:00
|
|
|
|
|
|
|
// pointer to the index of the predecessor of this block
|
2010-08-29 09:58:15 -07:00
|
|
|
CBlockIndex* pprev;
|
2012-08-18 15:33:01 -07:00
|
|
|
|
2014-06-24 15:56:47 -07:00
|
|
|
// pointer to the index of some further predecessor of this block
|
|
|
|
CBlockIndex* pskip;
|
|
|
|
|
2012-08-18 15:33:01 -07:00
|
|
|
// height of the entry in the chain. The genesis block has height 0
|
2010-08-29 09:58:15 -07:00
|
|
|
int nHeight;
|
2012-08-18 15:33:01 -07:00
|
|
|
|
|
|
|
// Which # file this block is stored in (blk?????.dat)
|
|
|
|
int nFile;
|
|
|
|
|
|
|
|
// Byte offset within blk?????.dat where this block's data is stored
|
|
|
|
unsigned int nDataPos;
|
|
|
|
|
|
|
|
// Byte offset within rev?????.dat where this block's undo data is stored
|
2012-08-13 10:11:05 -07:00
|
|
|
unsigned int nUndoPos;
|
2012-08-18 15:33:01 -07:00
|
|
|
|
|
|
|
// (memory only) Total amount of work (expected number of hashes) in the chain up to and including this block
|
2013-03-28 15:51:50 -07:00
|
|
|
uint256 nChainWork;
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2012-08-18 15:33:01 -07:00
|
|
|
// Number of transactions in this block.
|
|
|
|
// Note: in a potential headers-first mode, this number cannot be relied upon
|
|
|
|
unsigned int nTx;
|
|
|
|
|
|
|
|
// (memory only) Number of transactions in the chain up to and including this block
|
|
|
|
unsigned int nChainTx; // change to 64-bit type when necessary; won't happen before 2030
|
|
|
|
|
|
|
|
// Verification status of this block. See enum BlockStatus
|
|
|
|
unsigned int nStatus;
|
|
|
|
|
2010-08-29 09:58:15 -07:00
|
|
|
// block header
|
|
|
|
int nVersion;
|
|
|
|
uint256 hashMerkleRoot;
|
|
|
|
unsigned int nTime;
|
|
|
|
unsigned int nBits;
|
|
|
|
unsigned int nNonce;
|
|
|
|
|
2013-11-16 10:28:24 -08:00
|
|
|
// (memory only) Sequencial id assigned to distinguish order in which blocks are received.
|
|
|
|
uint32_t nSequenceId;
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2014-07-02 09:36:43 -07:00
|
|
|
void SetNull()
|
2010-08-29 09:58:15 -07:00
|
|
|
{
|
|
|
|
phashBlock = NULL;
|
|
|
|
pprev = NULL;
|
2014-06-24 15:56:47 -07:00
|
|
|
pskip = NULL;
|
2010-08-29 09:58:15 -07:00
|
|
|
nHeight = 0;
|
2012-08-18 15:33:01 -07:00
|
|
|
nFile = 0;
|
|
|
|
nDataPos = 0;
|
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
|
|
|
nUndoPos = 0;
|
2013-03-28 15:51:50 -07:00
|
|
|
nChainWork = 0;
|
2012-08-18 15:33:01 -07:00
|
|
|
nTx = 0;
|
|
|
|
nChainTx = 0;
|
|
|
|
nStatus = 0;
|
2013-11-16 10:28:24 -08:00
|
|
|
nSequenceId = 0;
|
2010-08-29 09:58:15 -07:00
|
|
|
|
|
|
|
nVersion = 0;
|
|
|
|
hashMerkleRoot = 0;
|
|
|
|
nTime = 0;
|
|
|
|
nBits = 0;
|
|
|
|
nNonce = 0;
|
|
|
|
}
|
|
|
|
|
2014-07-02 09:36:43 -07:00
|
|
|
CBlockIndex()
|
|
|
|
{
|
|
|
|
SetNull();
|
|
|
|
}
|
|
|
|
|
2012-11-14 13:18:10 -08:00
|
|
|
CBlockIndex(CBlockHeader& block)
|
2010-08-29 09:58:15 -07:00
|
|
|
{
|
2014-07-02 09:36:43 -07:00
|
|
|
SetNull();
|
2010-08-29 09:58:15 -07:00
|
|
|
|
|
|
|
nVersion = block.nVersion;
|
|
|
|
hashMerkleRoot = block.hashMerkleRoot;
|
|
|
|
nTime = block.nTime;
|
|
|
|
nBits = block.nBits;
|
|
|
|
nNonce = block.nNonce;
|
|
|
|
}
|
|
|
|
|
2012-06-18 16:36:43 -07:00
|
|
|
CDiskBlockPos GetBlockPos() const {
|
2012-08-18 15:33:01 -07:00
|
|
|
CDiskBlockPos ret;
|
|
|
|
if (nStatus & BLOCK_HAVE_DATA) {
|
|
|
|
ret.nFile = nFile;
|
|
|
|
ret.nPos = nDataPos;
|
2012-12-03 01:14:54 -08:00
|
|
|
}
|
2012-08-18 15:33:01 -07:00
|
|
|
return ret;
|
2012-08-13 10:11:05 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
CDiskBlockPos GetUndoPos() const {
|
2012-08-18 15:33:01 -07:00
|
|
|
CDiskBlockPos ret;
|
|
|
|
if (nStatus & BLOCK_HAVE_UNDO) {
|
|
|
|
ret.nFile = nFile;
|
|
|
|
ret.nPos = nUndoPos;
|
2012-12-03 01:14:54 -08:00
|
|
|
}
|
2012-08-13 10:11:05 -07:00
|
|
|
return ret;
|
2012-06-18 16:36:43 -07:00
|
|
|
}
|
|
|
|
|
2012-11-14 13:18:10 -08:00
|
|
|
CBlockHeader GetBlockHeader() const
|
2010-12-05 01:29:30 -08:00
|
|
|
{
|
2012-11-14 13:18:10 -08:00
|
|
|
CBlockHeader block;
|
2010-12-05 01:29:30 -08:00
|
|
|
block.nVersion = nVersion;
|
|
|
|
if (pprev)
|
|
|
|
block.hashPrevBlock = pprev->GetBlockHash();
|
|
|
|
block.hashMerkleRoot = hashMerkleRoot;
|
|
|
|
block.nTime = nTime;
|
|
|
|
block.nBits = nBits;
|
|
|
|
block.nNonce = nNonce;
|
|
|
|
return block;
|
|
|
|
}
|
|
|
|
|
2010-08-29 09:58:15 -07:00
|
|
|
uint256 GetBlockHash() const
|
|
|
|
{
|
|
|
|
return *phashBlock;
|
|
|
|
}
|
|
|
|
|
2013-04-12 22:13:08 -07:00
|
|
|
int64_t GetBlockTime() const
|
2010-08-29 09:58:15 -07:00
|
|
|
{
|
2013-04-12 22:13:08 -07:00
|
|
|
return (int64_t)nTime;
|
2010-08-29 09:58:15 -07:00
|
|
|
}
|
|
|
|
|
2014-04-19 18:19:20 -07:00
|
|
|
uint256 GetBlockWork() const
|
2010-08-29 09:58:15 -07:00
|
|
|
{
|
2014-04-19 18:19:20 -07:00
|
|
|
uint256 bnTarget;
|
|
|
|
bool fNegative;
|
|
|
|
bool fOverflow;
|
|
|
|
bnTarget.SetCompact(nBits, &fNegative, &fOverflow);
|
|
|
|
if (fNegative || fOverflow || bnTarget == 0)
|
2010-08-29 09:58:15 -07:00
|
|
|
return 0;
|
2014-04-19 18:19:20 -07:00
|
|
|
// We need to compute 2**256 / (bnTarget+1), but we can't represent 2**256
|
|
|
|
// as it's too large for a uint256. However, as 2**256 is at least as large
|
|
|
|
// as bnTarget+1, it is equal to ((2**256 - bnTarget - 1) / (bnTarget+1)) + 1,
|
|
|
|
// or ~bnTarget / (nTarget+1) + 1.
|
|
|
|
return (~bnTarget / (bnTarget + 1)) + 1;
|
2010-08-29 09:58:15 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
enum { nMedianTimeSpan=11 };
|
|
|
|
|
2013-04-12 22:13:08 -07:00
|
|
|
int64_t GetMedianTimePast() const
|
2010-08-29 09:58:15 -07:00
|
|
|
{
|
2013-04-12 22:13:08 -07:00
|
|
|
int64_t pmedian[nMedianTimeSpan];
|
|
|
|
int64_t* pbegin = &pmedian[nMedianTimeSpan];
|
|
|
|
int64_t* pend = &pmedian[nMedianTimeSpan];
|
2010-08-29 09:58:15 -07:00
|
|
|
|
|
|
|
const CBlockIndex* pindex = this;
|
|
|
|
for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
|
|
|
|
*(--pbegin) = pindex->GetBlockTime();
|
|
|
|
|
2011-05-15 00:11:04 -07:00
|
|
|
std::sort(pbegin, pend);
|
2010-08-29 09:58:15 -07:00
|
|
|
return pbegin[(pend - pbegin)/2];
|
|
|
|
}
|
|
|
|
|
2012-06-27 16:30:39 -07:00
|
|
|
/**
|
|
|
|
* Returns true if there are nRequired or more blocks of minVersion or above
|
2014-03-22 11:52:26 -07:00
|
|
|
* in the last Params().ToCheckBlockUpgradeMajority() blocks, starting at pstart
|
|
|
|
* and going backwards.
|
2012-06-27 16:30:39 -07:00
|
|
|
*/
|
|
|
|
static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
|
2014-03-22 11:52:26 -07:00
|
|
|
unsigned int nRequired);
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2011-05-15 00:11:04 -07:00
|
|
|
std::string ToString() const
|
2010-08-29 09:58:15 -07:00
|
|
|
{
|
2013-10-10 14:07:44 -07:00
|
|
|
return strprintf("CBlockIndex(pprev=%p, nHeight=%d, merkle=%s, hashBlock=%s)",
|
|
|
|
pprev, nHeight,
|
2014-05-21 03:50:46 -07:00
|
|
|
hashMerkleRoot.ToString(),
|
|
|
|
GetBlockHash().ToString());
|
2010-08-29 09:58:15 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void print() const
|
|
|
|
{
|
2014-05-21 03:50:46 -07:00
|
|
|
LogPrintf("%s\n", ToString());
|
2010-08-29 09:58:15 -07:00
|
|
|
}
|
2014-03-12 19:48:27 -07:00
|
|
|
|
|
|
|
// Check whether this block index entry is valid up to the passed validity level.
|
|
|
|
bool IsValid(enum BlockStatus nUpTo = BLOCK_VALID_TRANSACTIONS) const
|
|
|
|
{
|
|
|
|
assert(!(nUpTo & ~BLOCK_VALID_MASK)); // Only validity flags allowed.
|
|
|
|
if (nStatus & BLOCK_FAILED_MASK)
|
|
|
|
return false;
|
|
|
|
return ((nStatus & BLOCK_VALID_MASK) >= nUpTo);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Raise the validity level of this block index entry.
|
|
|
|
// Returns true if the validity was changed.
|
|
|
|
bool RaiseValidity(enum BlockStatus nUpTo)
|
|
|
|
{
|
|
|
|
assert(!(nUpTo & ~BLOCK_VALID_MASK)); // Only validity flags allowed.
|
|
|
|
if (nStatus & BLOCK_FAILED_MASK)
|
|
|
|
return false;
|
|
|
|
if ((nStatus & BLOCK_VALID_MASK) < nUpTo) {
|
|
|
|
nStatus = (nStatus & ~BLOCK_VALID_MASK) | nUpTo;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2014-06-24 15:56:47 -07:00
|
|
|
// Build the skiplist pointer for this entry.
|
|
|
|
void BuildSkip();
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2014-06-24 15:56:47 -07:00
|
|
|
// Efficiently find an ancestor of this block.
|
|
|
|
CBlockIndex* GetAncestor(int height);
|
|
|
|
const CBlockIndex* GetAncestor(int height) const;
|
|
|
|
};
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2012-03-26 07:48:23 -07:00
|
|
|
/** Used to marshal pointers into hashes for db storage. */
|
2010-08-29 09:58:15 -07:00
|
|
|
class CDiskBlockIndex : public CBlockIndex
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
uint256 hashPrev;
|
|
|
|
|
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
|
|
|
CDiskBlockIndex() {
|
2010-08-29 09:58:15 -07:00
|
|
|
hashPrev = 0;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex) {
|
2010-08-29 09:58:15 -07:00
|
|
|
hashPrev = (pprev ? pprev->GetBlockHash() : 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
IMPLEMENT_SERIALIZE
|
|
|
|
(
|
|
|
|
if (!(nType & SER_GETHASH))
|
2012-08-18 15:33:01 -07:00
|
|
|
READWRITE(VARINT(nVersion));
|
|
|
|
|
|
|
|
READWRITE(VARINT(nHeight));
|
|
|
|
READWRITE(VARINT(nStatus));
|
|
|
|
READWRITE(VARINT(nTx));
|
|
|
|
if (nStatus & (BLOCK_HAVE_DATA | BLOCK_HAVE_UNDO))
|
|
|
|
READWRITE(VARINT(nFile));
|
|
|
|
if (nStatus & BLOCK_HAVE_DATA)
|
|
|
|
READWRITE(VARINT(nDataPos));
|
|
|
|
if (nStatus & BLOCK_HAVE_UNDO)
|
|
|
|
READWRITE(VARINT(nUndoPos));
|
2010-08-29 09:58:15 -07:00
|
|
|
|
|
|
|
// block header
|
|
|
|
READWRITE(this->nVersion);
|
|
|
|
READWRITE(hashPrev);
|
|
|
|
READWRITE(hashMerkleRoot);
|
|
|
|
READWRITE(nTime);
|
|
|
|
READWRITE(nBits);
|
|
|
|
READWRITE(nNonce);
|
|
|
|
)
|
|
|
|
|
|
|
|
uint256 GetBlockHash() const
|
|
|
|
{
|
2012-11-14 13:18:10 -08:00
|
|
|
CBlockHeader block;
|
2010-08-29 09:58:15 -07:00
|
|
|
block.nVersion = nVersion;
|
|
|
|
block.hashPrevBlock = hashPrev;
|
|
|
|
block.hashMerkleRoot = hashMerkleRoot;
|
|
|
|
block.nTime = nTime;
|
|
|
|
block.nBits = nBits;
|
|
|
|
block.nNonce = nNonce;
|
|
|
|
return block.GetHash();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-05-15 00:11:04 -07:00
|
|
|
std::string ToString() const
|
2010-08-29 09:58:15 -07:00
|
|
|
{
|
2011-05-15 00:11:04 -07:00
|
|
|
std::string str = "CDiskBlockIndex(";
|
2010-08-29 09:58:15 -07:00
|
|
|
str += CBlockIndex::ToString();
|
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
|
|
|
str += strprintf("\n hashBlock=%s, hashPrev=%s)",
|
2014-05-21 03:50:46 -07:00
|
|
|
GetBlockHash().ToString(),
|
|
|
|
hashPrev.ToString());
|
2010-08-29 09:58:15 -07:00
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
|
|
|
void print() const
|
|
|
|
{
|
2014-05-21 03:50:46 -07:00
|
|
|
LogPrintf("%s\n", ToString());
|
2010-08-29 09:58:15 -07:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2013-01-26 15:14:11 -08:00
|
|
|
/** Capture information about block/transaction validation */
|
|
|
|
class CValidationState {
|
|
|
|
private:
|
|
|
|
enum mode_state {
|
|
|
|
MODE_VALID, // everything ok
|
|
|
|
MODE_INVALID, // network rule violation (DoS value may be set)
|
|
|
|
MODE_ERROR, // run-time error
|
|
|
|
} mode;
|
|
|
|
int nDoS;
|
2013-10-27 23:36:11 -07:00
|
|
|
std::string strRejectReason;
|
|
|
|
unsigned char chRejectCode;
|
2013-10-25 00:52:53 -07:00
|
|
|
bool corruptionPossible;
|
2013-01-26 15:14:11 -08:00
|
|
|
public:
|
2013-11-25 16:48:14 -08:00
|
|
|
CValidationState() : mode(MODE_VALID), nDoS(0), corruptionPossible(false) {}
|
2013-10-27 23:36:11 -07:00
|
|
|
bool DoS(int level, bool ret = false,
|
|
|
|
unsigned char chRejectCodeIn=0, std::string strRejectReasonIn="",
|
|
|
|
bool corruptionIn=false) {
|
|
|
|
chRejectCode = chRejectCodeIn;
|
|
|
|
strRejectReason = strRejectReasonIn;
|
|
|
|
corruptionPossible = corruptionIn;
|
2013-01-26 15:14:11 -08:00
|
|
|
if (mode == MODE_ERROR)
|
|
|
|
return ret;
|
|
|
|
nDoS += level;
|
|
|
|
mode = MODE_INVALID;
|
|
|
|
return ret;
|
|
|
|
}
|
2013-10-27 23:36:11 -07:00
|
|
|
bool Invalid(bool ret = false,
|
|
|
|
unsigned char _chRejectCode=0, std::string _strRejectReason="") {
|
|
|
|
return DoS(0, ret, _chRejectCode, _strRejectReason);
|
2013-01-26 15:14:11 -08:00
|
|
|
}
|
2012-09-09 19:02:35 -07:00
|
|
|
bool Error(std::string strRejectReasonIn="") {
|
|
|
|
if (mode == MODE_VALID)
|
|
|
|
strRejectReason = strRejectReasonIn;
|
2013-01-26 15:14:11 -08:00
|
|
|
mode = MODE_ERROR;
|
2013-01-26 16:24:06 -08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
bool Abort(const std::string &msg) {
|
|
|
|
AbortNode(msg);
|
2012-09-09 19:02:35 -07:00
|
|
|
return Error(msg);
|
2013-01-26 15:14:11 -08:00
|
|
|
}
|
2013-11-16 10:28:24 -08:00
|
|
|
bool IsValid() const {
|
2013-01-26 15:14:11 -08:00
|
|
|
return mode == MODE_VALID;
|
|
|
|
}
|
2013-11-16 10:28:24 -08:00
|
|
|
bool IsInvalid() const {
|
2013-01-26 15:14:11 -08:00
|
|
|
return mode == MODE_INVALID;
|
|
|
|
}
|
2013-11-16 10:28:24 -08:00
|
|
|
bool IsError() const {
|
2013-01-26 15:14:11 -08:00
|
|
|
return mode == MODE_ERROR;
|
|
|
|
}
|
2013-11-16 10:28:24 -08:00
|
|
|
bool IsInvalid(int &nDoSOut) const {
|
2013-01-26 15:14:11 -08:00
|
|
|
if (IsInvalid()) {
|
|
|
|
nDoSOut = nDoS;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
2013-11-16 10:28:24 -08:00
|
|
|
bool CorruptionPossible() const {
|
2013-10-25 00:52:53 -07:00
|
|
|
return corruptionPossible;
|
|
|
|
}
|
2013-10-27 23:36:11 -07:00
|
|
|
unsigned char GetRejectCode() const { return chRejectCode; }
|
|
|
|
std::string GetRejectReason() const { return strRejectReason; }
|
2013-01-26 15:14:11 -08:00
|
|
|
};
|
2010-08-29 09:58:15 -07:00
|
|
|
|
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();
|
|
|
|
bool VerifyDB(int nCheckLevel, int nCheckDepth);
|
|
|
|
};
|
|
|
|
|
2013-10-10 14:07:44 -07:00
|
|
|
/** An in-memory indexed chain of blocks. */
|
|
|
|
class CChain {
|
|
|
|
private:
|
|
|
|
std::vector<CBlockIndex*> vChain;
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2013-10-10 14:07:44 -07:00
|
|
|
public:
|
|
|
|
/** Returns the index entry for the genesis block of this chain, or NULL if none. */
|
|
|
|
CBlockIndex *Genesis() const {
|
|
|
|
return vChain.size() > 0 ? vChain[0] : NULL;
|
|
|
|
}
|
2010-08-29 09:58:15 -07:00
|
|
|
|
2013-10-10 14:07:44 -07:00
|
|
|
/** Returns the index entry for the tip of this chain, or NULL if none. */
|
|
|
|
CBlockIndex *Tip() const {
|
|
|
|
return vChain.size() > 0 ? vChain[vChain.size() - 1] : NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Returns the index entry at a particular height in this chain, or NULL if no such height exists. */
|
|
|
|
CBlockIndex *operator[](int nHeight) const {
|
|
|
|
if (nHeight < 0 || nHeight >= (int)vChain.size())
|
|
|
|
return NULL;
|
|
|
|
return vChain[nHeight];
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Compare two chains efficiently. */
|
|
|
|
friend bool operator==(const CChain &a, const CChain &b) {
|
|
|
|
return a.vChain.size() == b.vChain.size() &&
|
|
|
|
a.vChain[a.vChain.size() - 1] == b.vChain[b.vChain.size() - 1];
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Efficiently check whether a block is present in this chain. */
|
|
|
|
bool Contains(const CBlockIndex *pindex) const {
|
|
|
|
return (*this)[pindex->nHeight] == pindex;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Find the successor of a block in this chain, or NULL if the given index is not found or is the tip. */
|
|
|
|
CBlockIndex *Next(const CBlockIndex *pindex) const {
|
|
|
|
if (Contains(pindex))
|
|
|
|
return (*this)[pindex->nHeight + 1];
|
|
|
|
else
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Return the maximal height in the chain. Is equal to chain.Tip() ? chain.Tip()->nHeight : -1. */
|
|
|
|
int Height() const {
|
|
|
|
return vChain.size() - 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Set/initialize a chain with a given tip. Returns the forking point. */
|
|
|
|
CBlockIndex *SetTip(CBlockIndex *pindex);
|
2013-10-12 06:18:08 -07:00
|
|
|
|
|
|
|
/** Return a CBlockLocator that refers to a block in this chain (by default the tip). */
|
|
|
|
CBlockLocator GetLocator(const CBlockIndex *pindex = NULL) const;
|
|
|
|
|
|
|
|
/** Find the last common block between this chain and a locator. */
|
|
|
|
CBlockIndex *FindFork(const CBlockLocator &locator) const;
|
2014-05-05 15:54:10 -07:00
|
|
|
|
|
|
|
/** Find the last common block between this chain and a block index entry. */
|
|
|
|
CBlockIndex *FindFork(CBlockIndex *pindex) const;
|
2013-10-10 14:07:44 -07:00
|
|
|
};
|
2010-08-29 09:58:15 -07:00
|
|
|
|
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;
|
|
|
|
|
2012-12-19 12:21:21 -08:00
|
|
|
struct CBlockTemplate
|
|
|
|
{
|
|
|
|
CBlock block;
|
|
|
|
std::vector<int64_t> vTxFees;
|
|
|
|
std::vector<int64_t> vTxSigOps;
|
|
|
|
};
|
|
|
|
|
2012-08-18 20:40:00 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** Used to relay blocks as header + vector<merkle branch>
|
|
|
|
* to filtered nodes.
|
|
|
|
*/
|
|
|
|
class CMerkleBlock
|
|
|
|
{
|
|
|
|
public:
|
2012-11-08 13:26:25 -08:00
|
|
|
// Public only for unit testing
|
2012-08-18 20:40:00 -07:00
|
|
|
CBlockHeader header;
|
2012-11-08 13:26:25 -08:00
|
|
|
CPartialMerkleTree txn;
|
2012-08-18 20:40:00 -07:00
|
|
|
|
2012-11-08 13:26:25 -08:00
|
|
|
public:
|
|
|
|
// Public only for unit testing and relay testing
|
|
|
|
// (not relayed)
|
|
|
|
std::vector<std::pair<unsigned int, uint256> > vMatchedTxn;
|
2012-08-18 20:40:00 -07:00
|
|
|
|
|
|
|
// Create from a CBlock, filtering transactions according to filter
|
|
|
|
// Note that this will call IsRelevantAndUpdate on the filter for each transaction,
|
|
|
|
// thus the filter will likely be modified.
|
|
|
|
CMerkleBlock(const CBlock& block, CBloomFilter& filter);
|
|
|
|
|
|
|
|
IMPLEMENT_SERIALIZE
|
|
|
|
(
|
|
|
|
READWRITE(header);
|
2012-11-08 13:26:25 -08:00
|
|
|
READWRITE(txn);
|
2012-08-18 20:40:00 -07:00
|
|
|
)
|
|
|
|
};
|
|
|
|
|
2013-10-19 09:34:06 -07:00
|
|
|
|
|
|
|
class CWalletInterface {
|
|
|
|
protected:
|
2014-06-09 01:02:00 -07:00
|
|
|
virtual void SyncTransaction(const CTransaction &tx, const CBlock *pblock) =0;
|
2013-10-19 09:34:06 -07:00
|
|
|
virtual void EraseFromWallet(const uint256 &hash) =0;
|
|
|
|
virtual void SetBestChain(const CBlockLocator &locator) =0;
|
|
|
|
virtual void UpdatedTransaction(const uint256 &hash) =0;
|
|
|
|
virtual void Inventory(const uint256 &hash) =0;
|
|
|
|
virtual void ResendWalletTransactions() =0;
|
|
|
|
friend void ::RegisterWallet(CWalletInterface*);
|
|
|
|
friend void ::UnregisterWallet(CWalletInterface*);
|
|
|
|
friend void ::UnregisterAllWallets();
|
|
|
|
};
|
|
|
|
|
2011-05-15 00:11:04 -07:00
|
|
|
#endif
|