2010-08-29 18:58:15 +02:00
|
|
|
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
2012-02-07 17:28:30 +01:00
|
|
|
// Copyright (c) 2009-2012 The Bitcoin developers
|
2010-08-29 18:58:15 +02:00
|
|
|
// Distributed under the MIT/X11 software license, see the accompanying
|
2012-05-18 16:02:28 +02:00
|
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
2011-05-15 09:11:04 +02:00
|
|
|
#ifndef BITCOIN_MAIN_H
|
|
|
|
#define BITCOIN_MAIN_H
|
|
|
|
|
|
|
|
#include "bignum.h"
|
2012-05-11 17:00:03 +02:00
|
|
|
#include "sync.h"
|
2011-05-15 09:11:04 +02:00
|
|
|
#include "net.h"
|
|
|
|
#include "script.h"
|
|
|
|
|
|
|
|
#include <list>
|
2010-08-29 18:58:15 +02:00
|
|
|
|
2012-04-15 23:39:49 +02:00
|
|
|
class CWallet;
|
2010-08-29 18:58:15 +02:00
|
|
|
class CBlock;
|
|
|
|
class CBlockIndex;
|
|
|
|
class CKeyItem;
|
CWallet class
* A new class CKeyStore manages private keys, and script.cpp depends on access to CKeyStore.
* A new class CWallet extends CKeyStore, and contains all former wallet-specific globals; CWallet depends on script.cpp, not the other way around.
* Wallet-specific functions in CTransaction/CTxIn/CTxOut (GetDebit, GetCredit, GetChange, IsMine, IsFromMe), are moved to CWallet, taking their former 'this' argument as an explicit parameter
* CWalletTx objects know which CWallet they belong to, for convenience, so they have their own direct (and caching) GetDebit/... functions.
* Some code was moved from CWalletDB to CWallet, such as handling of reserve keys.
* Main.cpp keeps a set of all 'registered' wallets, which should be informed about updates to the block chain, and does not have any notion about any 'main' wallet. Function in main.cpp that require a wallet (such as GenerateCoins), take an explicit CWallet* argument.
* The actual CWallet instance used by the application is defined in init.cpp as "CWallet* pwalletMain". rpc.cpp and ui.cpp use this variable.
* Functions in main.cpp and db.cpp that are not used by other modules are marked static.
* The code for handling the 'submitorder' message is removed, as it not really compatible with the idea that a node is independent from the wallet(s) connected to it, and obsolete anyway.
2011-06-01 18:28:20 +02:00
|
|
|
class CReserveKey;
|
2010-08-29 18:58:15 +02:00
|
|
|
|
2011-05-14 23:20:30 +02:00
|
|
|
class CAddress;
|
|
|
|
class CInv;
|
|
|
|
class CNode;
|
|
|
|
|
2012-11-11 03:53:32 +01:00
|
|
|
struct CBlockIndexWorkComparator;
|
2012-08-19 00:33:01 +02:00
|
|
|
|
2012-11-03 00:14:43 +01:00
|
|
|
/** The maximum allowed size for a serialized block, in bytes (network rule) */
|
2010-08-29 18:58:15 +02:00
|
|
|
static const unsigned int MAX_BLOCK_SIZE = 1000000;
|
2012-11-03 00:14:43 +01:00
|
|
|
/** The maximum size for mined blocks */
|
2010-09-14 00:14:24 +02:00
|
|
|
static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
|
2012-11-03 00:14:43 +01:00
|
|
|
/** The maximum allowed number of signature check operations in a block (network rule) */
|
2012-04-23 20:14:03 +02:00
|
|
|
static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
|
2012-11-03 00:14:43 +01:00
|
|
|
/** The maximum number of orphan transactions kept in memory */
|
2012-04-23 20:14:03 +02:00
|
|
|
static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
|
2012-11-03 00:14:43 +01:00
|
|
|
/** The maximum number of entries in an 'inv' protocol message */
|
2012-07-31 23:42:35 +02:00
|
|
|
static const unsigned int MAX_INV_SZ = 50000;
|
2012-11-03 00:14:43 +01:00
|
|
|
/** The maximum size of a blk?????.dat file (since 0.8) */
|
2012-08-13 19:11:05 +02:00
|
|
|
static const unsigned int MAX_BLOCKFILE_SIZE = 0x8000000; // 128 MiB
|
2012-11-03 00:14:43 +01:00
|
|
|
/** The pre-allocation chunk size for blk?????.dat files (since 0.8) */
|
2012-08-16 02:21:28 +02:00
|
|
|
static const unsigned int BLOCKFILE_CHUNK_SIZE = 0x1000000; // 16 MiB
|
2012-11-03 00:14:43 +01:00
|
|
|
/** The pre-allocation chunk size for rev?????.dat files (since 0.8) */
|
2012-08-16 02:21:28 +02:00
|
|
|
static const unsigned int UNDOFILE_CHUNK_SIZE = 0x100000; // 1 MiB
|
2012-11-03 00:14:43 +01:00
|
|
|
/** Fake height value used in CCoins to signify they are only in the memory pool (since 0.8) */
|
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 18:54:00 +02:00
|
|
|
static const unsigned int MEMPOOL_HEIGHT = 0x7FFFFFFF;
|
2012-11-03 00:14:43 +01:00
|
|
|
/** Fees smaller than this (in satoshi) are considered zero fee (for transaction creation) */
|
2011-12-21 22:33:19 +01:00
|
|
|
static const int64 MIN_TX_FEE = 50000;
|
2012-11-03 00:14:43 +01:00
|
|
|
/** Fees smaller than this (in satoshi) are considered zero fee (for relaying) */
|
2011-12-21 22:33:19 +01:00
|
|
|
static const int64 MIN_RELAY_TX_FEE = 10000;
|
2012-11-03 00:14:43 +01:00
|
|
|
/** No amount larger than this (in satoshi) is valid */
|
2011-12-21 22:33:19 +01:00
|
|
|
static const int64 MAX_MONEY = 21000000 * COIN;
|
|
|
|
inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
|
2012-11-03 00:14:43 +01:00
|
|
|
/** Coinbase transaction outputs can only be spent after this number of new blocks (network rule) */
|
2010-08-29 18:58:15 +02:00
|
|
|
static const int COINBASE_MATURITY = 100;
|
2012-11-03 00:14:43 +01:00
|
|
|
/** Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp. */
|
2012-05-09 03:48:14 +02:00
|
|
|
static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC
|
2011-03-26 13:01:27 +01:00
|
|
|
#ifdef USE_UPNP
|
|
|
|
static const int fHaveUPnP = true;
|
|
|
|
#else
|
|
|
|
static const int fHaveUPnP = false;
|
|
|
|
#endif
|
2010-08-29 18:58:15 +02:00
|
|
|
|
|
|
|
|
2012-02-06 21:48:00 +01:00
|
|
|
extern CScript COINBASE_FLAGS;
|
2012-01-15 00:51:52 +01:00
|
|
|
|
|
|
|
|
2010-08-29 18:58:15 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern CCriticalSection cs_main;
|
2011-05-15 09:11:04 +02:00
|
|
|
extern std::map<uint256, CBlockIndex*> mapBlockIndex;
|
2012-08-19 00:33:01 +02:00
|
|
|
extern std::set<CBlockIndex*, CBlockIndexWorkComparator> setBlockIndexValid;
|
2010-10-19 19:16:51 +02:00
|
|
|
extern uint256 hashGenesisBlock;
|
2010-08-29 18:58:15 +02:00
|
|
|
extern CBlockIndex* pindexGenesisBlock;
|
|
|
|
extern int nBestHeight;
|
|
|
|
extern CBigNum bnBestChainWork;
|
|
|
|
extern CBigNum bnBestInvalidWork;
|
|
|
|
extern uint256 hashBestChain;
|
|
|
|
extern CBlockIndex* pindexBest;
|
|
|
|
extern unsigned int nTransactionsUpdated;
|
2011-05-27 06:02:51 +02:00
|
|
|
extern uint64 nLastBlockTx;
|
|
|
|
extern uint64 nLastBlockSize;
|
2011-12-23 16:14:57 +01:00
|
|
|
extern const std::string strMessageMagic;
|
2010-08-29 18:58:15 +02:00
|
|
|
extern double dHashesPerSec;
|
2011-12-21 22:33:19 +01:00
|
|
|
extern int64 nHPSTimerStart;
|
|
|
|
extern int64 nTimeBestReceived;
|
CWallet class
* A new class CKeyStore manages private keys, and script.cpp depends on access to CKeyStore.
* A new class CWallet extends CKeyStore, and contains all former wallet-specific globals; CWallet depends on script.cpp, not the other way around.
* Wallet-specific functions in CTransaction/CTxIn/CTxOut (GetDebit, GetCredit, GetChange, IsMine, IsFromMe), are moved to CWallet, taking their former 'this' argument as an explicit parameter
* CWalletTx objects know which CWallet they belong to, for convenience, so they have their own direct (and caching) GetDebit/... functions.
* Some code was moved from CWalletDB to CWallet, such as handling of reserve keys.
* Main.cpp keeps a set of all 'registered' wallets, which should be informed about updates to the block chain, and does not have any notion about any 'main' wallet. Function in main.cpp that require a wallet (such as GenerateCoins), take an explicit CWallet* argument.
* The actual CWallet instance used by the application is defined in init.cpp as "CWallet* pwalletMain". rpc.cpp and ui.cpp use this variable.
* Functions in main.cpp and db.cpp that are not used by other modules are marked static.
* The code for handling the 'submitorder' message is removed, as it not really compatible with the idea that a node is independent from the wallet(s) connected to it, and obsolete anyway.
2011-06-01 18:28:20 +02:00
|
|
|
extern CCriticalSection cs_setpwalletRegistered;
|
|
|
|
extern std::set<CWallet*> setpwalletRegistered;
|
2012-02-20 20:50:26 +01:00
|
|
|
extern unsigned char pchMessageStart[4];
|
2012-09-13 14:33:52 +02:00
|
|
|
extern bool fImporting;
|
2012-10-21 21:23:13 +02:00
|
|
|
extern bool fReindex;
|
2012-12-01 20:10:23 +01:00
|
|
|
extern bool fBenchmark;
|
2012-11-04 17:11:48 +01:00
|
|
|
extern unsigned int nCoinCacheSize;
|
2010-08-29 18:58:15 +02:00
|
|
|
|
|
|
|
// Settings
|
2011-12-21 22:33:19 +01:00
|
|
|
extern int64 nTransactionFee;
|
2010-08-29 18:58:15 +02:00
|
|
|
|
2012-05-14 07:49:17 +02:00
|
|
|
// Minimum disk space required - used in CheckDiskSpace()
|
|
|
|
static const uint64 nMinDiskSpace = 52428800;
|
2010-08-29 18:58:15 +02:00
|
|
|
|
|
|
|
|
2011-05-14 22:57:34 +02:00
|
|
|
class CReserveKey;
|
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 18:54:00 +02:00
|
|
|
class CCoinsDB;
|
2012-09-03 15:26:57 +02:00
|
|
|
class CBlockTreeDB;
|
2012-06-19 01:36:43 +02:00
|
|
|
class 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 18:54:00 +02:00
|
|
|
class CCoins;
|
|
|
|
class CTxUndo;
|
|
|
|
class CCoinsView;
|
2012-07-08 19:04:05 +02:00
|
|
|
class CCoinsViewCache;
|
2010-08-29 18:58:15 +02:00
|
|
|
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Register a wallet to receive updates from core */
|
CWallet class
* A new class CKeyStore manages private keys, and script.cpp depends on access to CKeyStore.
* A new class CWallet extends CKeyStore, and contains all former wallet-specific globals; CWallet depends on script.cpp, not the other way around.
* Wallet-specific functions in CTransaction/CTxIn/CTxOut (GetDebit, GetCredit, GetChange, IsMine, IsFromMe), are moved to CWallet, taking their former 'this' argument as an explicit parameter
* CWalletTx objects know which CWallet they belong to, for convenience, so they have their own direct (and caching) GetDebit/... functions.
* Some code was moved from CWalletDB to CWallet, such as handling of reserve keys.
* Main.cpp keeps a set of all 'registered' wallets, which should be informed about updates to the block chain, and does not have any notion about any 'main' wallet. Function in main.cpp that require a wallet (such as GenerateCoins), take an explicit CWallet* argument.
* The actual CWallet instance used by the application is defined in init.cpp as "CWallet* pwalletMain". rpc.cpp and ui.cpp use this variable.
* Functions in main.cpp and db.cpp that are not used by other modules are marked static.
* The code for handling the 'submitorder' message is removed, as it not really compatible with the idea that a node is independent from the wallet(s) connected to it, and obsolete anyway.
2011-06-01 18:28:20 +02:00
|
|
|
void RegisterWallet(CWallet* pwalletIn);
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Unregister a wallet from core */
|
CWallet class
* A new class CKeyStore manages private keys, and script.cpp depends on access to CKeyStore.
* A new class CWallet extends CKeyStore, and contains all former wallet-specific globals; CWallet depends on script.cpp, not the other way around.
* Wallet-specific functions in CTransaction/CTxIn/CTxOut (GetDebit, GetCredit, GetChange, IsMine, IsFromMe), are moved to CWallet, taking their former 'this' argument as an explicit parameter
* CWalletTx objects know which CWallet they belong to, for convenience, so they have their own direct (and caching) GetDebit/... functions.
* Some code was moved from CWalletDB to CWallet, such as handling of reserve keys.
* Main.cpp keeps a set of all 'registered' wallets, which should be informed about updates to the block chain, and does not have any notion about any 'main' wallet. Function in main.cpp that require a wallet (such as GenerateCoins), take an explicit CWallet* argument.
* The actual CWallet instance used by the application is defined in init.cpp as "CWallet* pwalletMain". rpc.cpp and ui.cpp use this variable.
* Functions in main.cpp and db.cpp that are not used by other modules are marked static.
* The code for handling the 'submitorder' message is removed, as it not really compatible with the idea that a node is independent from the wallet(s) connected to it, and obsolete anyway.
2011-06-01 18:28:20 +02:00
|
|
|
void UnregisterWallet(CWallet* pwalletIn);
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Push an updated transaction to all registered wallets */
|
2012-07-08 00:06:34 +02:00
|
|
|
void SyncWithWallets(const uint256 &hash, const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false);
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Process an incoming block */
|
2012-10-21 21:23:13 +02:00
|
|
|
bool ProcessBlock(CNode* pfrom, CBlock* pblock, CDiskBlockPos *dbp = NULL);
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Check whether enough disk space is available for an incoming block */
|
2011-12-21 22:33:19 +01:00
|
|
|
bool CheckDiskSpace(uint64 nAdditionalBytes=0);
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Open a block file (blk?????.dat) */
|
2012-08-13 19:11:05 +02:00
|
|
|
FILE* OpenBlockFile(const CDiskBlockPos &pos, bool fReadOnly = false);
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Open an undo file (rev?????.dat) */
|
2012-08-13 19:11:05 +02:00
|
|
|
FILE* OpenUndoFile(const CDiskBlockPos &pos, bool fReadOnly = false);
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Import blocks from an external file */
|
2012-10-21 21:23:13 +02:00
|
|
|
bool LoadExternalBlockFile(FILE* fileIn, CDiskBlockPos *dbp = NULL);
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Load the block tree and coins database from disk */
|
2012-10-21 21:23:13 +02:00
|
|
|
bool LoadBlockIndex();
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Print the loaded block tree */
|
2010-08-29 18:58:15 +02:00
|
|
|
void PrintBlockTree();
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Find a block by height in the currently-connected chain */
|
2012-07-19 22:06:20 +02:00
|
|
|
CBlockIndex* FindBlockByHeight(int nHeight);
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Process protocol messages received from a given node */
|
2010-08-29 18:58:15 +02:00
|
|
|
bool ProcessMessages(CNode* pfrom);
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Send queued protocol messages to be sent to a give node */
|
2010-08-29 18:58:15 +02:00
|
|
|
bool SendMessages(CNode* pto, bool fSendTrickle);
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Run the importer thread, which deals with reindexing, loading bootstrap.dat, and whatever is passed to -loadblock */
|
2012-09-13 14:33:52 +02:00
|
|
|
void ThreadImport(void *parg);
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Run the miner threads */
|
CWallet class
* A new class CKeyStore manages private keys, and script.cpp depends on access to CKeyStore.
* A new class CWallet extends CKeyStore, and contains all former wallet-specific globals; CWallet depends on script.cpp, not the other way around.
* Wallet-specific functions in CTransaction/CTxIn/CTxOut (GetDebit, GetCredit, GetChange, IsMine, IsFromMe), are moved to CWallet, taking their former 'this' argument as an explicit parameter
* CWalletTx objects know which CWallet they belong to, for convenience, so they have their own direct (and caching) GetDebit/... functions.
* Some code was moved from CWalletDB to CWallet, such as handling of reserve keys.
* Main.cpp keeps a set of all 'registered' wallets, which should be informed about updates to the block chain, and does not have any notion about any 'main' wallet. Function in main.cpp that require a wallet (such as GenerateCoins), take an explicit CWallet* argument.
* The actual CWallet instance used by the application is defined in init.cpp as "CWallet* pwalletMain". rpc.cpp and ui.cpp use this variable.
* Functions in main.cpp and db.cpp that are not used by other modules are marked static.
* The code for handling the 'submitorder' message is removed, as it not really compatible with the idea that a node is independent from the wallet(s) connected to it, and obsolete anyway.
2011-06-01 18:28:20 +02:00
|
|
|
void GenerateBitcoins(bool fGenerate, CWallet* pwallet);
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Generate a new block, without valid proof-of-work */
|
2010-11-23 20:16:36 +01:00
|
|
|
CBlock* CreateNewBlock(CReserveKey& reservekey);
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Modify the extranonce in a block */
|
2011-09-06 22:39:05 +02:00
|
|
|
void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Do mining precalculation */
|
2010-11-23 20:16:36 +01:00
|
|
|
void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1);
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Check mined block */
|
CWallet class
* A new class CKeyStore manages private keys, and script.cpp depends on access to CKeyStore.
* A new class CWallet extends CKeyStore, and contains all former wallet-specific globals; CWallet depends on script.cpp, not the other way around.
* Wallet-specific functions in CTransaction/CTxIn/CTxOut (GetDebit, GetCredit, GetChange, IsMine, IsFromMe), are moved to CWallet, taking their former 'this' argument as an explicit parameter
* CWalletTx objects know which CWallet they belong to, for convenience, so they have their own direct (and caching) GetDebit/... functions.
* Some code was moved from CWalletDB to CWallet, such as handling of reserve keys.
* Main.cpp keeps a set of all 'registered' wallets, which should be informed about updates to the block chain, and does not have any notion about any 'main' wallet. Function in main.cpp that require a wallet (such as GenerateCoins), take an explicit CWallet* argument.
* The actual CWallet instance used by the application is defined in init.cpp as "CWallet* pwalletMain". rpc.cpp and ui.cpp use this variable.
* Functions in main.cpp and db.cpp that are not used by other modules are marked static.
* The code for handling the 'submitorder' message is removed, as it not really compatible with the idea that a node is independent from the wallet(s) connected to it, and obsolete anyway.
2011-06-01 18:28:20 +02:00
|
|
|
bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey);
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Check whether a block hash satisfies the proof-of-work requirement specified by nBits */
|
2010-08-29 18:58:15 +02:00
|
|
|
bool CheckProofOfWork(uint256 hash, unsigned int nBits);
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Calculate the minimum amount of work a received block needs, without knowing its direct parent */
|
2011-12-21 22:33:19 +01:00
|
|
|
unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Get the number of active peers */
|
2011-09-11 10:49:30 +02:00
|
|
|
int GetNumBlocksOfPeers();
|
2012-12-17 11:09:53 +01:00
|
|
|
/** Check whether we are doing an initial block download (synchronizing from disk or network) */
|
2010-08-29 18:58:15 +02:00
|
|
|
bool IsInitialBlockDownload();
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Format a string that describes several potential problems detected by the core */
|
2011-05-15 09:11:04 +02:00
|
|
|
std::string GetWarnings(std::string strFor);
|
2012-11-04 13:18:04 +01: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 18:54:00 +02:00
|
|
|
bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock, bool fAllowSlow = false);
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Connect/disconnect blocks until pindexNew is the new tip of the active block chain */
|
2012-08-19 00:33:01 +02:00
|
|
|
bool SetBestChain(CBlockIndex* pindexNew);
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Find the best known block, and make it the tip of the block chain */
|
2012-08-19 00:33:01 +02:00
|
|
|
bool ConnectBestBlock();
|
2012-11-04 13:18:04 +01:00
|
|
|
/** Create a new block index entry for a given block hash */
|
2012-09-03 21:14:03 +02:00
|
|
|
CBlockIndex * InsertBlockIndex(uint256 hash);
|
2012-09-08 17:33:10 +02:00
|
|
|
/** Verify a signature */
|
|
|
|
bool VerifySignature(const CCoins& txFrom, const CTransaction& txTo, unsigned int nIn, unsigned int flags, int nHashType);
|
2012-08-19 00:33:01 +02:00
|
|
|
|
2010-08-29 18:58:15 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2012-08-13 09:02:44 +02:00
|
|
|
static inline std::string BlockHashStr(const uint256& hash)
|
|
|
|
{
|
2012-08-20 21:22:15 +02:00
|
|
|
return hash.ToString();
|
2012-08-13 09:02:44 +02:00
|
|
|
}
|
|
|
|
|
CWallet class
* A new class CKeyStore manages private keys, and script.cpp depends on access to CKeyStore.
* A new class CWallet extends CKeyStore, and contains all former wallet-specific globals; CWallet depends on script.cpp, not the other way around.
* Wallet-specific functions in CTransaction/CTxIn/CTxOut (GetDebit, GetCredit, GetChange, IsMine, IsFromMe), are moved to CWallet, taking their former 'this' argument as an explicit parameter
* CWalletTx objects know which CWallet they belong to, for convenience, so they have their own direct (and caching) GetDebit/... functions.
* Some code was moved from CWalletDB to CWallet, such as handling of reserve keys.
* Main.cpp keeps a set of all 'registered' wallets, which should be informed about updates to the block chain, and does not have any notion about any 'main' wallet. Function in main.cpp that require a wallet (such as GenerateCoins), take an explicit CWallet* argument.
* The actual CWallet instance used by the application is defined in init.cpp as "CWallet* pwalletMain". rpc.cpp and ui.cpp use this variable.
* Functions in main.cpp and db.cpp that are not used by other modules are marked static.
* The code for handling the 'submitorder' message is removed, as it not really compatible with the idea that a node is independent from the wallet(s) connected to it, and obsolete anyway.
2011-06-01 18:28:20 +02:00
|
|
|
bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
|
|
|
|
|
2012-06-19 01:36:43 +02:00
|
|
|
class CDiskBlockPos
|
|
|
|
{
|
|
|
|
public:
|
2012-08-13 19:11:05 +02:00
|
|
|
int nFile;
|
|
|
|
unsigned int nPos;
|
2012-06-19 01:36:43 +02:00
|
|
|
|
2012-08-13 19:11:05 +02:00
|
|
|
IMPLEMENT_SERIALIZE(
|
|
|
|
READWRITE(VARINT(nFile));
|
|
|
|
READWRITE(VARINT(nPos));
|
|
|
|
)
|
2012-06-19 01:36:43 +02:00
|
|
|
|
2012-12-03 10:14:54 +01:00
|
|
|
CDiskBlockPos() {
|
|
|
|
SetNull();
|
|
|
|
}
|
|
|
|
|
|
|
|
CDiskBlockPos(int nFileIn, unsigned int nPosIn) {
|
|
|
|
nFile = nFileIn;
|
|
|
|
nPos = nPosIn;
|
|
|
|
}
|
|
|
|
|
2012-06-19 01:36:43 +02:00
|
|
|
friend bool operator==(const CDiskBlockPos &a, const CDiskBlockPos &b) {
|
2012-08-13 19:11:05 +02:00
|
|
|
return (a.nFile == b.nFile && a.nPos == b.nPos);
|
2012-06-19 01:36:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
friend bool operator!=(const CDiskBlockPos &a, const CDiskBlockPos &b) {
|
|
|
|
return !(a == b);
|
|
|
|
}
|
|
|
|
|
2012-08-13 19:11:05 +02:00
|
|
|
void SetNull() { nFile = -1; nPos = 0; }
|
|
|
|
bool IsNull() const { return (nFile == -1); }
|
2012-06-19 01:36:43 +02:00
|
|
|
};
|
|
|
|
|
2010-08-29 18:58:15 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
2012-03-26 16:48:23 +02:00
|
|
|
/** An inpoint - a combination of a transaction and an index n into its vin */
|
2010-08-29 18:58:15 +02:00
|
|
|
class CInPoint
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
CTransaction* ptx;
|
|
|
|
unsigned int n;
|
|
|
|
|
|
|
|
CInPoint() { SetNull(); }
|
|
|
|
CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
|
2012-05-01 23:49:17 +02:00
|
|
|
void SetNull() { ptx = NULL; n = (unsigned int) -1; }
|
|
|
|
bool IsNull() const { return (ptx == NULL && n == (unsigned int) -1); }
|
2010-08-29 18:58:15 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
2012-03-26 16:48:23 +02:00
|
|
|
/** An outpoint - a combination of a transaction hash and an index n into its vout */
|
2010-08-29 18:58:15 +02:00
|
|
|
class COutPoint
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
uint256 hash;
|
|
|
|
unsigned int n;
|
|
|
|
|
|
|
|
COutPoint() { SetNull(); }
|
|
|
|
COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
|
|
|
|
IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
|
2012-05-01 23:49:17 +02:00
|
|
|
void SetNull() { hash = 0; n = (unsigned int) -1; }
|
|
|
|
bool IsNull() const { return (hash == 0 && n == (unsigned int) -1); }
|
2010-08-29 18:58:15 +02:00
|
|
|
|
|
|
|
friend bool operator<(const COutPoint& a, const COutPoint& b)
|
|
|
|
{
|
|
|
|
return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
|
|
|
|
}
|
|
|
|
|
|
|
|
friend bool operator==(const COutPoint& a, const COutPoint& b)
|
|
|
|
{
|
|
|
|
return (a.hash == b.hash && a.n == b.n);
|
|
|
|
}
|
|
|
|
|
|
|
|
friend bool operator!=(const COutPoint& a, const COutPoint& b)
|
|
|
|
{
|
|
|
|
return !(a == b);
|
|
|
|
}
|
|
|
|
|
2011-05-15 09:11:04 +02:00
|
|
|
std::string ToString() const
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
2012-09-05 23:36:19 +02:00
|
|
|
return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
|
2010-08-29 18:58:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void print() const
|
|
|
|
{
|
|
|
|
printf("%s\n", ToString().c_str());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2012-03-26 16:48:23 +02:00
|
|
|
/** An input of a transaction. It contains the location of the previous
|
|
|
|
* transaction's output that it claims and a signature that matches the
|
|
|
|
* output's public key.
|
|
|
|
*/
|
2010-08-29 18:58:15 +02:00
|
|
|
class CTxIn
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
COutPoint prevout;
|
|
|
|
CScript scriptSig;
|
|
|
|
unsigned int nSequence;
|
|
|
|
|
|
|
|
CTxIn()
|
|
|
|
{
|
2011-12-19 23:08:25 +01:00
|
|
|
nSequence = std::numeric_limits<unsigned int>::max();
|
2010-08-29 18:58:15 +02:00
|
|
|
}
|
|
|
|
|
2011-12-19 23:08:25 +01:00
|
|
|
explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
|
|
|
prevout = prevoutIn;
|
|
|
|
scriptSig = scriptSigIn;
|
|
|
|
nSequence = nSequenceIn;
|
|
|
|
}
|
|
|
|
|
2011-12-19 23:08:25 +01:00
|
|
|
CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
|
|
|
prevout = COutPoint(hashPrevTx, nOut);
|
|
|
|
scriptSig = scriptSigIn;
|
|
|
|
nSequence = nSequenceIn;
|
|
|
|
}
|
|
|
|
|
|
|
|
IMPLEMENT_SERIALIZE
|
|
|
|
(
|
|
|
|
READWRITE(prevout);
|
|
|
|
READWRITE(scriptSig);
|
|
|
|
READWRITE(nSequence);
|
|
|
|
)
|
|
|
|
|
|
|
|
bool IsFinal() const
|
|
|
|
{
|
2011-12-19 23:08:25 +01:00
|
|
|
return (nSequence == std::numeric_limits<unsigned int>::max());
|
2010-08-29 18:58:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
friend bool operator==(const CTxIn& a, const CTxIn& b)
|
|
|
|
{
|
|
|
|
return (a.prevout == b.prevout &&
|
|
|
|
a.scriptSig == b.scriptSig &&
|
|
|
|
a.nSequence == b.nSequence);
|
|
|
|
}
|
|
|
|
|
|
|
|
friend bool operator!=(const CTxIn& a, const CTxIn& b)
|
|
|
|
{
|
|
|
|
return !(a == b);
|
|
|
|
}
|
|
|
|
|
2011-05-15 09:11:04 +02:00
|
|
|
std::string ToString() const
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
2011-05-15 09:11:04 +02:00
|
|
|
std::string str;
|
2012-03-18 23:14:03 +01:00
|
|
|
str += "CTxIn(";
|
2010-08-29 18:58:15 +02:00
|
|
|
str += prevout.ToString();
|
|
|
|
if (prevout.IsNull())
|
2010-09-07 03:12:53 +02:00
|
|
|
str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
|
2010-08-29 18:58:15 +02:00
|
|
|
else
|
|
|
|
str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
|
2011-12-19 23:08:25 +01:00
|
|
|
if (nSequence != std::numeric_limits<unsigned int>::max())
|
2010-08-29 18:58:15 +02:00
|
|
|
str += strprintf(", nSequence=%u", nSequence);
|
|
|
|
str += ")";
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
|
|
|
void print() const
|
|
|
|
{
|
|
|
|
printf("%s\n", ToString().c_str());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2012-03-26 16:48:23 +02:00
|
|
|
/** An output of a transaction. It contains the public key that the next input
|
|
|
|
* must be able to sign with to claim it.
|
|
|
|
*/
|
2010-08-29 18:58:15 +02:00
|
|
|
class CTxOut
|
|
|
|
{
|
|
|
|
public:
|
2011-12-21 22:33:19 +01:00
|
|
|
int64 nValue;
|
2010-08-29 18:58:15 +02:00
|
|
|
CScript scriptPubKey;
|
|
|
|
|
|
|
|
CTxOut()
|
|
|
|
{
|
|
|
|
SetNull();
|
|
|
|
}
|
|
|
|
|
2011-12-21 22:33:19 +01:00
|
|
|
CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
|
|
|
nValue = nValueIn;
|
|
|
|
scriptPubKey = scriptPubKeyIn;
|
|
|
|
}
|
|
|
|
|
|
|
|
IMPLEMENT_SERIALIZE
|
|
|
|
(
|
|
|
|
READWRITE(nValue);
|
|
|
|
READWRITE(scriptPubKey);
|
|
|
|
)
|
|
|
|
|
|
|
|
void SetNull()
|
|
|
|
{
|
|
|
|
nValue = -1;
|
|
|
|
scriptPubKey.clear();
|
|
|
|
}
|
|
|
|
|
2012-06-15 15:27:09 +02:00
|
|
|
bool IsNull() const
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
|
|
|
return (nValue == -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
uint256 GetHash() const
|
|
|
|
{
|
|
|
|
return SerializeHash(*this);
|
|
|
|
}
|
|
|
|
|
|
|
|
friend bool operator==(const CTxOut& a, const CTxOut& b)
|
|
|
|
{
|
|
|
|
return (a.nValue == b.nValue &&
|
|
|
|
a.scriptPubKey == b.scriptPubKey);
|
|
|
|
}
|
|
|
|
|
|
|
|
friend bool operator!=(const CTxOut& a, const CTxOut& b)
|
|
|
|
{
|
|
|
|
return !(a == b);
|
|
|
|
}
|
|
|
|
|
2011-05-15 09:11:04 +02:00
|
|
|
std::string ToString() const
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
|
|
|
if (scriptPubKey.size() < 6)
|
|
|
|
return "CTxOut(error)";
|
2010-10-09 21:33:35 +02:00
|
|
|
return strprintf("CTxOut(nValue=%"PRI64d".%08"PRI64d", scriptPubKey=%s)", nValue / COIN, nValue % COIN, scriptPubKey.ToString().substr(0,30).c_str());
|
2010-08-29 18:58:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void print() const
|
|
|
|
{
|
|
|
|
printf("%s\n", ToString().c_str());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2011-10-03 18:55:47 +02:00
|
|
|
enum GetMinFee_mode
|
|
|
|
{
|
|
|
|
GMF_BLOCK,
|
|
|
|
GMF_RELAY,
|
|
|
|
GMF_SEND,
|
|
|
|
};
|
|
|
|
|
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 18:54:00 +02:00
|
|
|
enum CheckSig_mode
|
|
|
|
{
|
|
|
|
CS_NEVER, // never validate scripts
|
|
|
|
CS_AFTER_CHECKPOINT, // validate scripts after the last checkpoint
|
|
|
|
CS_ALWAYS // always validate scripts
|
|
|
|
};
|
2012-01-11 02:18:00 +01:00
|
|
|
|
2012-03-26 16:48:23 +02:00
|
|
|
/** The basic transaction that is broadcasted on the network and contained in
|
|
|
|
* blocks. A transaction can contain multiple inputs and outputs.
|
|
|
|
*/
|
2010-08-29 18:58:15 +02:00
|
|
|
class CTransaction
|
|
|
|
{
|
|
|
|
public:
|
2012-06-27 18:43:19 +02:00
|
|
|
static const int CURRENT_VERSION=1;
|
2010-08-29 18:58:15 +02:00
|
|
|
int nVersion;
|
2011-05-15 09:11:04 +02:00
|
|
|
std::vector<CTxIn> vin;
|
|
|
|
std::vector<CTxOut> vout;
|
2010-08-29 18:58:15 +02:00
|
|
|
unsigned int nLockTime;
|
|
|
|
|
2011-09-06 22:59:38 +02:00
|
|
|
// Denial-of-service detection:
|
|
|
|
mutable int nDoS;
|
|
|
|
bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
|
2010-08-29 18:58:15 +02:00
|
|
|
|
|
|
|
CTransaction()
|
|
|
|
{
|
|
|
|
SetNull();
|
|
|
|
}
|
|
|
|
|
|
|
|
IMPLEMENT_SERIALIZE
|
|
|
|
(
|
|
|
|
READWRITE(this->nVersion);
|
|
|
|
nVersion = this->nVersion;
|
|
|
|
READWRITE(vin);
|
|
|
|
READWRITE(vout);
|
|
|
|
READWRITE(nLockTime);
|
|
|
|
)
|
|
|
|
|
|
|
|
void SetNull()
|
|
|
|
{
|
2012-06-27 18:43:19 +02:00
|
|
|
nVersion = CTransaction::CURRENT_VERSION;
|
2010-08-29 18:58:15 +02:00
|
|
|
vin.clear();
|
|
|
|
vout.clear();
|
|
|
|
nLockTime = 0;
|
2011-09-06 22:59:38 +02:00
|
|
|
nDoS = 0; // Denial-of-service prevention
|
2010-08-29 18:58:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bool IsNull() const
|
|
|
|
{
|
|
|
|
return (vin.empty() && vout.empty());
|
|
|
|
}
|
|
|
|
|
|
|
|
uint256 GetHash() const
|
|
|
|
{
|
|
|
|
return SerializeHash(*this);
|
|
|
|
}
|
|
|
|
|
2011-12-21 22:33:19 +01:00
|
|
|
bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
|
|
|
// Time based nLockTime implemented in 0.1.6
|
|
|
|
if (nLockTime == 0)
|
|
|
|
return true;
|
|
|
|
if (nBlockHeight == 0)
|
|
|
|
nBlockHeight = nBestHeight;
|
|
|
|
if (nBlockTime == 0)
|
|
|
|
nBlockTime = GetAdjustedTime();
|
2012-04-22 19:51:16 +02:00
|
|
|
if ((int64)nLockTime < ((int64)nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
|
2010-08-29 18:58:15 +02:00
|
|
|
return true;
|
2011-05-15 09:11:04 +02:00
|
|
|
BOOST_FOREACH(const CTxIn& txin, vin)
|
2010-08-29 18:58:15 +02:00
|
|
|
if (!txin.IsFinal())
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IsNewerThan(const CTransaction& old) const
|
|
|
|
{
|
|
|
|
if (vin.size() != old.vin.size())
|
|
|
|
return false;
|
2012-04-15 22:52:09 +02:00
|
|
|
for (unsigned int i = 0; i < vin.size(); i++)
|
2010-08-29 18:58:15 +02:00
|
|
|
if (vin[i].prevout != old.vin[i].prevout)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
bool fNewer = false;
|
2011-12-19 23:08:25 +01:00
|
|
|
unsigned int nLowest = std::numeric_limits<unsigned int>::max();
|
2012-04-15 22:52:09 +02:00
|
|
|
for (unsigned int i = 0; i < vin.size(); i++)
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
|
|
|
if (vin[i].nSequence != old.vin[i].nSequence)
|
|
|
|
{
|
|
|
|
if (vin[i].nSequence <= nLowest)
|
|
|
|
{
|
|
|
|
fNewer = false;
|
|
|
|
nLowest = vin[i].nSequence;
|
|
|
|
}
|
|
|
|
if (old.vin[i].nSequence < nLowest)
|
|
|
|
{
|
|
|
|
fNewer = true;
|
|
|
|
nLowest = old.vin[i].nSequence;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return fNewer;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IsCoinBase() const
|
|
|
|
{
|
|
|
|
return (vin.size() == 1 && vin[0].prevout.IsNull());
|
|
|
|
}
|
|
|
|
|
2012-01-11 02:18:00 +01:00
|
|
|
/** Check for standard transaction types
|
|
|
|
@return True if all outputs (scriptPubKeys) use only standard transaction forms
|
|
|
|
*/
|
2011-10-03 19:05:43 +02:00
|
|
|
bool IsStandard() const;
|
2012-01-05 03:40:52 +01:00
|
|
|
|
2012-01-11 02:18:00 +01: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
|
|
|
|
@see CTransaction::FetchInputs
|
|
|
|
*/
|
2012-07-08 19:04:05 +02:00
|
|
|
bool AreInputsStandard(CCoinsViewCache& mapInputs) const;
|
2012-01-11 02:18:00 +01: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
|
|
|
|
*/
|
2012-04-23 20:14:03 +02:00
|
|
|
unsigned int GetLegacySigOpCount() const;
|
2010-12-07 14:43:31 +01:00
|
|
|
|
2012-01-20 23:07:40 +01:00
|
|
|
/** Count ECDSA signature operations in pay-to-script-hash inputs.
|
2012-01-11 02:18:00 +01: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
|
|
|
|
*/
|
2012-07-08 19:04:05 +02:00
|
|
|
unsigned int GetP2SHSigOpCount(CCoinsViewCache& mapInputs) const;
|
2012-01-11 02:18:00 +01:00
|
|
|
|
|
|
|
/** Amount of bitcoins spent by this transaction.
|
|
|
|
@return sum of all outputs (note: does not include fees)
|
|
|
|
*/
|
2011-12-21 22:33:19 +01:00
|
|
|
int64 GetValueOut() const
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
2011-12-21 22:33:19 +01:00
|
|
|
int64 nValueOut = 0;
|
2011-05-15 09:11:04 +02:00
|
|
|
BOOST_FOREACH(const CTxOut& txout, vout)
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
|
|
|
nValueOut += txout.nValue;
|
|
|
|
if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
|
2011-05-15 09:11:04 +02:00
|
|
|
throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
|
2010-08-29 18:58:15 +02:00
|
|
|
}
|
|
|
|
return nValueOut;
|
|
|
|
}
|
|
|
|
|
2012-01-11 02:18:00 +01:00
|
|
|
/** Amount of bitcoins coming in to this transaction
|
|
|
|
Note that lightweight clients may not know anything besides the hash of previous transactions,
|
|
|
|
so may not be able to calculate this.
|
|
|
|
|
|
|
|
@param[in] mapInputs Map of previous transactions that have outputs we're spending
|
|
|
|
@return Sum of value of all inputs (scriptSigs)
|
|
|
|
@see CTransaction::FetchInputs
|
|
|
|
*/
|
2012-07-08 19:04:05 +02:00
|
|
|
int64 GetValueIn(CCoinsViewCache& mapInputs) const;
|
2012-01-11 02:18:00 +01:00
|
|
|
|
2011-03-02 22:27:24 +01:00
|
|
|
static bool AllowFree(double dPriority)
|
|
|
|
{
|
|
|
|
// Large (in bytes) low-priority (new, small-coin) transactions
|
|
|
|
// need a fee.
|
|
|
|
return dPriority > COIN * 144 / 250;
|
|
|
|
}
|
|
|
|
|
2012-09-09 22:39:45 +02:00
|
|
|
int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=true, enum GetMinFee_mode mode=GMF_BLOCK) const;
|
2010-08-29 18:58:15 +02:00
|
|
|
|
|
|
|
friend bool operator==(const CTransaction& a, const CTransaction& b)
|
|
|
|
{
|
|
|
|
return (a.nVersion == b.nVersion &&
|
|
|
|
a.vin == b.vin &&
|
|
|
|
a.vout == b.vout &&
|
|
|
|
a.nLockTime == b.nLockTime);
|
|
|
|
}
|
|
|
|
|
|
|
|
friend bool operator!=(const CTransaction& a, const CTransaction& b)
|
|
|
|
{
|
|
|
|
return !(a == b);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-05-15 09:11:04 +02:00
|
|
|
std::string ToString() const
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
2011-05-15 09:11:04 +02:00
|
|
|
std::string str;
|
2012-09-29 11:57:44 +02:00
|
|
|
str += strprintf("CTransaction(hash=%s, ver=%d, vin.size=%"PRIszu", vout.size=%"PRIszu", nLockTime=%u)\n",
|
2010-10-06 04:19:47 +02:00
|
|
|
GetHash().ToString().substr(0,10).c_str(),
|
2010-08-29 18:58:15 +02:00
|
|
|
nVersion,
|
|
|
|
vin.size(),
|
|
|
|
vout.size(),
|
|
|
|
nLockTime);
|
2012-04-15 22:52:09 +02:00
|
|
|
for (unsigned int i = 0; i < vin.size(); i++)
|
2010-08-29 18:58:15 +02:00
|
|
|
str += " " + vin[i].ToString() + "\n";
|
2012-04-15 22:52:09 +02:00
|
|
|
for (unsigned int i = 0; i < vout.size(); i++)
|
2010-08-29 18:58:15 +02:00
|
|
|
str += " " + vout[i].ToString() + "\n";
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
|
|
|
void print() const
|
|
|
|
{
|
|
|
|
printf("%s", ToString().c_str());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
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 18:54:00 +02:00
|
|
|
// Do all possible client-mode checks
|
|
|
|
bool ClientCheckInputs() const;
|
2011-11-08 19:20:29 +01:00
|
|
|
|
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 18:54:00 +02:00
|
|
|
// Check whether all prevouts of this transaction are present in the UTXO set represented by view
|
2012-07-08 19:04:05 +02:00
|
|
|
bool HaveInputs(CCoinsViewCache &view) const;
|
2012-01-11 02:18:00 +01:00
|
|
|
|
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 18:54:00 +02:00
|
|
|
// Check whether all inputs of this transaction are valid (no double spends, scripts & sigs, amounts)
|
|
|
|
// This does not modify the UTXO set
|
2012-11-13 23:03:25 +01:00
|
|
|
bool CheckInputs(CCoinsViewCache &view, enum CheckSig_mode csmode, unsigned int flags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC) const;
|
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 18:54:00 +02:00
|
|
|
|
|
|
|
// Apply the effects of this transaction on the UTXO set represented by view
|
2012-07-08 19:04:05 +02:00
|
|
|
bool UpdateCoins(CCoinsViewCache &view, CTxUndo &txundo, int nHeight, const uint256 &txhash) const;
|
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 18:54:00 +02:00
|
|
|
|
|
|
|
// Context-independent validity checks
|
2010-09-30 18:23:07 +02:00
|
|
|
bool CheckTransaction() const;
|
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 18:54:00 +02:00
|
|
|
|
|
|
|
// Try to accept this transaction into the memory pool
|
2012-07-06 16:33:34 +02:00
|
|
|
bool AcceptToMemoryPool(bool fCheckInputs=true, bool* pfMissingInputs=NULL);
|
2012-01-11 02:18:00 +01:00
|
|
|
|
2010-08-29 18:58:15 +02:00
|
|
|
protected:
|
2012-07-08 19:04:05 +02:00
|
|
|
static const CTxOut &GetOutputFor(const CTxIn& input, CCoinsViewCache& mapInputs);
|
2010-08-29 18:58:15 +02:00
|
|
|
};
|
|
|
|
|
2012-06-15 18:52:19 +02:00
|
|
|
/** wrapper for CTxOut that provides a more compact serialization */
|
|
|
|
class CTxOutCompressor
|
|
|
|
{
|
|
|
|
private:
|
|
|
|
CTxOut &txout;
|
2012-06-16 13:36:00 +02:00
|
|
|
|
2012-06-15 18:52:19 +02:00
|
|
|
public:
|
2012-06-16 13:36:00 +02:00
|
|
|
static uint64 CompressAmount(uint64 nAmount);
|
|
|
|
static uint64 DecompressAmount(uint64 nAmount);
|
|
|
|
|
2012-06-15 18:52:19 +02:00
|
|
|
CTxOutCompressor(CTxOut &txoutIn) : txout(txoutIn) { }
|
|
|
|
|
2012-06-16 13:36:00 +02:00
|
|
|
IMPLEMENT_SERIALIZE(({
|
|
|
|
if (!fRead) {
|
|
|
|
uint64 nVal = CompressAmount(txout.nValue);
|
|
|
|
READWRITE(VARINT(nVal));
|
|
|
|
} else {
|
|
|
|
uint64 nVal = 0;
|
|
|
|
READWRITE(VARINT(nVal));
|
|
|
|
txout.nValue = DecompressAmount(nVal);
|
|
|
|
}
|
2012-06-15 18:52:19 +02:00
|
|
|
CScriptCompressor cscript(REF(txout.scriptPubKey));
|
|
|
|
READWRITE(cscript);
|
2012-06-16 13:36:00 +02:00
|
|
|
});)
|
2012-06-15 18:52:19 +02:00
|
|
|
};
|
2010-08-29 18:58:15 +02:00
|
|
|
|
2012-06-18 16:55:29 +02:00
|
|
|
/** Undo information for a CTxIn
|
|
|
|
*
|
|
|
|
* Contains the prevout's CTxOut being spent, and if this was the
|
|
|
|
* last output of the affected transaction, its metadata as well
|
|
|
|
* (coinbase or not, height, transaction version)
|
|
|
|
*/
|
|
|
|
class CTxInUndo
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
CTxOut txout; // the txout data before being spent
|
|
|
|
bool fCoinBase; // if the outpoint was the last unspent: whether it belonged to a coinbase
|
|
|
|
unsigned int nHeight; // if the outpoint was the last unspent: its height
|
|
|
|
int nVersion; // if the outpoint was the last unspent: its version
|
|
|
|
|
|
|
|
CTxInUndo() : txout(), fCoinBase(false), nHeight(0), nVersion(0) {}
|
|
|
|
CTxInUndo(const CTxOut &txoutIn, bool fCoinBaseIn = false, unsigned int nHeightIn = 0, int nVersionIn = 0) : txout(txoutIn), fCoinBase(fCoinBaseIn), nHeight(nHeightIn), nVersion(nVersionIn) { }
|
|
|
|
|
|
|
|
unsigned int GetSerializeSize(int nType, int nVersion) const {
|
|
|
|
return ::GetSerializeSize(VARINT(nHeight*2+(fCoinBase ? 1 : 0)), nType, nVersion) +
|
|
|
|
(nHeight > 0 ? ::GetSerializeSize(VARINT(this->nVersion), nType, nVersion) : 0) +
|
|
|
|
::GetSerializeSize(CTxOutCompressor(REF(txout)), nType, nVersion);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename Stream>
|
|
|
|
void Serialize(Stream &s, int nType, int nVersion) const {
|
|
|
|
::Serialize(s, VARINT(nHeight*2+(fCoinBase ? 1 : 0)), nType, nVersion);
|
|
|
|
if (nHeight > 0)
|
|
|
|
::Serialize(s, VARINT(this->nVersion), nType, nVersion);
|
|
|
|
::Serialize(s, CTxOutCompressor(REF(txout)), nType, nVersion);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename Stream>
|
|
|
|
void Unserialize(Stream &s, int nType, int nVersion) {
|
|
|
|
unsigned int nCode = 0;
|
|
|
|
::Unserialize(s, VARINT(nCode), nType, nVersion);
|
|
|
|
nHeight = nCode / 2;
|
|
|
|
fCoinBase = nCode & 1;
|
|
|
|
if (nHeight > 0)
|
|
|
|
::Unserialize(s, VARINT(this->nVersion), nType, nVersion);
|
|
|
|
::Unserialize(s, REF(CTxOutCompressor(REF(txout))), nType, nVersion);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
/** Undo information for a CTransaction */
|
|
|
|
class CTxUndo
|
|
|
|
{
|
|
|
|
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 18:54:00 +02:00
|
|
|
// undo information for all txins
|
2012-06-18 16:55:29 +02:00
|
|
|
std::vector<CTxInUndo> vprevout;
|
|
|
|
|
|
|
|
IMPLEMENT_SERIALIZE(
|
|
|
|
READWRITE(vprevout);
|
|
|
|
)
|
|
|
|
};
|
|
|
|
|
2012-06-23 14:17:13 +02: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 18:54:00 +02:00
|
|
|
std::vector<CTxUndo> vtxundo; // for all but the coinbase
|
2012-06-23 14:17:13 +02:00
|
|
|
|
|
|
|
IMPLEMENT_SERIALIZE(
|
|
|
|
READWRITE(vtxundo);
|
|
|
|
)
|
2012-08-13 19:11:05 +02:00
|
|
|
|
|
|
|
bool WriteToDisk(CDiskBlockPos &pos)
|
|
|
|
{
|
|
|
|
// Open history file to append
|
|
|
|
CAutoFile fileout = CAutoFile(OpenUndoFile(pos), SER_DISK, CLIENT_VERSION);
|
|
|
|
if (!fileout)
|
|
|
|
return error("CBlockUndo::WriteToDisk() : OpenUndoFile failed");
|
|
|
|
|
|
|
|
// Write index header
|
|
|
|
unsigned int nSize = fileout.GetSerializeSize(*this);
|
|
|
|
fileout << FLATDATA(pchMessageStart) << nSize;
|
|
|
|
|
|
|
|
// Write undo data
|
|
|
|
long fileOutPos = ftell(fileout);
|
|
|
|
if (fileOutPos < 0)
|
2012-11-11 13:11:42 +01:00
|
|
|
return error("CBlockUndo::WriteToDisk() : ftell failed");
|
2012-08-13 19:11:05 +02:00
|
|
|
pos.nPos = (unsigned int)fileOutPos;
|
|
|
|
fileout << *this;
|
|
|
|
|
|
|
|
// 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 18:54:00 +02:00
|
|
|
if (!IsInitialBlockDownload())
|
2012-08-13 19:11:05 +02:00
|
|
|
FileCommit(fileout);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2012-06-23 14:17:13 +02:00
|
|
|
};
|
|
|
|
|
2012-06-15 15:27:09 +02:00
|
|
|
/** pruned version of CTransaction: only retains metadata and unspent transaction outputs
|
|
|
|
*
|
|
|
|
* Serialized format:
|
|
|
|
* - VARINT(nVersion)
|
|
|
|
* - VARINT(nCode)
|
|
|
|
* - unspentness bitvector, for vout[2] and further; least significant byte first
|
|
|
|
* - the non-spent CTxOuts (via CTxOutCompressor)
|
|
|
|
* - VARINT(nHeight)
|
|
|
|
*
|
|
|
|
* The nCode value consists of:
|
|
|
|
* - bit 1: IsCoinBase()
|
|
|
|
* - bit 2: vout[0] is not spent
|
|
|
|
* - bit 4: vout[1] is not spent
|
|
|
|
* - The higher bits encode N, the number of non-zero bytes in the following bitvector.
|
|
|
|
* - In case both bit 2 and bit 4 are unset, they encode N-1, as there must be at
|
|
|
|
* least one non-spent output).
|
|
|
|
*
|
|
|
|
* Example: 0104835800816115944e077fe7c803cfa57f29b36bf87c1d358bb85e
|
|
|
|
* <><><--------------------------------------------><---->
|
|
|
|
* | \ | /
|
|
|
|
* version code vout[1] height
|
|
|
|
*
|
|
|
|
* - version = 1
|
|
|
|
* - code = 4 (vout[1] is not spent, and 0 non-zero bytes of bitvector follow)
|
|
|
|
* - unspentness bitvector: as 0 non-zero bytes follow, it has length 0
|
|
|
|
* - vout[1]: 835800816115944e077fe7c803cfa57f29b36bf87c1d35
|
|
|
|
* * 8358: compact amount representation for 60000000000 (600 BTC)
|
|
|
|
* * 00: special txout type pay-to-pubkey-hash
|
|
|
|
* * 816115944e077fe7c803cfa57f29b36bf87c1d35: address uint160
|
|
|
|
* - height = 203998
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Example: 0109044086ef97d5790061b01caab50f1b8e9c50a5057eb43c2d9563a4eebbd123008c988f1a4a4de2161e0f50aac7f17e7f9555caa486af3b
|
|
|
|
* <><><--><--------------------------------------------------><----------------------------------------------><---->
|
|
|
|
* / \ \ | | /
|
|
|
|
* version code unspentness vout[4] vout[16] height
|
|
|
|
*
|
|
|
|
* - version = 1
|
|
|
|
* - code = 9 (coinbase, neither vout[0] or vout[1] are unspent,
|
|
|
|
* 2 (1, +1 because both bit 2 and bit 4 are unset) non-zero bitvector bytes follow)
|
|
|
|
* - unspentness bitvector: bits 2 (0x04) and 14 (0x4000) are set, so vout[2+2] and vout[14+2] are unspent
|
|
|
|
* - vout[4]: 86ef97d5790061b01caab50f1b8e9c50a5057eb43c2d9563a4ee
|
|
|
|
* * 86ef97d579: compact amount representation for 234925952 (2.35 BTC)
|
|
|
|
* * 00: special txout type pay-to-pubkey-hash
|
|
|
|
* * 61b01caab50f1b8e9c50a5057eb43c2d9563a4ee: address uint160
|
|
|
|
* - vout[16]: bbd123008c988f1a4a4de2161e0f50aac7f17e7f9555caa4
|
|
|
|
* * bbd123: compact amount representation for 110397 (0.001 BTC)
|
|
|
|
* * 00: special txout type pay-to-pubkey-hash
|
|
|
|
* * 8c988f1a4a4de2161e0f50aac7f17e7f9555caa4: address uint160
|
|
|
|
* - height = 120891
|
|
|
|
*/
|
|
|
|
class CCoins
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
// whether transaction is a coinbase
|
|
|
|
bool fCoinBase;
|
|
|
|
|
|
|
|
// unspent transaction outputs; spent outputs are .IsNull(); spent outputs at the end of the array are dropped
|
|
|
|
std::vector<CTxOut> vout;
|
|
|
|
|
2012-10-05 19:22:21 +02:00
|
|
|
// at which height this transaction was included in the active block chain
|
2012-06-15 15:27:09 +02:00
|
|
|
int nHeight;
|
|
|
|
|
|
|
|
// version of the CTransaction; accesses to this value should probably check for nHeight as well,
|
|
|
|
// as new tx version will probably only be introduced at certain heights
|
|
|
|
int nVersion;
|
|
|
|
|
|
|
|
// construct a CCoins from a CTransaction, at a given height
|
|
|
|
CCoins(const CTransaction &tx, int nHeightIn) : fCoinBase(tx.IsCoinBase()), vout(tx.vout), nHeight(nHeightIn), nVersion(tx.nVersion) { }
|
|
|
|
|
|
|
|
// empty constructor
|
|
|
|
CCoins() : fCoinBase(false), vout(0), nHeight(0), nVersion(0) { }
|
|
|
|
|
|
|
|
// remove spent outputs at the end of vout
|
|
|
|
void Cleanup() {
|
|
|
|
while (vout.size() > 0 && vout.back().IsNull())
|
|
|
|
vout.pop_back();
|
|
|
|
}
|
|
|
|
|
|
|
|
// equality test
|
|
|
|
friend bool operator==(const CCoins &a, const CCoins &b) {
|
2012-10-05 19:22:21 +02:00
|
|
|
return a.fCoinBase == b.fCoinBase &&
|
2012-06-15 15:27:09 +02:00
|
|
|
a.nHeight == b.nHeight &&
|
|
|
|
a.nVersion == b.nVersion &&
|
|
|
|
a.vout == b.vout;
|
|
|
|
}
|
|
|
|
friend bool operator!=(const CCoins &a, const CCoins &b) {
|
|
|
|
return !(a == b);
|
|
|
|
}
|
|
|
|
|
|
|
|
// calculate number of bytes for the bitmask, and its number of non-zero bytes
|
|
|
|
// each bit in the bitmask represents the availability of one output, but the
|
|
|
|
// availabilities of the first two outputs are encoded separately
|
|
|
|
void CalcMaskSize(unsigned int &nBytes, unsigned int &nNonzeroBytes) const {
|
|
|
|
unsigned int nLastUsedByte = 0;
|
|
|
|
for (unsigned int b = 0; 2+b*8 < vout.size(); b++) {
|
|
|
|
bool fZero = true;
|
|
|
|
for (unsigned int i = 0; i < 8 && 2+b*8+i < vout.size(); i++) {
|
|
|
|
if (!vout[2+b*8+i].IsNull()) {
|
|
|
|
fZero = false;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!fZero) {
|
|
|
|
nLastUsedByte = b + 1;
|
|
|
|
nNonzeroBytes++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
nBytes += nLastUsedByte;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IsCoinBase() const {
|
|
|
|
return fCoinBase;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned int GetSerializeSize(int nType, int nVersion) const {
|
|
|
|
unsigned int nSize = 0;
|
|
|
|
unsigned int nMaskSize = 0, nMaskCode = 0;
|
|
|
|
CalcMaskSize(nMaskSize, nMaskCode);
|
|
|
|
bool fFirst = vout.size() > 0 && !vout[0].IsNull();
|
|
|
|
bool fSecond = vout.size() > 1 && !vout[1].IsNull();
|
|
|
|
assert(fFirst || fSecond || nMaskCode);
|
|
|
|
unsigned int nCode = 8*(nMaskCode - (fFirst || fSecond ? 0 : 1)) + (fCoinBase ? 1 : 0) + (fFirst ? 2 : 0) + (fSecond ? 4 : 0);
|
|
|
|
// version
|
|
|
|
nSize += ::GetSerializeSize(VARINT(this->nVersion), nType, nVersion);
|
|
|
|
// size of header code
|
|
|
|
nSize += ::GetSerializeSize(VARINT(nCode), nType, nVersion);
|
|
|
|
// spentness bitmask
|
|
|
|
nSize += nMaskSize;
|
|
|
|
// txouts themself
|
|
|
|
for (unsigned int i = 0; i < vout.size(); i++)
|
|
|
|
if (!vout[i].IsNull())
|
|
|
|
nSize += ::GetSerializeSize(CTxOutCompressor(REF(vout[i])), nType, nVersion);
|
|
|
|
// height
|
|
|
|
nSize += ::GetSerializeSize(VARINT(nHeight), nType, nVersion);
|
|
|
|
return nSize;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename Stream>
|
|
|
|
void Serialize(Stream &s, int nType, int nVersion) const {
|
|
|
|
unsigned int nMaskSize = 0, nMaskCode = 0;
|
|
|
|
CalcMaskSize(nMaskSize, nMaskCode);
|
|
|
|
bool fFirst = vout.size() > 0 && !vout[0].IsNull();
|
|
|
|
bool fSecond = vout.size() > 1 && !vout[1].IsNull();
|
|
|
|
assert(fFirst || fSecond || nMaskCode);
|
|
|
|
unsigned int nCode = 8*(nMaskCode - (fFirst || fSecond ? 0 : 1)) + (fCoinBase ? 1 : 0) + (fFirst ? 2 : 0) + (fSecond ? 4 : 0);
|
|
|
|
// version
|
|
|
|
::Serialize(s, VARINT(this->nVersion), nType, nVersion);
|
|
|
|
// header code
|
|
|
|
::Serialize(s, VARINT(nCode), nType, nVersion);
|
|
|
|
// spentness bitmask
|
|
|
|
for (unsigned int b = 0; b<nMaskSize; b++) {
|
|
|
|
unsigned char chAvail = 0;
|
|
|
|
for (unsigned int i = 0; i < 8 && 2+b*8+i < vout.size(); i++)
|
|
|
|
if (!vout[2+b*8+i].IsNull())
|
|
|
|
chAvail |= (1 << i);
|
|
|
|
::Serialize(s, chAvail, nType, nVersion);
|
|
|
|
}
|
|
|
|
// txouts themself
|
|
|
|
for (unsigned int i = 0; i < vout.size(); i++) {
|
|
|
|
if (!vout[i].IsNull())
|
|
|
|
::Serialize(s, CTxOutCompressor(REF(vout[i])), nType, nVersion);
|
|
|
|
}
|
|
|
|
// coinbase height
|
|
|
|
::Serialize(s, VARINT(nHeight), nType, nVersion);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename Stream>
|
|
|
|
void Unserialize(Stream &s, int nType, int nVersion) {
|
|
|
|
unsigned int nCode = 0;
|
|
|
|
// version
|
|
|
|
::Unserialize(s, VARINT(this->nVersion), nType, nVersion);
|
|
|
|
// header code
|
|
|
|
::Unserialize(s, VARINT(nCode), nType, nVersion);
|
|
|
|
fCoinBase = nCode & 1;
|
|
|
|
std::vector<bool> vAvail(2, false);
|
|
|
|
vAvail[0] = nCode & 2;
|
|
|
|
vAvail[1] = nCode & 4;
|
|
|
|
unsigned int nMaskCode = (nCode / 8) + ((nCode & 6) != 0 ? 0 : 1);
|
|
|
|
// spentness bitmask
|
|
|
|
while (nMaskCode > 0) {
|
|
|
|
unsigned char chAvail = 0;
|
|
|
|
::Unserialize(s, chAvail, nType, nVersion);
|
|
|
|
for (unsigned int p = 0; p < 8; p++) {
|
|
|
|
bool f = (chAvail & (1 << p)) != 0;
|
|
|
|
vAvail.push_back(f);
|
|
|
|
}
|
|
|
|
if (chAvail != 0)
|
|
|
|
nMaskCode--;
|
|
|
|
}
|
|
|
|
// txouts themself
|
|
|
|
vout.assign(vAvail.size(), CTxOut());
|
|
|
|
for (unsigned int i = 0; i < vAvail.size(); i++) {
|
|
|
|
if (vAvail[i])
|
|
|
|
::Unserialize(s, REF(CTxOutCompressor(vout[i])), nType, nVersion);
|
|
|
|
}
|
|
|
|
// coinbase height
|
|
|
|
::Unserialize(s, VARINT(nHeight), nType, nVersion);
|
|
|
|
Cleanup();
|
|
|
|
}
|
|
|
|
|
2012-06-18 16:55:29 +02:00
|
|
|
// mark an outpoint spent, and construct undo information
|
|
|
|
bool Spend(const COutPoint &out, CTxInUndo &undo) {
|
2012-06-15 15:27:09 +02:00
|
|
|
if (out.n >= vout.size())
|
|
|
|
return false;
|
|
|
|
if (vout[out.n].IsNull())
|
|
|
|
return false;
|
2012-06-18 16:55:29 +02:00
|
|
|
undo = CTxInUndo(vout[out.n]);
|
2012-06-15 15:27:09 +02:00
|
|
|
vout[out.n].SetNull();
|
|
|
|
Cleanup();
|
2012-06-18 16:55:29 +02:00
|
|
|
if (vout.size() == 0) {
|
|
|
|
undo.nHeight = nHeight;
|
|
|
|
undo.fCoinBase = fCoinBase;
|
|
|
|
undo.nVersion = this->nVersion;
|
|
|
|
}
|
2012-06-15 15:27:09 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// mark a vout spent
|
|
|
|
bool Spend(int nPos) {
|
2012-06-18 16:55:29 +02:00
|
|
|
CTxInUndo undo;
|
2012-06-15 15:27:09 +02:00
|
|
|
COutPoint out(0, nPos);
|
2012-06-18 16:55:29 +02:00
|
|
|
return Spend(out, undo);
|
2012-06-15 15:27:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// check whether a particular output is still available
|
|
|
|
bool IsAvailable(unsigned int nPos) const {
|
|
|
|
return (nPos < vout.size() && !vout[nPos].IsNull());
|
|
|
|
}
|
|
|
|
|
|
|
|
// check whether the entire CCoins is spent
|
|
|
|
// note that only !IsPruned() CCoins can be serialized
|
|
|
|
bool IsPruned() const {
|
|
|
|
BOOST_FOREACH(const CTxOut &out, vout)
|
|
|
|
if (!out.IsNull())
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
2010-08-29 18:58:15 +02:00
|
|
|
|
2012-12-01 22:30:06 +01: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 18:58:15 +02:00
|
|
|
|
2012-12-01 22:30:06 +01: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 18:58:15 +02:00
|
|
|
|
2012-03-26 16:48:23 +02:00
|
|
|
/** A transaction with a merkle branch linking it to the block chain. */
|
2010-08-29 18:58:15 +02:00
|
|
|
class CMerkleTx : public CTransaction
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
uint256 hashBlock;
|
2011-05-15 09:11:04 +02:00
|
|
|
std::vector<uint256> vMerkleBranch;
|
2010-08-29 18:58:15 +02:00
|
|
|
int nIndex;
|
|
|
|
|
|
|
|
// memory only
|
2012-04-21 13:31:08 +02:00
|
|
|
mutable bool fMerkleVerified;
|
2010-08-29 18:58:15 +02:00
|
|
|
|
|
|
|
|
|
|
|
CMerkleTx()
|
|
|
|
{
|
|
|
|
Init();
|
|
|
|
}
|
|
|
|
|
|
|
|
CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
|
|
|
|
{
|
|
|
|
Init();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Init()
|
|
|
|
{
|
|
|
|
hashBlock = 0;
|
|
|
|
nIndex = -1;
|
|
|
|
fMerkleVerified = false;
|
|
|
|
}
|
|
|
|
|
2011-03-17 22:51:59 +01:00
|
|
|
|
2010-08-29 18:58:15 +02: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);
|
2011-07-11 21:49:45 +02:00
|
|
|
int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
|
|
|
|
int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
|
2010-08-29 18:58:15 +02:00
|
|
|
bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
|
|
|
|
int GetBlocksToMaturity() const;
|
2012-07-06 16:33:34 +02:00
|
|
|
bool AcceptToMemoryPool(bool fCheckInputs=true);
|
2010-08-29 18:58:15 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2012-03-26 16:48:23 +02:00
|
|
|
/** Nodes collect new transactions into a block, hash them into a hash tree,
|
|
|
|
* and scan through nonce values to make the block's hash satisfy proof-of-work
|
|
|
|
* requirements. When they solve the proof-of-work, they broadcast the block
|
|
|
|
* to everyone and the block is added to the block chain. The first transaction
|
|
|
|
* in the block is a special one that creates a new coin owned by the creator
|
|
|
|
* of the block.
|
|
|
|
*/
|
2012-11-14 22:18:10 +01:00
|
|
|
class CBlockHeader
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
// header
|
2012-06-28 01:30:39 +02:00
|
|
|
static const int CURRENT_VERSION=2;
|
2010-08-29 18:58:15 +02:00
|
|
|
int nVersion;
|
|
|
|
uint256 hashPrevBlock;
|
|
|
|
uint256 hashMerkleRoot;
|
|
|
|
unsigned int nTime;
|
|
|
|
unsigned int nBits;
|
|
|
|
unsigned int nNonce;
|
|
|
|
|
2012-11-14 22:18:10 +01:00
|
|
|
CBlockHeader()
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
|
|
|
SetNull();
|
|
|
|
}
|
|
|
|
|
|
|
|
IMPLEMENT_SERIALIZE
|
|
|
|
(
|
|
|
|
READWRITE(this->nVersion);
|
|
|
|
nVersion = this->nVersion;
|
|
|
|
READWRITE(hashPrevBlock);
|
|
|
|
READWRITE(hashMerkleRoot);
|
|
|
|
READWRITE(nTime);
|
|
|
|
READWRITE(nBits);
|
|
|
|
READWRITE(nNonce);
|
|
|
|
)
|
|
|
|
|
|
|
|
void SetNull()
|
|
|
|
{
|
2012-11-14 22:18:10 +01:00
|
|
|
nVersion = CBlockHeader::CURRENT_VERSION;
|
2010-08-29 18:58:15 +02:00
|
|
|
hashPrevBlock = 0;
|
|
|
|
hashMerkleRoot = 0;
|
|
|
|
nTime = 0;
|
|
|
|
nBits = 0;
|
|
|
|
nNonce = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IsNull() const
|
|
|
|
{
|
|
|
|
return (nBits == 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
uint256 GetHash() const
|
|
|
|
{
|
|
|
|
return Hash(BEGIN(nVersion), END(nNonce));
|
|
|
|
}
|
|
|
|
|
2011-12-21 22:33:19 +01:00
|
|
|
int64 GetBlockTime() const
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
2011-12-21 22:33:19 +01:00
|
|
|
return (int64)nTime;
|
2010-08-29 18:58:15 +02:00
|
|
|
}
|
|
|
|
|
2012-02-16 16:22:31 +01:00
|
|
|
void UpdateTime(const CBlockIndex* pindexPrev);
|
2012-11-14 22:18:10 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
class CBlock : public CBlockHeader
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
// network and disk
|
|
|
|
std::vector<CTransaction> vtx;
|
|
|
|
|
|
|
|
// memory only
|
|
|
|
mutable std::vector<uint256> vMerkleTree;
|
2010-09-07 03:12:53 +02:00
|
|
|
|
2012-11-14 22:18:10 +01:00
|
|
|
// Denial-of-service detection:
|
|
|
|
mutable int nDoS;
|
|
|
|
bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
|
|
|
|
|
|
|
|
CBlock()
|
|
|
|
{
|
|
|
|
SetNull();
|
|
|
|
}
|
|
|
|
|
|
|
|
CBlock(const CBlockHeader &header)
|
|
|
|
{
|
|
|
|
SetNull();
|
|
|
|
*((CBlockHeader*)this) = header;
|
|
|
|
}
|
|
|
|
|
|
|
|
IMPLEMENT_SERIALIZE
|
|
|
|
(
|
|
|
|
READWRITE(*(CBlockHeader*)this);
|
|
|
|
READWRITE(vtx);
|
|
|
|
)
|
|
|
|
|
|
|
|
void SetNull()
|
|
|
|
{
|
|
|
|
CBlockHeader::SetNull();
|
|
|
|
vtx.clear();
|
|
|
|
vMerkleTree.clear();
|
|
|
|
nDoS = 0;
|
|
|
|
}
|
2010-08-29 18:58:15 +02:00
|
|
|
|
|
|
|
uint256 BuildMerkleTree() const
|
|
|
|
{
|
|
|
|
vMerkleTree.clear();
|
2011-05-15 09:11:04 +02:00
|
|
|
BOOST_FOREACH(const CTransaction& tx, vtx)
|
2010-08-29 18:58:15 +02:00
|
|
|
vMerkleTree.push_back(tx.GetHash());
|
|
|
|
int j = 0;
|
|
|
|
for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
|
|
|
|
{
|
|
|
|
for (int i = 0; i < nSize; i += 2)
|
|
|
|
{
|
2011-05-15 09:11:04 +02:00
|
|
|
int i2 = std::min(i+1, nSize-1);
|
2010-08-29 18:58:15 +02:00
|
|
|
vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
|
|
|
|
BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
|
|
|
|
}
|
|
|
|
j += nSize;
|
|
|
|
}
|
|
|
|
return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
|
|
|
|
}
|
|
|
|
|
2012-07-08 00:06:34 +02:00
|
|
|
const uint256 &GetTxHash(unsigned int nIndex) const {
|
|
|
|
assert(vMerkleTree.size() > 0); // BuildMerkleTree must have been called first
|
|
|
|
assert(nIndex < vtx.size());
|
|
|
|
return vMerkleTree[nIndex];
|
|
|
|
}
|
|
|
|
|
2011-05-15 09:11:04 +02:00
|
|
|
std::vector<uint256> GetMerkleBranch(int nIndex) const
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
|
|
|
if (vMerkleTree.empty())
|
|
|
|
BuildMerkleTree();
|
2011-05-15 09:11:04 +02:00
|
|
|
std::vector<uint256> vMerkleBranch;
|
2010-08-29 18:58:15 +02:00
|
|
|
int j = 0;
|
|
|
|
for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
|
|
|
|
{
|
2011-05-15 09:11:04 +02:00
|
|
|
int i = std::min(nIndex^1, nSize-1);
|
2010-08-29 18:58:15 +02:00
|
|
|
vMerkleBranch.push_back(vMerkleTree[j+i]);
|
|
|
|
nIndex >>= 1;
|
|
|
|
j += nSize;
|
|
|
|
}
|
|
|
|
return vMerkleBranch;
|
|
|
|
}
|
|
|
|
|
2011-05-15 09:11:04 +02:00
|
|
|
static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
|
|
|
if (nIndex == -1)
|
|
|
|
return 0;
|
2011-05-15 09:11:04 +02:00
|
|
|
BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
|
|
|
if (nIndex & 1)
|
|
|
|
hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
|
|
|
|
else
|
|
|
|
hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
|
|
|
|
nIndex >>= 1;
|
|
|
|
}
|
|
|
|
return hash;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-06-19 01:36:43 +02:00
|
|
|
bool WriteToDisk(CDiskBlockPos &pos)
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
|
|
|
// Open history file to append
|
2012-08-13 19:11:05 +02:00
|
|
|
CAutoFile fileout = CAutoFile(OpenBlockFile(pos), SER_DISK, CLIENT_VERSION);
|
2010-08-29 18:58:15 +02:00
|
|
|
if (!fileout)
|
2012-08-13 19:11:05 +02:00
|
|
|
return error("CBlock::WriteToDisk() : OpenBlockFile failed");
|
|
|
|
|
|
|
|
// Write index header
|
|
|
|
unsigned int nSize = fileout.GetSerializeSize(*this);
|
|
|
|
fileout << FLATDATA(pchMessageStart) << nSize;
|
2010-08-29 18:58:15 +02:00
|
|
|
|
|
|
|
// Write block
|
2012-08-13 19:11:05 +02:00
|
|
|
long fileOutPos = ftell(fileout);
|
|
|
|
if (fileOutPos < 0)
|
|
|
|
return error("CBlock::WriteToDisk() : ftell failed");
|
|
|
|
pos.nPos = (unsigned int)fileOutPos;
|
2010-08-29 18:58:15 +02:00
|
|
|
fileout << *this;
|
|
|
|
|
|
|
|
// 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 18:54:00 +02:00
|
|
|
if (!IsInitialBlockDownload())
|
2012-05-12 07:24:27 +02:00
|
|
|
FileCommit(fileout);
|
2010-08-29 18:58:15 +02:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-11-14 22:18:10 +01:00
|
|
|
bool ReadFromDisk(const CDiskBlockPos &pos)
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
|
|
|
SetNull();
|
|
|
|
|
|
|
|
// Open history file to read
|
2012-08-13 19:11:05 +02:00
|
|
|
CAutoFile filein = CAutoFile(OpenBlockFile(pos, true), SER_DISK, CLIENT_VERSION);
|
2010-08-29 18:58:15 +02:00
|
|
|
if (!filein)
|
|
|
|
return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
|
|
|
|
|
|
|
|
// Read block
|
2012-05-22 21:23:17 +02:00
|
|
|
try {
|
|
|
|
filein >> *this;
|
|
|
|
}
|
|
|
|
catch (std::exception &e) {
|
|
|
|
return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
|
|
|
|
}
|
2010-08-29 18:58:15 +02:00
|
|
|
|
|
|
|
// Check the header
|
|
|
|
if (!CheckProofOfWork(GetHash(), nBits))
|
|
|
|
return error("CBlock::ReadFromDisk() : errors in block header");
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void print() const
|
|
|
|
{
|
2012-09-29 11:57:44 +02:00
|
|
|
printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%"PRIszu")\n",
|
2012-08-13 09:02:44 +02:00
|
|
|
BlockHashStr(GetHash()).c_str(),
|
2010-08-29 18:58:15 +02:00
|
|
|
nVersion,
|
2012-08-13 09:02:44 +02:00
|
|
|
BlockHashStr(hashPrevBlock).c_str(),
|
2010-10-06 04:19:47 +02:00
|
|
|
hashMerkleRoot.ToString().substr(0,10).c_str(),
|
2010-08-29 18:58:15 +02:00
|
|
|
nTime, nBits, nNonce,
|
|
|
|
vtx.size());
|
2012-04-15 22:52:09 +02:00
|
|
|
for (unsigned int i = 0; i < vtx.size(); i++)
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
|
|
|
printf(" ");
|
|
|
|
vtx[i].print();
|
|
|
|
}
|
|
|
|
printf(" vMerkleTree: ");
|
2012-04-15 22:52:09 +02:00
|
|
|
for (unsigned int i = 0; i < vMerkleTree.size(); i++)
|
2010-10-06 04:19:47 +02:00
|
|
|
printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
|
2010-08-29 18:58:15 +02:00
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
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 18:54:00 +02:00
|
|
|
// Undo the effects of this block (with given index) on the UTXO set represented by coins
|
2012-07-08 19:04:05 +02:00
|
|
|
bool DisconnectBlock(CBlockIndex *pindex, CCoinsViewCache &coins);
|
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 18:54:00 +02:00
|
|
|
|
|
|
|
// Apply the effects of this block (with given index) on the UTXO set represented by coins
|
2012-07-08 19:04:05 +02:00
|
|
|
bool ConnectBlock(CBlockIndex *pindex, CCoinsViewCache &coins, bool fJustCheck=false);
|
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 18:54:00 +02:00
|
|
|
|
|
|
|
// Read a block from disk
|
2012-11-14 22:18:10 +01:00
|
|
|
bool ReadFromDisk(const CBlockIndex* pindex);
|
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 18:54:00 +02:00
|
|
|
|
|
|
|
// Add this block to the block index, and if necessary, switch the active block chain to this
|
2012-06-19 01:36:43 +02:00
|
|
|
bool AddToBlockIndex(const CDiskBlockPos &pos);
|
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 18:54:00 +02:00
|
|
|
|
|
|
|
// Context-independent validity checks
|
2012-05-09 19:24:44 +02:00
|
|
|
bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true) const;
|
2012-03-10 23:04:06 +01:00
|
|
|
|
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 18:54:00 +02:00
|
|
|
// Store block on disk
|
2012-10-21 21:23:13 +02:00
|
|
|
// if dbp is provided, the file is known to already reside on disk
|
|
|
|
bool AcceptBlock(CDiskBlockPos *dbp = NULL);
|
2010-08-29 18:58:15 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2012-08-13 19:11:05 +02: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
|
|
|
|
uint64 nTimeFirst; // earliest time of block in file
|
|
|
|
uint64 nTimeLast; // latest time of block in file
|
|
|
|
|
|
|
|
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 {
|
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 18:54:00 +02: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 19:11:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// update statistics (does not update nSize)
|
|
|
|
void AddBlock(unsigned int nHeightIn, uint64 nTimeIn) {
|
|
|
|
if (nBlocks==0 || nHeightFirst > nHeightIn)
|
|
|
|
nHeightFirst = nHeightIn;
|
|
|
|
if (nBlocks==0 || nTimeFirst > nTimeIn)
|
|
|
|
nTimeFirst = nTimeIn;
|
|
|
|
nBlocks++;
|
|
|
|
if (nHeightIn > nHeightFirst)
|
|
|
|
nHeightLast = nHeightIn;
|
|
|
|
if (nTimeIn > nTimeLast)
|
|
|
|
nTimeLast = nTimeIn;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
extern CCriticalSection cs_LastBlockFile;
|
|
|
|
extern CBlockFileInfo infoLastBlockFile;
|
|
|
|
extern int nLastBlockFile;
|
2010-08-29 18:58:15 +02:00
|
|
|
|
2012-08-19 00:33:01 +02: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 16:48:23 +02:00
|
|
|
/** The block chain is a tree shaped structure starting with the
|
|
|
|
* genesis block at the root, with each block potentially having multiple
|
|
|
|
* candidates to be the next block. pprev and pnext link a path through the
|
|
|
|
* main/longest chain. A blockindex may have multiple pprev pointing back
|
|
|
|
* to it, but pnext will only point forward to the longest branch, or will
|
|
|
|
* be null if the block is not part of the longest chain.
|
|
|
|
*/
|
2010-08-29 18:58:15 +02:00
|
|
|
class CBlockIndex
|
|
|
|
{
|
|
|
|
public:
|
2012-08-19 00:33:01 +02:00
|
|
|
// pointer to the hash of the block, if any. memory is owned by this CBlockIndex
|
2010-08-29 18:58:15 +02:00
|
|
|
const uint256* phashBlock;
|
2012-08-19 00:33:01 +02:00
|
|
|
|
|
|
|
// pointer to the index of the predecessor of this block
|
2010-08-29 18:58:15 +02:00
|
|
|
CBlockIndex* pprev;
|
2012-08-19 00:33:01 +02:00
|
|
|
|
|
|
|
// (memory only) pointer to the index of the *active* successor of this block
|
2010-08-29 18:58:15 +02:00
|
|
|
CBlockIndex* pnext;
|
2012-08-19 00:33:01 +02:00
|
|
|
|
|
|
|
// height of the entry in the chain. The genesis block has height 0
|
2010-08-29 18:58:15 +02:00
|
|
|
int nHeight;
|
2012-08-19 00:33:01 +02: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 19:11:05 +02:00
|
|
|
unsigned int nUndoPos;
|
2012-08-19 00:33:01 +02:00
|
|
|
|
|
|
|
// (memory only) Total amount of work (expected number of hashes) in the chain up to and including this block
|
2010-08-29 18:58:15 +02:00
|
|
|
CBigNum bnChainWork;
|
|
|
|
|
2012-08-19 00:33:01 +02: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 18:58:15 +02:00
|
|
|
// block header
|
|
|
|
int nVersion;
|
|
|
|
uint256 hashMerkleRoot;
|
|
|
|
unsigned int nTime;
|
|
|
|
unsigned int nBits;
|
|
|
|
unsigned int nNonce;
|
|
|
|
|
|
|
|
|
|
|
|
CBlockIndex()
|
|
|
|
{
|
|
|
|
phashBlock = NULL;
|
|
|
|
pprev = NULL;
|
|
|
|
pnext = NULL;
|
|
|
|
nHeight = 0;
|
2012-08-19 00:33:01 +02: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 18:54:00 +02:00
|
|
|
nUndoPos = 0;
|
2010-08-29 18:58:15 +02:00
|
|
|
bnChainWork = 0;
|
2012-08-19 00:33:01 +02:00
|
|
|
nTx = 0;
|
|
|
|
nChainTx = 0;
|
|
|
|
nStatus = 0;
|
2010-08-29 18:58:15 +02:00
|
|
|
|
|
|
|
nVersion = 0;
|
|
|
|
hashMerkleRoot = 0;
|
|
|
|
nTime = 0;
|
|
|
|
nBits = 0;
|
|
|
|
nNonce = 0;
|
|
|
|
}
|
|
|
|
|
2012-11-14 22:18:10 +01:00
|
|
|
CBlockIndex(CBlockHeader& block)
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
|
|
|
phashBlock = NULL;
|
|
|
|
pprev = NULL;
|
|
|
|
pnext = NULL;
|
|
|
|
nHeight = 0;
|
2012-08-19 00:33:01 +02:00
|
|
|
nFile = 0;
|
|
|
|
nDataPos = 0;
|
2012-08-13 19:11:05 +02:00
|
|
|
nUndoPos = 0;
|
2010-08-29 18:58:15 +02:00
|
|
|
bnChainWork = 0;
|
2012-08-19 00:33:01 +02:00
|
|
|
nTx = 0;
|
|
|
|
nChainTx = 0;
|
|
|
|
nStatus = 0;
|
2010-08-29 18:58:15 +02:00
|
|
|
|
|
|
|
nVersion = block.nVersion;
|
|
|
|
hashMerkleRoot = block.hashMerkleRoot;
|
|
|
|
nTime = block.nTime;
|
|
|
|
nBits = block.nBits;
|
|
|
|
nNonce = block.nNonce;
|
|
|
|
}
|
|
|
|
|
2012-06-19 01:36:43 +02:00
|
|
|
CDiskBlockPos GetBlockPos() const {
|
2012-08-19 00:33:01 +02:00
|
|
|
CDiskBlockPos ret;
|
|
|
|
if (nStatus & BLOCK_HAVE_DATA) {
|
|
|
|
ret.nFile = nFile;
|
|
|
|
ret.nPos = nDataPos;
|
2012-12-03 10:14:54 +01:00
|
|
|
}
|
2012-08-19 00:33:01 +02:00
|
|
|
return ret;
|
2012-08-13 19:11:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
CDiskBlockPos GetUndoPos() const {
|
2012-08-19 00:33:01 +02:00
|
|
|
CDiskBlockPos ret;
|
|
|
|
if (nStatus & BLOCK_HAVE_UNDO) {
|
|
|
|
ret.nFile = nFile;
|
|
|
|
ret.nPos = nUndoPos;
|
2012-12-03 10:14:54 +01:00
|
|
|
}
|
2012-08-13 19:11:05 +02:00
|
|
|
return ret;
|
2012-06-19 01:36:43 +02:00
|
|
|
}
|
|
|
|
|
2012-11-14 22:18:10 +01:00
|
|
|
CBlockHeader GetBlockHeader() const
|
2010-12-05 10:29:30 +01:00
|
|
|
{
|
2012-11-14 22:18:10 +01:00
|
|
|
CBlockHeader block;
|
2010-12-05 10:29:30 +01: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 18:58:15 +02:00
|
|
|
uint256 GetBlockHash() const
|
|
|
|
{
|
|
|
|
return *phashBlock;
|
|
|
|
}
|
|
|
|
|
2011-12-21 22:33:19 +01:00
|
|
|
int64 GetBlockTime() const
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
2011-12-21 22:33:19 +01:00
|
|
|
return (int64)nTime;
|
2010-08-29 18:58:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
CBigNum GetBlockWork() const
|
|
|
|
{
|
2010-09-23 18:01:44 +02:00
|
|
|
CBigNum bnTarget;
|
|
|
|
bnTarget.SetCompact(nBits);
|
|
|
|
if (bnTarget <= 0)
|
2010-08-29 18:58:15 +02:00
|
|
|
return 0;
|
2010-09-23 18:01:44 +02:00
|
|
|
return (CBigNum(1)<<256) / (bnTarget+1);
|
2010-08-29 18:58:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bool IsInMainChain() const
|
|
|
|
{
|
|
|
|
return (pnext || this == pindexBest);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CheckIndex() const
|
|
|
|
{
|
|
|
|
return CheckProofOfWork(GetBlockHash(), nBits);
|
|
|
|
}
|
|
|
|
|
|
|
|
enum { nMedianTimeSpan=11 };
|
|
|
|
|
2011-12-21 22:33:19 +01:00
|
|
|
int64 GetMedianTimePast() const
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
2011-12-21 22:33:19 +01:00
|
|
|
int64 pmedian[nMedianTimeSpan];
|
|
|
|
int64* pbegin = &pmedian[nMedianTimeSpan];
|
|
|
|
int64* pend = &pmedian[nMedianTimeSpan];
|
2010-08-29 18:58:15 +02:00
|
|
|
|
|
|
|
const CBlockIndex* pindex = this;
|
|
|
|
for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
|
|
|
|
*(--pbegin) = pindex->GetBlockTime();
|
|
|
|
|
2011-05-15 09:11:04 +02:00
|
|
|
std::sort(pbegin, pend);
|
2010-08-29 18:58:15 +02:00
|
|
|
return pbegin[(pend - pbegin)/2];
|
|
|
|
}
|
|
|
|
|
2011-12-21 22:33:19 +01:00
|
|
|
int64 GetMedianTime() const
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
|
|
|
const CBlockIndex* pindex = this;
|
|
|
|
for (int i = 0; i < nMedianTimeSpan/2; i++)
|
|
|
|
{
|
|
|
|
if (!pindex->pnext)
|
|
|
|
return GetBlockTime();
|
|
|
|
pindex = pindex->pnext;
|
|
|
|
}
|
|
|
|
return pindex->GetMedianTimePast();
|
|
|
|
}
|
|
|
|
|
2012-06-28 01:30:39 +02:00
|
|
|
/**
|
|
|
|
* Returns true if there are nRequired or more blocks of minVersion or above
|
|
|
|
* in the last nToCheck blocks, starting at pstart and going backwards.
|
|
|
|
*/
|
|
|
|
static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
|
|
|
|
unsigned int nRequired, unsigned int nToCheck);
|
2010-08-29 18:58:15 +02:00
|
|
|
|
2011-05-15 09:11:04 +02:00
|
|
|
std::string ToString() const
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
2012-06-19 01:36:43 +02:00
|
|
|
return strprintf("CBlockIndex(pprev=%p, pnext=%p, nHeight=%d, merkle=%s, hashBlock=%s)",
|
|
|
|
pprev, pnext, nHeight,
|
2010-10-06 04:19:47 +02:00
|
|
|
hashMerkleRoot.ToString().substr(0,10).c_str(),
|
2012-08-13 09:02:44 +02:00
|
|
|
BlockHashStr(GetBlockHash()).c_str());
|
2010-08-29 18:58:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void print() const
|
|
|
|
{
|
|
|
|
printf("%s\n", ToString().c_str());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2012-08-19 00:33:01 +02:00
|
|
|
struct CBlockIndexWorkComparator
|
|
|
|
{
|
|
|
|
bool operator()(CBlockIndex *pa, CBlockIndex *pb) {
|
|
|
|
if (pa->bnChainWork > pb->bnChainWork) return false;
|
|
|
|
if (pa->bnChainWork < pb->bnChainWork) return true;
|
|
|
|
|
|
|
|
if (pa->GetBlockHash() < pb->GetBlockHash()) return false;
|
|
|
|
if (pa->GetBlockHash() > pb->GetBlockHash()) return true;
|
|
|
|
|
|
|
|
return false; // identical blocks
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2010-08-29 18:58:15 +02:00
|
|
|
|
|
|
|
|
2012-03-26 16:48:23 +02:00
|
|
|
/** Used to marshal pointers into hashes for db storage. */
|
2010-08-29 18:58:15 +02: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 18:54:00 +02:00
|
|
|
CDiskBlockIndex() {
|
2010-08-29 18:58:15 +02: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 18:54:00 +02:00
|
|
|
explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex) {
|
2010-08-29 18:58:15 +02:00
|
|
|
hashPrev = (pprev ? pprev->GetBlockHash() : 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
IMPLEMENT_SERIALIZE
|
|
|
|
(
|
|
|
|
if (!(nType & SER_GETHASH))
|
2012-08-19 00:33:01 +02: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 18:58:15 +02:00
|
|
|
|
|
|
|
// block header
|
|
|
|
READWRITE(this->nVersion);
|
|
|
|
READWRITE(hashPrev);
|
|
|
|
READWRITE(hashMerkleRoot);
|
|
|
|
READWRITE(nTime);
|
|
|
|
READWRITE(nBits);
|
|
|
|
READWRITE(nNonce);
|
|
|
|
)
|
|
|
|
|
|
|
|
uint256 GetBlockHash() const
|
|
|
|
{
|
2012-11-14 22:18:10 +01:00
|
|
|
CBlockHeader block;
|
2010-08-29 18:58:15 +02: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 09:11:04 +02:00
|
|
|
std::string ToString() const
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
2011-05-15 09:11:04 +02:00
|
|
|
std::string str = "CDiskBlockIndex(";
|
2010-08-29 18:58:15 +02: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 18:54:00 +02:00
|
|
|
str += strprintf("\n hashBlock=%s, hashPrev=%s)",
|
2010-08-29 18:58:15 +02:00
|
|
|
GetBlockHash().ToString().c_str(),
|
2012-08-13 09:02:44 +02:00
|
|
|
BlockHashStr(hashPrev).c_str());
|
2010-08-29 18:58:15 +02:00
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
|
|
|
void print() const
|
|
|
|
{
|
|
|
|
printf("%s\n", ToString().c_str());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2012-03-26 16:48:23 +02:00
|
|
|
/** Describes a place in the block chain to another node such that if the
|
|
|
|
* other node doesn't have the same branch, it can find a recent common trunk.
|
|
|
|
* The further back it is, the further before the fork it may be.
|
|
|
|
*/
|
2010-08-29 18:58:15 +02:00
|
|
|
class CBlockLocator
|
|
|
|
{
|
|
|
|
protected:
|
2011-05-15 09:11:04 +02:00
|
|
|
std::vector<uint256> vHave;
|
2010-08-29 18:58:15 +02:00
|
|
|
public:
|
|
|
|
|
|
|
|
CBlockLocator()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
explicit CBlockLocator(const CBlockIndex* pindex)
|
|
|
|
{
|
|
|
|
Set(pindex);
|
|
|
|
}
|
|
|
|
|
|
|
|
explicit CBlockLocator(uint256 hashBlock)
|
|
|
|
{
|
2011-05-15 09:11:04 +02:00
|
|
|
std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
|
2010-08-29 18:58:15 +02:00
|
|
|
if (mi != mapBlockIndex.end())
|
|
|
|
Set((*mi).second);
|
|
|
|
}
|
|
|
|
|
2011-07-11 21:49:45 +02:00
|
|
|
CBlockLocator(const std::vector<uint256>& vHaveIn)
|
|
|
|
{
|
|
|
|
vHave = vHaveIn;
|
|
|
|
}
|
|
|
|
|
2010-08-29 18:58:15 +02:00
|
|
|
IMPLEMENT_SERIALIZE
|
|
|
|
(
|
|
|
|
if (!(nType & SER_GETHASH))
|
|
|
|
READWRITE(nVersion);
|
|
|
|
READWRITE(vHave);
|
|
|
|
)
|
|
|
|
|
2010-12-05 10:29:30 +01:00
|
|
|
void SetNull()
|
|
|
|
{
|
|
|
|
vHave.clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IsNull()
|
|
|
|
{
|
|
|
|
return vHave.empty();
|
|
|
|
}
|
|
|
|
|
2010-08-29 18:58:15 +02:00
|
|
|
void Set(const CBlockIndex* pindex)
|
|
|
|
{
|
|
|
|
vHave.clear();
|
|
|
|
int nStep = 1;
|
|
|
|
while (pindex)
|
|
|
|
{
|
|
|
|
vHave.push_back(pindex->GetBlockHash());
|
|
|
|
|
|
|
|
// Exponentially larger steps back
|
|
|
|
for (int i = 0; pindex && i < nStep; i++)
|
|
|
|
pindex = pindex->pprev;
|
|
|
|
if (vHave.size() > 10)
|
|
|
|
nStep *= 2;
|
|
|
|
}
|
|
|
|
vHave.push_back(hashGenesisBlock);
|
|
|
|
}
|
|
|
|
|
|
|
|
int GetDistanceBack()
|
|
|
|
{
|
|
|
|
// Retrace how far back it was in the sender's branch
|
|
|
|
int nDistance = 0;
|
|
|
|
int nStep = 1;
|
2011-05-15 09:11:04 +02:00
|
|
|
BOOST_FOREACH(const uint256& hash, vHave)
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
2011-05-15 09:11:04 +02:00
|
|
|
std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
|
2010-08-29 18:58:15 +02:00
|
|
|
if (mi != mapBlockIndex.end())
|
|
|
|
{
|
|
|
|
CBlockIndex* pindex = (*mi).second;
|
|
|
|
if (pindex->IsInMainChain())
|
|
|
|
return nDistance;
|
|
|
|
}
|
|
|
|
nDistance += nStep;
|
|
|
|
if (nDistance > 10)
|
|
|
|
nStep *= 2;
|
|
|
|
}
|
|
|
|
return nDistance;
|
|
|
|
}
|
|
|
|
|
|
|
|
CBlockIndex* GetBlockIndex()
|
|
|
|
{
|
|
|
|
// Find the first block the caller has in the main chain
|
2011-05-15 09:11:04 +02:00
|
|
|
BOOST_FOREACH(const uint256& hash, vHave)
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
2011-05-15 09:11:04 +02:00
|
|
|
std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
|
2010-08-29 18:58:15 +02:00
|
|
|
if (mi != mapBlockIndex.end())
|
|
|
|
{
|
|
|
|
CBlockIndex* pindex = (*mi).second;
|
|
|
|
if (pindex->IsInMainChain())
|
|
|
|
return pindex;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return pindexGenesisBlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint256 GetBlockHash()
|
|
|
|
{
|
|
|
|
// Find the first block the caller has in the main chain
|
2011-05-15 09:11:04 +02:00
|
|
|
BOOST_FOREACH(const uint256& hash, vHave)
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
2011-05-15 09:11:04 +02:00
|
|
|
std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
|
2010-08-29 18:58:15 +02:00
|
|
|
if (mi != mapBlockIndex.end())
|
|
|
|
{
|
|
|
|
CBlockIndex* pindex = (*mi).second;
|
|
|
|
if (pindex->IsInMainChain())
|
|
|
|
return hash;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return hashGenesisBlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
int GetHeight()
|
|
|
|
{
|
|
|
|
CBlockIndex* pindex = GetBlockIndex();
|
|
|
|
if (!pindex)
|
|
|
|
return 0;
|
|
|
|
return pindex->nHeight;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2010-11-22 16:53:20 +01:00
|
|
|
|
|
|
|
|
2012-04-13 22:03:09 +02:00
|
|
|
class CTxMemPool
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
mutable CCriticalSection cs;
|
|
|
|
std::map<uint256, CTransaction> mapTx;
|
|
|
|
std::map<COutPoint, CInPoint> mapNextTx;
|
2012-04-13 22:28:07 +02:00
|
|
|
|
2012-07-06 16:33:34 +02:00
|
|
|
bool accept(CTransaction &tx, bool fCheckInputs, bool* pfMissingInputs);
|
2012-07-04 07:12:44 +02:00
|
|
|
bool addUnchecked(const uint256& hash, CTransaction &tx);
|
2012-11-24 14:26:51 +01:00
|
|
|
bool remove(const CTransaction &tx, bool fRecursive = false);
|
|
|
|
bool removeConflicts(const CTransaction &tx);
|
2012-05-22 23:55:15 +02:00
|
|
|
void clear();
|
2012-06-22 17:43:34 +02:00
|
|
|
void queryHashes(std::vector<uint256>& vtxid);
|
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 18:54:00 +02:00
|
|
|
void pruneSpent(const uint256& hash, CCoins &coins);
|
2012-04-13 22:28:07 +02:00
|
|
|
|
|
|
|
unsigned long size()
|
|
|
|
{
|
|
|
|
LOCK(cs);
|
|
|
|
return mapTx.size();
|
|
|
|
}
|
2012-04-14 00:20:44 +02:00
|
|
|
|
|
|
|
bool exists(uint256 hash)
|
|
|
|
{
|
|
|
|
return (mapTx.count(hash) != 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
CTransaction& lookup(uint256 hash)
|
|
|
|
{
|
|
|
|
return mapTx[hash];
|
|
|
|
}
|
2012-04-13 22:03:09 +02:00
|
|
|
};
|
|
|
|
|
2012-04-13 22:28:07 +02:00
|
|
|
extern CTxMemPool mempool;
|
|
|
|
|
2012-09-25 23:04:54 +02:00
|
|
|
struct CCoinsStats
|
|
|
|
{
|
|
|
|
int nHeight;
|
|
|
|
uint64 nTransactions;
|
|
|
|
uint64 nTransactionOutputs;
|
|
|
|
uint64 nSerializedSize;
|
|
|
|
|
|
|
|
CCoinsStats() : nHeight(0), nTransactions(0), nTransactionOutputs(0), nSerializedSize(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 18:54:00 +02:00
|
|
|
/** Abstract view on the open txout dataset. */
|
|
|
|
class CCoinsView
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
// Retrieve the CCoins (unspent transaction outputs) for a given txid
|
|
|
|
virtual bool GetCoins(uint256 txid, CCoins &coins);
|
|
|
|
|
|
|
|
// Modify the CCoins for a given txid
|
|
|
|
virtual bool SetCoins(uint256 txid, const CCoins &coins);
|
|
|
|
|
|
|
|
// Just check whether we have data for a given txid.
|
|
|
|
// This may (but cannot always) return true for fully spent transactions
|
|
|
|
virtual bool HaveCoins(uint256 txid);
|
|
|
|
|
|
|
|
// Retrieve the block index whose state this CCoinsView currently represents
|
|
|
|
virtual CBlockIndex *GetBestBlock();
|
|
|
|
|
|
|
|
// Modify the currently active block index
|
|
|
|
virtual bool SetBestBlock(CBlockIndex *pindex);
|
2012-10-23 00:21:16 +02:00
|
|
|
|
|
|
|
// Do a bulk modification (multiple SetCoins + one SetBestBlock)
|
2012-07-06 16:33:34 +02:00
|
|
|
virtual bool BatchWrite(const std::map<uint256, CCoins> &mapCoins, CBlockIndex *pindex);
|
2012-10-23 00:21:16 +02:00
|
|
|
|
|
|
|
// Calculate statistics about the unspent transaction output set
|
2012-09-25 23:04:54 +02:00
|
|
|
virtual bool GetStats(CCoinsStats &stats);
|
2012-11-01 22:53:54 +01:00
|
|
|
|
|
|
|
// As we use CCoinsViews polymorphically, have a virtual destructor
|
2012-11-11 13:11:42 +01:00
|
|
|
virtual ~CCoinsView() {}
|
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 18:54:00 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/** CCoinsView backed by another CCoinsView */
|
|
|
|
class CCoinsViewBacked : public CCoinsView
|
|
|
|
{
|
|
|
|
protected:
|
|
|
|
CCoinsView *base;
|
|
|
|
|
|
|
|
public:
|
|
|
|
CCoinsViewBacked(CCoinsView &viewIn);
|
|
|
|
bool GetCoins(uint256 txid, CCoins &coins);
|
|
|
|
bool SetCoins(uint256 txid, const CCoins &coins);
|
|
|
|
bool HaveCoins(uint256 txid);
|
|
|
|
CBlockIndex *GetBestBlock();
|
|
|
|
bool SetBestBlock(CBlockIndex *pindex);
|
|
|
|
void SetBackend(CCoinsView &viewIn);
|
2012-07-06 16:33:34 +02:00
|
|
|
bool BatchWrite(const std::map<uint256, CCoins> &mapCoins, CBlockIndex *pindex);
|
2012-09-25 23:04:54 +02:00
|
|
|
bool GetStats(CCoinsStats &stats);
|
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 18:54:00 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/** CCoinsView that adds a memory cache for transactions to another CCoinsView */
|
|
|
|
class CCoinsViewCache : public CCoinsViewBacked
|
|
|
|
{
|
|
|
|
protected:
|
|
|
|
CBlockIndex *pindexTip;
|
|
|
|
std::map<uint256,CCoins> cacheCoins;
|
|
|
|
|
|
|
|
public:
|
|
|
|
CCoinsViewCache(CCoinsView &baseIn, bool fDummy = false);
|
2012-10-23 00:21:16 +02:00
|
|
|
|
|
|
|
// Standard CCoinsView methods
|
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 18:54:00 +02:00
|
|
|
bool GetCoins(uint256 txid, CCoins &coins);
|
|
|
|
bool SetCoins(uint256 txid, const CCoins &coins);
|
|
|
|
bool HaveCoins(uint256 txid);
|
|
|
|
CBlockIndex *GetBestBlock();
|
|
|
|
bool SetBestBlock(CBlockIndex *pindex);
|
2012-07-06 16:33:34 +02:00
|
|
|
bool BatchWrite(const std::map<uint256, CCoins> &mapCoins, CBlockIndex *pindex);
|
2012-10-23 00:21:16 +02:00
|
|
|
|
|
|
|
// Return a modifiable reference to a CCoins. Check HaveCoins first.
|
|
|
|
// Many methods explicitly require a CCoinsViewCache because of this method, to reduce
|
|
|
|
// copying.
|
|
|
|
CCoins &GetCoins(uint256 txid);
|
|
|
|
|
|
|
|
// Push the modifications applied to this cache to its base.
|
|
|
|
// Failure to call this method before destruction will cause the changes to be forgotten.
|
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 18:54:00 +02:00
|
|
|
bool Flush();
|
2012-10-23 00:21:16 +02:00
|
|
|
|
|
|
|
// Calculate the size of the cache (in number of transactions)
|
2012-07-06 16:33:34 +02:00
|
|
|
unsigned int GetCacheSize();
|
2012-07-08 19:04:05 +02:00
|
|
|
|
|
|
|
private:
|
|
|
|
std::map<uint256,CCoins>::iterator FetchCoins(uint256 txid);
|
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 18:54:00 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/** CCoinsView that brings transactions from a memorypool into view.
|
|
|
|
It does not check for spendings by memory pool transactions. */
|
|
|
|
class CCoinsViewMemPool : public CCoinsViewBacked
|
|
|
|
{
|
|
|
|
protected:
|
|
|
|
CTxMemPool &mempool;
|
|
|
|
|
|
|
|
public:
|
|
|
|
CCoinsViewMemPool(CCoinsView &baseIn, CTxMemPool &mempoolIn);
|
|
|
|
bool GetCoins(uint256 txid, CCoins &coins);
|
|
|
|
bool HaveCoins(uint256 txid);
|
|
|
|
};
|
|
|
|
|
2012-09-03 15:26:57 +02:00
|
|
|
/** Global variable that points to the active CCoinsView (protected by cs_main) */
|
2012-07-06 16:33:34 +02:00
|
|
|
extern CCoinsViewCache *pcoinsTip;
|
|
|
|
|
2012-09-03 15:26:57 +02:00
|
|
|
/** Global variable that points to the active block tree (protected by cs_main) */
|
|
|
|
extern CBlockTreeDB *pblocktree;
|
|
|
|
|
2011-05-15 09:11:04 +02:00
|
|
|
#endif
|