kvazar/kevacoin
1
0
Fork 0
mirror of https://github.com/kvazar-network/kevacoin.git synced 2025-01-11 15:48:05 +00:00
Code Issues Projects Releases Wiki Activity

Ultraprune

Browse Source 
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.
This commit is contained in:
Pieter Wuille 2012-07-01 18:54:00 +02:00
parent bba89aa82a
commit 450cbb0944
15 changed files with 890 additions and 1127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

245
src/db.cpp
View File

@ -244,7 +244,7 @@ CDB::CDB(const char *pszFile, const char* pszMode) :
ret = pdb->open(NULL, // Txn pointer ret = pdb->open(NULL, // Txn pointer
fMockDb ? NULL : pszFile, // Filename fMockDb ? NULL : pszFile, // Filename
"main", // Logical db name fMockDb ? pszFile : "main", // Logical db name
DB_BTREE, // Database type DB_BTREE, // Database type
nFlags, // Flags nFlags, // Flags
0); 0);
@ -273,7 +273,7 @@ CDB::CDB(const char *pszFile, const char* pszMode) :
static bool IsChainFile(std::string strFile) static bool IsChainFile(std::string strFile)
{ {
if (strFile == "blkindex.dat") if (strFile == "coins.dat" || strFile == "chain.dat")
return true; return true;
return false; return false;
@ -475,111 +475,66 @@ void CDBEnv::Flush(bool fShutdown)
// //
// CTxDB // CChainDB and CCoinsDB
// //
bool CTxDB::ReadTxIndex(uint256 hash, CTxIndex& txindex) bool CCoinsDB::HaveCoins(uint256 hash) {
{
assert(!fClient); assert(!fClient);
txindex.SetNull(); return Exists(make_pair('c', hash));
return Read(make_pair(string("tx"), hash), txindex);
} }
bool CTxDB::UpdateTxIndex(uint256 hash, const CTxIndex& txindex) bool CCoinsDB::ReadCoins(uint256 hash, CCoins &coins) {
{
assert(!fClient); assert(!fClient);
return Write(make_pair(string("tx"), hash), txindex); return Read(make_pair('c', hash), coins);
} }
bool CTxDB::AddTxIndex(const CTransaction& tx, const CDiskTxPos& pos, int nHeight) bool CCoinsDB::WriteCoins(uint256 hash, const CCoins &coins) {
{
assert(!fClient); assert(!fClient);
if (coins.IsPruned())
// Add to tx index return Erase(make_pair('c', hash));
uint256 hash = tx.GetHash(); else
CTxIndex txindex(pos, tx.vout.size()); return Write(make_pair('c', hash), coins);
return Write(make_pair(string("tx"), hash), txindex);
} }
bool CTxDB::EraseTxIndex(const CTransaction& tx) bool CChainDB::WriteBlockIndex(const CDiskBlockIndex& blockindex)
{ {
assert(!fClient); return Write(make_pair('b', blockindex.GetBlockHash()), blockindex);
uint256 hash = tx.GetHash();
return Erase(make_pair(string("tx"), hash));
} }
bool CTxDB::ContainsTx(uint256 hash) bool CCoinsDB::ReadHashBestChain(uint256& hashBestChain)
{ {
assert(!fClient); return Read('B', hashBestChain);
return Exists(make_pair(string("tx"), hash));
} }
bool CTxDB::ReadDiskTx(uint256 hash, CTransaction& tx, CTxIndex& txindex) bool CCoinsDB::WriteHashBestChain(uint256 hashBestChain)
{ {
assert(!fClient); return Write('B', hashBestChain);
tx.SetNull();
if (!ReadTxIndex(hash, txindex))
return false;
return (tx.ReadFromDisk(txindex.pos));
} }
bool CTxDB::ReadDiskTx(uint256 hash, CTransaction& tx) bool CChainDB::ReadBestInvalidWork(CBigNum& bnBestInvalidWork)
{ {
CTxIndex txindex; return Read('I', bnBestInvalidWork);
return ReadDiskTx(hash, tx, txindex);
} }
bool CTxDB::ReadDiskTx(COutPoint outpoint, CTransaction& tx, CTxIndex& txindex) bool CChainDB::WriteBestInvalidWork(CBigNum bnBestInvalidWork)
{ {
return ReadDiskTx(outpoint.hash, tx, txindex); return Write('I', bnBestInvalidWork);
} }
bool CTxDB::ReadDiskTx(COutPoint outpoint, CTransaction& tx) bool CChainDB::WriteBlockFileInfo(int nFile, const CBlockFileInfo &info) {
{ return Write(make_pair('f', nFile), info);
CTxIndex txindex;
return ReadDiskTx(outpoint.hash, tx, txindex);
} }
bool CTxDB::WriteBlockIndex(const CDiskBlockIndex& blockindex) bool CChainDB::ReadBlockFileInfo(int nFile, CBlockFileInfo &info) {
{ return Read(make_pair('f', nFile), info);
return Write(make_pair(string("blockindex"), blockindex.GetBlockHash()), blockindex);
} }
bool CTxDB::WriteBlockFileInfo(int nFile, const CBlockFileInfo &info) { bool CChainDB::WriteLastBlockFile(int nFile) {
return Write(make_pair(string("blockfile"), nFile), info); return Write('l', nFile);
} }
bool CTxDB::ReadBlockFileInfo(int nFile, CBlockFileInfo &info) { bool CChainDB::ReadLastBlockFile(int &nFile) {
return Read(make_pair(string("blockfile"), nFile), info); return Read('l', nFile);
}
bool CTxDB::WriteLastBlockFile(int nFile) {
return Write(string("lastblockfile"), nFile);
}
bool CTxDB::ReadLastBlockFile(int &nFile) {
return Read(string("lastblockfile"), nFile);
}
bool CTxDB::ReadHashBestChain(uint256& hashBestChain)
{
return Read(string("hashBestChain"), hashBestChain);
}
bool CTxDB::WriteHashBestChain(uint256 hashBestChain)
{
return Write(string("hashBestChain"), hashBestChain);
}
bool CTxDB::ReadBestInvalidWork(CBigNum& bnBestInvalidWork)
{
return Read(string("bnBestInvalidWork"), bnBestInvalidWork);
}
bool CTxDB::WriteBestInvalidWork(CBigNum bnBestInvalidWork)
{
return Write(string("bnBestInvalidWork"), bnBestInvalidWork);
} }
CBlockIndex static * InsertBlockIndex(uint256 hash) CBlockIndex static * InsertBlockIndex(uint256 hash)
@ -602,9 +557,9 @@ CBlockIndex static * InsertBlockIndex(uint256 hash)
return pindexNew; return pindexNew;
} }
bool CTxDB::LoadBlockIndex() bool LoadBlockIndex(CCoinsDB &coindb, CChainDB &chaindb)
{ {
if (!LoadBlockIndexGuts()) if (!chaindb.LoadBlockIndexGuts())
return false; return false;
if (fRequestShutdown) if (fRequestShutdown)
@ -626,29 +581,39 @@ bool CTxDB::LoadBlockIndex()
} }
// Load block file info // Load block file info
ReadLastBlockFile(nLastBlockFile); chaindb.ReadLastBlockFile(nLastBlockFile);
printf("LoadBlockIndex(): last block file = %i\n", nLastBlockFile); printf("LoadBlockIndex(): last block file = %i\n", nLastBlockFile);
if (ReadBlockFileInfo(nLastBlockFile, infoLastBlockFile)) if (chaindb.ReadBlockFileInfo(nLastBlockFile, infoLastBlockFile))
printf("LoadBlockIndex(): last block file: %s\n", infoLastBlockFile.ToString().c_str()); printf("LoadBlockIndex(): last block file: %s\n", infoLastBlockFile.ToString().c_str());
// Load hashBestChain pointer to end of best chain // Load hashBestChain pointer to end of best chain
if (!ReadHashBestChain(hashBestChain)) if (!coindb.ReadHashBestChain(hashBestChain))
{ {
if (pindexGenesisBlock == NULL) if (pindexGenesisBlock == NULL)
return true; return true;
return error("CTxDB::LoadBlockIndex() : hashBestChain not loaded"); return error("CTxDB::LoadBlockIndex() : hashBestChain not loaded");
} }
if (!mapBlockIndex.count(hashBestChain)) std::map<uint256, CBlockIndex*>::iterator it = mapBlockIndex.find(hashBestChain);
if (it == mapBlockIndex.end()) {
return error("CTxDB::LoadBlockIndex() : hashBestChain not found in the block index"); return error("CTxDB::LoadBlockIndex() : hashBestChain not found in the block index");
pindexBest = mapBlockIndex[hashBestChain]; } else {
nBestHeight = pindexBest->nHeight; // set 'next' pointers in best chain
bnBestChainWork = pindexBest->bnChainWork; CBlockIndex *pindex = it->second;
printf("LoadBlockIndex(): hashBestChain=%s height=%d date=%s\n", while(pindex != NULL && pindex->pprev != NULL) {
hashBestChain.ToString().substr(0,20).c_str(), nBestHeight, CBlockIndex *pindexPrev = pindex->pprev;
DateTimeStrFormat("%x %H:%M:%S", pindexBest->GetBlockTime()).c_str()); pindexPrev->pnext = pindex;
pindex = pindexPrev;
}
pindexBest = it->second;
nBestHeight = pindexBest->nHeight;
bnBestChainWork = pindexBest->bnChainWork;
}
printf("LoadBlockIndex(): hashBestChain=%s height=%d date=%s\n",
hashBestChain.ToString().substr(0,20).c_str(), nBestHeight,
DateTimeStrFormat("%x %H:%M:%S", pindexBest->GetBlockTime()).c_str());
// Load bnBestInvalidWork, OK if it doesn't exist // Load bnBestInvalidWork, OK if it doesn't exist
ReadBestInvalidWork(bnBestInvalidWork); chaindb.ReadBestInvalidWork(bnBestInvalidWork);
// Verify blocks in the best chain // Verify blocks in the best chain
int nCheckLevel = GetArg("-checklevel", 1); int nCheckLevel = GetArg("-checklevel", 1);
@ -664,7 +629,6 @@ bool CTxDB::LoadBlockIndex()
if (fRequestShutdown || pindex->nHeight < nBestHeight-nCheckDepth) if (fRequestShutdown || pindex->nHeight < nBestHeight-nCheckDepth)
break; break;
CBlock block; CBlock block;
CDiskBlockPos blockPos = pindex->GetBlockPos();
if (!block.ReadFromDisk(pindex)) if (!block.ReadFromDisk(pindex))
return error("LoadBlockIndex() : block.ReadFromDisk failed"); return error("LoadBlockIndex() : block.ReadFromDisk failed");
// check level 1: verify block validity // check level 1: verify block validity
@ -673,98 +637,12 @@ bool CTxDB::LoadBlockIndex()
printf("LoadBlockIndex() : *** found bad block at %d, hash=%s\n", pindex->nHeight, pindex->GetBlockHash().ToString().c_str()); printf("LoadBlockIndex() : *** found bad block at %d, hash=%s\n", pindex->nHeight, pindex->GetBlockHash().ToString().c_str());
pindexFork = pindex->pprev; pindexFork = pindex->pprev;
} }
// check level 2: verify transaction index validity // TODO: stronger verifications
if (nCheckLevel>1)
{
BOOST_FOREACH(const CTransaction &tx, block.vtx)
{
uint256 hashTx = tx.GetHash();
CTxIndex txindex;
if (ReadTxIndex(hashTx, txindex))
{
// check level 3: checker transaction hashes
if (nCheckLevel>2 || blockPos != txindex.pos.blockPos)
{
// either an error or a duplicate transaction
CTransaction txFound;
if (!txFound.ReadFromDisk(txindex.pos))
{
printf("LoadBlockIndex() : *** cannot read mislocated transaction %s\n", hashTx.ToString().c_str());
pindexFork = pindex->pprev;
}
else
if (txFound.GetHash() != hashTx) // not a duplicate tx
{
printf("LoadBlockIndex(): *** invalid tx position for %s\n", hashTx.ToString().c_str());
pindexFork = pindex->pprev;
}
}
// check level 4: check whether spent txouts were spent within the main chain
unsigned int nOutput = 0;
if (nCheckLevel>3)
{
BOOST_FOREACH(const CDiskTxPos &txpos, txindex.vSpent)
{
if (!txpos.IsNull())
{
// check level 6: check whether spent txouts were spent by a valid transaction that consume them
if (nCheckLevel>5)
{
CTransaction txSpend;
if (!txSpend.ReadFromDisk(txpos))
{
printf("LoadBlockIndex(): *** cannot read spending transaction of %s:%i from disk\n", hashTx.ToString().c_str(), nOutput);
pindexFork = pindex->pprev;
}
else if (!txSpend.CheckTransaction())
{
printf("LoadBlockIndex(): *** spending transaction of %s:%i is invalid\n", hashTx.ToString().c_str(), nOutput);
pindexFork = pindex->pprev;
}
else
{
bool fFound = false;
BOOST_FOREACH(const CTxIn &txin, txSpend.vin)
if (txin.prevout.hash == hashTx && txin.prevout.n == nOutput)
fFound = true;
if (!fFound)
{
printf("LoadBlockIndex(): *** spending transaction of %s:%i does not spend it\n", hashTx.ToString().c_str(), nOutput);
pindexFork = pindex->pprev;
}
}
}
}
nOutput++;
}
}
}
// check level 5: check whether all prevouts are marked spent
if (nCheckLevel>4)
{
BOOST_FOREACH(const CTxIn &txin, tx.vin)
{
CTxIndex txindex;
if (ReadTxIndex(txin.prevout.hash, txindex))
if (txindex.vSpent.size()-1 < txin.prevout.n || txindex.vSpent[txin.prevout.n].IsNull())
{
printf("LoadBlockIndex(): *** found unspent prevout %s:%i in %s\n", txin.prevout.hash.ToString().c_str(), txin.prevout.n, hashTx.ToString().c_str());
pindexFork = pindex->pprev;
}
}
}
}
}
} }
if (pindexFork && !fRequestShutdown) if (pindexFork && !fRequestShutdown)
{ {
// Reorg back to the fork // TODO: reorg back
printf("LoadBlockIndex() : *** moving best chain pointer back to block %d\n", pindexFork->nHeight); return error("LoadBlockIndex(): chain database corrupted");
CBlock block;
if (!block.ReadFromDisk(pindexFork))
return error("LoadBlockIndex() : block.ReadFromDisk failed");
CTxDB txdb;
block.SetBestChain(txdb, pindexFork);
} }
return true; return true;
@ -772,7 +650,7 @@ bool CTxDB::LoadBlockIndex()
bool CTxDB::LoadBlockIndexGuts() bool CChainDB::LoadBlockIndexGuts()
{ {
// Get database cursor // Get database cursor
Dbc* pcursor = GetCursor(); Dbc* pcursor = GetCursor();
@ -786,7 +664,7 @@ bool CTxDB::LoadBlockIndexGuts()
// Read next record // Read next record
CDataStream ssKey(SER_DISK, CLIENT_VERSION); CDataStream ssKey(SER_DISK, CLIENT_VERSION);
if (fFlags == DB_SET_RANGE) if (fFlags == DB_SET_RANGE)
ssKey << make_pair(string("blockindex"), uint256(0)); ssKey << make_pair('b', uint256(0));
CDataStream ssValue(SER_DISK, CLIENT_VERSION); CDataStream ssValue(SER_DISK, CLIENT_VERSION);
int ret = ReadAtCursor(pcursor, ssKey, ssValue, fFlags); int ret = ReadAtCursor(pcursor, ssKey, ssValue, fFlags);
fFlags = DB_NEXT; fFlags = DB_NEXT;
@ -798,9 +676,9 @@ bool CTxDB::LoadBlockIndexGuts()
// Unserialize // Unserialize
try { try {
string strType; char chType;
ssKey >> strType; ssKey >> chType;
if (strType == "blockindex" && !fRequestShutdown) if (chType == 'b' && !fRequestShutdown)
{ {
CDiskBlockIndex diskindex; CDiskBlockIndex diskindex;
ssValue >> diskindex; ssValue >> diskindex;
@ -808,7 +686,6 @@ bool CTxDB::LoadBlockIndexGuts()
// Construct block index object // Construct block index object
CBlockIndex* pindexNew = InsertBlockIndex(diskindex.GetBlockHash()); CBlockIndex* pindexNew = InsertBlockIndex(diskindex.GetBlockHash());
pindexNew->pprev = InsertBlockIndex(diskindex.hashPrev); pindexNew->pprev = InsertBlockIndex(diskindex.hashPrev);
pindexNew->pnext = InsertBlockIndex(diskindex.hashNext);
pindexNew->nHeight = diskindex.nHeight; pindexNew->nHeight = diskindex.nHeight;
pindexNew->pos = diskindex.pos; pindexNew->pos = diskindex.pos;
pindexNew->nUndoPos = diskindex.nUndoPos; pindexNew->nUndoPos = diskindex.nUndoPos;

40
src/db.h
View File

@ -17,10 +17,8 @@ class CAddress;
class CAddrMan; class CAddrMan;
class CBlockLocator; class CBlockLocator;
class CDiskBlockIndex; class CDiskBlockIndex;
class CDiskTxPos;
class CMasterKey; class CMasterKey;
class COutPoint; class COutPoint;
class CTxIndex;
class CWallet; class CWallet;
class CWalletTx; class CWalletTx;
@ -316,39 +314,43 @@ public:
/** Access to the transaction database (blkindex.dat) */ /** Access to the transaction database (coins.dat) */
class CTxDB : public CDB class CCoinsDB : public CDB
{ {
public: public:
CTxDB(const char* pszMode="r+") : CDB("blkindex.dat", pszMode) { } CCoinsDB(const char* pszMode="r+") : CDB("coins.dat", pszMode) { }
private: private:
CTxDB(const CTxDB&); CCoinsDB(const CCoinsDB&);
void operator=(const CTxDB&); void operator=(const CCoinsDB&);
public: public:
bool ReadTxIndex(uint256 hash, CTxIndex& txindex); bool ReadCoins(uint256 hash, CCoins &coins);
bool UpdateTxIndex(uint256 hash, const CTxIndex& txindex); bool WriteCoins(uint256 hash, const CCoins& coins);
bool AddTxIndex(const CTransaction& tx, const CDiskTxPos& pos, int nHeight); bool HaveCoins(uint256 hash);
bool EraseTxIndex(const CTransaction& tx);
bool ContainsTx(uint256 hash);
bool ReadDiskTx(uint256 hash, CTransaction& tx, CTxIndex& txindex);
bool ReadDiskTx(uint256 hash, CTransaction& tx);
bool ReadDiskTx(COutPoint outpoint, CTransaction& tx, CTxIndex& txindex);
bool ReadDiskTx(COutPoint outpoint, CTransaction& tx);
bool WriteBlockIndex(const CDiskBlockIndex& blockindex);
bool ReadHashBestChain(uint256& hashBestChain); bool ReadHashBestChain(uint256& hashBestChain);
bool WriteHashBestChain(uint256 hashBestChain); bool WriteHashBestChain(uint256 hashBestChain);
};
/** Access to the block database (chain.dat) */
class CChainDB : public CDB
{
public:
CChainDB(const char* pszMode="r+") : CDB("chain.dat", pszMode) { }
private:
CChainDB(const CChainDB&);
void operator=(const CChainDB&);
public:
bool WriteBlockIndex(const CDiskBlockIndex& blockindex);
bool ReadBestInvalidWork(CBigNum& bnBestInvalidWork); bool ReadBestInvalidWork(CBigNum& bnBestInvalidWork);
bool WriteBestInvalidWork(CBigNum bnBestInvalidWork); bool WriteBestInvalidWork(CBigNum bnBestInvalidWork);
bool ReadBlockFileInfo(int nFile, CBlockFileInfo &fileinfo); bool ReadBlockFileInfo(int nFile, CBlockFileInfo &fileinfo);
bool WriteBlockFileInfo(int nFile, const CBlockFileInfo &fileinfo); bool WriteBlockFileInfo(int nFile, const CBlockFileInfo &fileinfo);
bool ReadLastBlockFile(int &nFile); bool ReadLastBlockFile(int &nFile);
bool WriteLastBlockFile(int nFile); bool WriteLastBlockFile(int nFile);
bool LoadBlockIndex();
private:
bool LoadBlockIndexGuts(); bool LoadBlockIndexGuts();
}; };
bool LoadBlockIndex(CCoinsDB &coinsdb, CChainDB &chaindb);
/** Access to the (IP) address database (peers.dat) */ /** Access to the (IP) address database (peers.dat) */

8
src/init.cpp
View File

@ -638,14 +638,6 @@ bool AppInit2()
return InitError(msg); return InitError(msg);
} }
if (GetBoolArg("-loadblockindextest"))
{
CTxDB txdb("r");
txdb.LoadBlockIndex();
PrintBlockTree();
return false;
}
uiInterface.InitMessage(_("Loading block index...")); uiInterface.InitMessage(_("Loading block index..."));
printf("Loading block index...\n"); printf("Loading block index...\n");
nStart = GetTimeMillis(); nStart = GetTimeMillis();

1095
src/main.cpp
View File

File diff suppressed because it is too large Load Diff

350
src/main.h
View File

@ -31,6 +31,7 @@ static const unsigned int MAX_INV_SZ = 50000;
static const unsigned int MAX_BLOCKFILE_SIZE = 0x8000000; // 128 MiB static const unsigned int MAX_BLOCKFILE_SIZE = 0x8000000; // 128 MiB
static const unsigned int BLOCKFILE_CHUNK_SIZE = 0x1000000; // 16 MiB static const unsigned int BLOCKFILE_CHUNK_SIZE = 0x1000000; // 16 MiB
static const unsigned int UNDOFILE_CHUNK_SIZE = 0x100000; // 1 MiB static const unsigned int UNDOFILE_CHUNK_SIZE = 0x100000; // 1 MiB
static const unsigned int MEMPOOL_HEIGHT = 0x7FFFFFFF;
static const int64 MIN_TX_FEE = 50000; static const int64 MIN_TX_FEE = 50000;
static const int64 MIN_RELAY_TX_FEE = 10000; static const int64 MIN_RELAY_TX_FEE = 10000;
static const int64 MAX_MONEY = 21000000 * COIN; static const int64 MAX_MONEY = 21000000 * COIN;
@ -81,9 +82,12 @@ static const uint64 nMinDiskSpace = 52428800;
class CReserveKey; class CReserveKey;
class CTxDB; class CCoinsDB;
class CTxIndex; class CChainDB;
class CDiskBlockPos; class CDiskBlockPos;
class CCoins;
class CTxUndo;
class CCoinsView;
void RegisterWallet(CWallet* pwalletIn); void RegisterWallet(CWallet* pwalletIn);
void UnregisterWallet(CWallet* pwalletIn); void UnregisterWallet(CWallet* pwalletIn);
@ -108,8 +112,7 @@ unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
int GetNumBlocksOfPeers(); int GetNumBlocksOfPeers();
bool IsInitialBlockDownload(); bool IsInitialBlockDownload();
std::string GetWarnings(std::string strFor); std::string GetWarnings(std::string strFor);
bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock); bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock, bool fAllowSlow = false);
@ -143,62 +146,8 @@ public:
void SetNull() { nFile = -1; nPos = 0; } void SetNull() { nFile = -1; nPos = 0; }
bool IsNull() const { return (nFile == -1); } bool IsNull() const { return (nFile == -1); }
void SetMemPool() { nFile = -2; nPos = 0; }
bool IsMemPool() const { return (nFile == -2); }
}; };
/** Position on disk for a particular transaction. */
class CDiskTxPos
{
public:
CDiskBlockPos blockPos;
unsigned int nTxPos;
CDiskTxPos(bool fInMemPool = false)
{
SetNull();
if (fInMemPool)
blockPos.SetMemPool();
}
CDiskTxPos(const CDiskBlockPos &block, unsigned int nTxPosIn) : blockPos(block), nTxPos(nTxPosIn) { }
IMPLEMENT_SERIALIZE(
READWRITE(blockPos);
READWRITE(VARINT(nTxPos));
)
void SetNull() { blockPos.SetNull(); nTxPos = 0; }
bool IsNull() const { return (nTxPos == 0); }
bool IsMemPool() const { return blockPos.IsMemPool(); }
friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
{
return (a.blockPos == b.blockPos &&
a.nTxPos == b.nTxPos);
}
friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
{
return !(a == b);
}
std::string ToString() const
{
if (IsNull())
return "null";
else if (blockPos.IsMemPool())
return "mempool";
else
return strprintf("\"blk%05i.dat:0x%x\"", blockPos.nFile, nTxPos);
}
void print() const
{
printf("%s", ToString().c_str());
}
};
@ -413,7 +362,13 @@ enum GetMinFee_mode
GMF_SEND, GMF_SEND,
}; };
typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx; // Modes for script/signature checking
enum CheckSig_mode
{
CS_NEVER, // never validate scripts
CS_AFTER_CHECKPOINT, // validate scripts after the last checkpoint
CS_ALWAYS // always validate scripts
};
/** The basic transaction that is broadcasted on the network and contained in /** The basic transaction that is broadcasted on the network and contained in
* blocks. A transaction can contain multiple inputs and outputs. * blocks. A transaction can contain multiple inputs and outputs.
@ -525,7 +480,7 @@ public:
@return True if all inputs (scriptSigs) use only standard transaction forms @return True if all inputs (scriptSigs) use only standard transaction forms
@see CTransaction::FetchInputs @see CTransaction::FetchInputs
*/ */
bool AreInputsStandard(const MapPrevTx& mapInputs) const; bool AreInputsStandard(CCoinsView& mapInputs) const;
/** Count ECDSA signature operations the old-fashioned (pre-0.6) way /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
@return number of sigops this transaction's outputs will produce when spent @return number of sigops this transaction's outputs will produce when spent
@ -539,7 +494,7 @@ public:
@return maximum number of sigops required to validate this transaction's inputs @return maximum number of sigops required to validate this transaction's inputs
@see CTransaction::FetchInputs @see CTransaction::FetchInputs
*/ */
unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const; unsigned int GetP2SHSigOpCount(CCoinsView& mapInputs) const;
/** Amount of bitcoins spent by this transaction. /** Amount of bitcoins spent by this transaction.
@return sum of all outputs (note: does not include fees) @return sum of all outputs (note: does not include fees)
@ -564,7 +519,7 @@ public:
@return Sum of value of all inputs (scriptSigs) @return Sum of value of all inputs (scriptSigs)
@see CTransaction::FetchInputs @see CTransaction::FetchInputs
*/ */
int64 GetValueIn(const MapPrevTx& mapInputs) const; int64 GetValueIn(CCoinsView& mapInputs) const;
static bool AllowFree(double dPriority) static bool AllowFree(double dPriority)
{ {
@ -575,33 +530,6 @@ public:
int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=true, enum GetMinFee_mode mode=GMF_BLOCK) const; int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=true, enum GetMinFee_mode mode=GMF_BLOCK) const;
bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
{
CAutoFile filein = CAutoFile(OpenBlockFile(pos.blockPos, pfileRet==NULL), SER_DISK, CLIENT_VERSION);
if (!filein)
return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
// Read transaction
if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
return error("CTransaction::ReadFromDisk() : fseek failed");
try {
filein >> *this;
}
catch (std::exception &e) {
return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
}
// Return file pointer
if (pfileRet)
{
if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
return error("CTransaction::ReadFromDisk() : second fseek failed");
*pfileRet = filein.release();
}
return true;
}
friend bool operator==(const CTransaction& a, const CTransaction& b) friend bool operator==(const CTransaction& a, const CTransaction& b)
{ {
return (a.nVersion == b.nVersion && return (a.nVersion == b.nVersion &&
@ -638,45 +566,27 @@ public:
} }
bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet); // Do all possible client-mode checks
bool ReadFromDisk(CTxDB& txdb, COutPoint prevout); bool ClientCheckInputs() const;
bool ReadFromDisk(COutPoint prevout);
bool DisconnectInputs(CTxDB& txdb);
/** Fetch from memory and/or disk. inputsRet keys are transaction hashes. // Check whether all prevouts of this transaction are present in the UTXO set represented by view
bool HaveInputs(CCoinsView &view) const;
@param[in] txdb Transaction database // Check whether all inputs of this transaction are valid (no double spends, scripts & sigs, amounts)
@param[in] mapTestPool List of pending changes to the transaction index database // This does not modify the UTXO set
@param[in] fBlock True if being called to add a new best-block to the chain bool CheckInputs(CCoinsView &view, enum CheckSig_mode csmode, bool fStrictPayToScriptHash=true, bool fStrictEncodings=true) const;
@param[in] fMiner True if being called by CreateNewBlock
@param[out] inputsRet Pointers to this transaction's inputs
@param[out] fInvalid returns true if transaction is invalid
@return Returns true if all inputs are in txdb or mapTestPool
*/
bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
/** Sanity check previous transactions, then, if all checks succeed, // Apply the effects of this transaction on the UTXO set represented by view
mark them as spent by this transaction. bool UpdateCoins(CCoinsView &view, CTxUndo &txundo, int nHeight) const;
@param[in] inputs Previous transactions (from FetchInputs) // Context-independent validity checks
@param[out] mapTestPool Keeps track of inputs that need to be updated on disk
@param[in] posThisTx Position of this transaction on disk
@param[in] pindexBlock
@param[in] fBlock true if called from ConnectBlock
@param[in] fMiner true if called from CreateNewBlock
@param[in] fStrictPayToScriptHash true if fully validating p2sh transactions
@return Returns true if all checks succeed
*/
bool ConnectInputs(MapPrevTx inputs,
std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, bool fStrictPayToScriptHash=true);
bool ClientConnectInputs();
bool CheckTransaction() const; bool CheckTransaction() const;
bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
// Try to accept this transaction into the memory pool
bool AcceptToMemoryPool(CCoinsDB& coinsdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
protected: protected:
const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const; static CTxOut GetOutputFor(const CTxIn& input, CCoinsView& mapInputs);
}; };
/** wrapper for CTxOut that provides a more compact serialization */ /** wrapper for CTxOut that provides a more compact serialization */
@ -752,6 +662,7 @@ public:
class CTxUndo class CTxUndo
{ {
public: public:
// undo information for all txins
std::vector<CTxInUndo> vprevout; std::vector<CTxInUndo> vprevout;
IMPLEMENT_SERIALIZE( IMPLEMENT_SERIALIZE(
@ -763,7 +674,7 @@ public:
class CBlockUndo class CBlockUndo
{ {
public: public:
std::vector<CTxUndo> vtxundo; std::vector<CTxUndo> vtxundo; // for all but the coinbase
IMPLEMENT_SERIALIZE( IMPLEMENT_SERIALIZE(
READWRITE(vtxundo); READWRITE(vtxundo);
@ -789,7 +700,7 @@ public:
// Flush stdio buffers and commit to disk before returning // Flush stdio buffers and commit to disk before returning
fflush(fileout); fflush(fileout);
if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0) if (!IsInitialBlockDownload())
FileCommit(fileout); FileCommit(fileout);
return true; return true;
@ -1084,66 +995,16 @@ public:
int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); } int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
bool IsInMainChain() const { return GetDepthInMainChain() > 0; } bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
int GetBlocksToMaturity() const; int GetBlocksToMaturity() const;
bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true); bool AcceptToMemoryPool(CCoinsDB& coinsdb, bool fCheckInputs=true);
bool AcceptToMemoryPool(); bool AcceptToMemoryPool();
}; };
/** A txdb record that contains the disk location of a transaction and the
* locations of transactions that spend its outputs. vSpent is really only
* used as a flag, but having the location is very helpful for debugging.
*/
class CTxIndex
{
public:
CDiskTxPos pos;
std::vector<CDiskTxPos> vSpent;
CTxIndex()
{
SetNull();
}
CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
{
pos = posIn;
vSpent.resize(nOutputs);
}
IMPLEMENT_SERIALIZE
(
if (!(nType & SER_GETHASH))
READWRITE(nVersion);
READWRITE(pos);
READWRITE(vSpent);
)
void SetNull()
{
pos.SetNull();
vSpent.clear();
}
bool IsNull()
{
return pos.IsNull();
}
friend bool operator==(const CTxIndex& a, const CTxIndex& b)
{
return (a.pos == b.pos &&
a.vSpent == b.vSpent);
}
friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
{
return !(a == b);
}
int GetDepthInMainChain() const;
};
@ -1155,9 +1016,6 @@ public:
* to everyone and the block is added to the block chain. The first transaction * 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 * in the block is a special one that creates a new coin owned by the creator
* of the block. * of the block.
*
* Blocks are appended to blk0001.dat files on disk. Their location on disk
* is indexed by CBlockIndex objects in memory.
*/ */
class CBlock class CBlock
{ {
@ -1305,7 +1163,7 @@ public:
// Flush stdio buffers and commit to disk before returning // Flush stdio buffers and commit to disk before returning
fflush(fileout); fflush(fileout);
if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0) if (!IsInitialBlockDownload())
FileCommit(fileout); FileCommit(fileout);
return true; return true;
@ -1360,16 +1218,26 @@ public:
} }
bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex); // Undo the effects of this block (with given index) on the UTXO set represented by coins
bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false); bool DisconnectBlock(CBlockIndex *pindex, CCoinsView &coins);
bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
bool AddToBlockIndex(const CDiskBlockPos &pos);
bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true) const;
bool AcceptBlock();
private: // Apply the effects of this block (with given index) on the UTXO set represented by coins
bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew); bool ConnectBlock(CBlockIndex *pindex, CCoinsView &coins, bool fJustCheck=false);
// Read a block from disk
bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
// Make this block (with given index) the new tip of the active block chain
bool SetBestChain(CBlockIndex* pindexNew);
// Add this block to the block index, and if necessary, switch the active block chain to this
bool AddToBlockIndex(const CDiskBlockPos &pos);
// Context-independent validity checks
bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true) const;
// Store block on disk
bool AcceptBlock();
}; };
@ -1412,7 +1280,7 @@ public:
} }
std::string ToString() const { std::string ToString() const {
return strprintf("CBlockFileInfo(blocks=%u, size=%lu, heights=%u..%u, time=%s..%s)", nBlocks, nSize, nHeightFirst, nHeightLast, DateTimeStrFormat("%Y-%m-%d", nTimeFirst).c_str(), DateTimeStrFormat("%Y-%m-%d", nTimeLast).c_str()); 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());
} }
// update statistics (does not update nSize) // update statistics (does not update nSize)
@ -1466,7 +1334,7 @@ public:
pnext = NULL; pnext = NULL;
nHeight = 0; nHeight = 0;
pos.SetNull(); pos.SetNull();
nUndoPos = (unsigned int)(-1); nUndoPos = 0;
bnChainWork = 0; bnChainWork = 0;
nVersion = 0; nVersion = 0;
@ -1499,10 +1367,10 @@ public:
CDiskBlockPos GetUndoPos() const { CDiskBlockPos GetUndoPos() const {
CDiskBlockPos ret = pos; CDiskBlockPos ret = pos;
if (nUndoPos == (unsigned int)(-1)) if (nUndoPos == 0)
ret.SetNull(); ret.SetNull();
else else
ret.nPos = nUndoPos; ret.nPos = nUndoPos - 1;
return ret; return ret;
} }
@ -1604,18 +1472,13 @@ class CDiskBlockIndex : public CBlockIndex
{ {
public: public:
uint256 hashPrev; uint256 hashPrev;
uint256 hashNext;
CDiskBlockIndex() CDiskBlockIndex() {
{
hashPrev = 0; hashPrev = 0;
hashNext = 0;
} }
explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex) explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex) {
{
hashPrev = (pprev ? pprev->GetBlockHash() : 0); hashPrev = (pprev ? pprev->GetBlockHash() : 0);
hashNext = (pnext ? pnext->GetBlockHash() : 0);
} }
IMPLEMENT_SERIALIZE IMPLEMENT_SERIALIZE
@ -1623,7 +1486,6 @@ public:
if (!(nType & SER_GETHASH)) if (!(nType & SER_GETHASH))
READWRITE(nVersion); READWRITE(nVersion);
READWRITE(hashNext);
READWRITE(nHeight); READWRITE(nHeight);
READWRITE(pos); READWRITE(pos);
READWRITE(nUndoPos); READWRITE(nUndoPos);
@ -1654,10 +1516,9 @@ public:
{ {
std::string str = "CDiskBlockIndex("; std::string str = "CDiskBlockIndex(";
str += CBlockIndex::ToString(); str += CBlockIndex::ToString();
str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)", str += strprintf("\n hashBlock=%s, hashPrev=%s)",
GetBlockHash().ToString().c_str(), GetBlockHash().ToString().c_str(),
hashPrev.ToString().substr(0,20).c_str(), hashPrev.ToString().substr(0,20).c_str());
hashNext.ToString().substr(0,20).c_str());
return str; return str;
} }
@ -1815,12 +1676,13 @@ public:
std::map<uint256, CTransaction> mapTx; std::map<uint256, CTransaction> mapTx;
std::map<COutPoint, CInPoint> mapNextTx; std::map<COutPoint, CInPoint> mapNextTx;
bool accept(CTxDB& txdb, CTransaction &tx, bool accept(CCoinsDB& coinsdb, CTransaction &tx,
bool fCheckInputs, bool* pfMissingInputs); bool fCheckInputs, bool* pfMissingInputs);
bool addUnchecked(const uint256& hash, CTransaction &tx); bool addUnchecked(const uint256& hash, CTransaction &tx);
bool remove(CTransaction &tx); bool remove(CTransaction &tx);
void clear(); void clear();
void queryHashes(std::vector<uint256>& vtxid); void queryHashes(std::vector<uint256>& vtxid);
void pruneSpent(const uint256& hash, CCoins &coins);
unsigned long size() unsigned long size()
{ {
@ -1841,4 +1703,86 @@ public:
extern CTxMemPool mempool; extern CTxMemPool mempool;
/** 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);
};
/** 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);
};
/** CCoinsView backed by a CCoinsDB */
class CCoinsViewDB : public CCoinsView
{
protected:
CCoinsDB &db;
public:
CCoinsViewDB(CCoinsDB &dbIn);
bool GetCoins(uint256 txid, CCoins &coins);
bool SetCoins(uint256 txid, const CCoins &coins);
bool HaveCoins(uint256 txid);
CBlockIndex *GetBestBlock();
bool SetBestBlock(CBlockIndex *pindex);
};
/** 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);
bool GetCoins(uint256 txid, CCoins &coins);
bool SetCoins(uint256 txid, const CCoins &coins);
bool HaveCoins(uint256 txid);
CBlockIndex *GetBestBlock();
bool SetBestBlock(CBlockIndex *pindex);
bool Flush();
};
/** 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);
};
#endif #endif

7
src/qt/transactiondesc.cpp
View File

@ -234,7 +234,8 @@ QString TransactionDesc::toHTML(CWallet *wallet, CWalletTx &wtx)
strHTML += "<br><b>" + tr("Transaction") + ":</b><br>"; strHTML += "<br><b>" + tr("Transaction") + ":</b><br>";
strHTML += GUIUtil::HtmlEscape(wtx.ToString(), true); strHTML += GUIUtil::HtmlEscape(wtx.ToString(), true);
CTxDB txdb("r"); // To fetch source txouts CCoinsDB coindb("r"); // To fetch source txouts
CCoinsViewDB coins(coindb);
strHTML += "<br><b>" + tr("Inputs") + ":</b>"; strHTML += "<br><b>" + tr("Inputs") + ":</b>";
strHTML += "<ul>"; strHTML += "<ul>";
@ -245,8 +246,8 @@ QString TransactionDesc::toHTML(CWallet *wallet, CWalletTx &wtx)
{ {
COutPoint prevout = txin.prevout; COutPoint prevout = txin.prevout;
CTransaction prev; CCoins prev;
if(txdb.ReadDiskTx(prevout.hash, prev)) if(coins.GetCoins(prevout.hash, prev))
{ {
if (prevout.n < prev.vout.size()) if (prevout.n < prev.vout.size())
{ {

43
src/rpcmining.cpp
View File

@ -198,7 +198,7 @@ Value getwork(const Array& params, bool fHelp)
Value getblocktemplate(const Array& params, bool fHelp) Value getblocktemplate(const Array& params, bool fHelp)
{ {
if (fHelp || params.size() > 1) if (fHelp || params.size() != 1)
throw runtime_error( throw runtime_error(
"getblocktemplate [params]\n" "getblocktemplate [params]\n"
"Returns data needed to construct a block to work on:\n" "Returns data needed to construct a block to work on:\n"
@ -281,7 +281,9 @@ Value getblocktemplate(const Array& params, bool fHelp)
Array transactions; Array transactions;
map<uint256, int64_t> setTxIndex; map<uint256, int64_t> setTxIndex;
int i = 0; int i = 0;
CTxDB txdb("r"); CCoinsDB coindb("r");
CCoinsViewDB viewdb(coindb);
CCoinsViewCache view(viewdb);
BOOST_FOREACH (CTransaction& tx, pblock->vtx) BOOST_FOREACH (CTransaction& tx, pblock->vtx)
{ {
uint256 txHash = tx.GetHash(); uint256 txHash = tx.GetHash();
@ -298,25 +300,21 @@ Value getblocktemplate(const Array& params, bool fHelp)
entry.push_back(Pair("hash", txHash.GetHex())); entry.push_back(Pair("hash", txHash.GetHex()));
MapPrevTx mapInputs; Array deps;
map<uint256, CTxIndex> mapUnused; BOOST_FOREACH (const CTxIn &in, tx.vin)
bool fInvalid = false;
if (tx.FetchInputs(txdb, mapUnused, false, false, mapInputs, fInvalid))
{ {
entry.push_back(Pair("fee", (int64_t)(tx.GetValueIn(mapInputs) - tx.GetValueOut()))); if (setTxIndex.count(in.prevout.hash))
deps.push_back(setTxIndex[in.prevout.hash]);
Array deps;
BOOST_FOREACH (MapPrevTx::value_type& inp, mapInputs)
{
if (setTxIndex.count(inp.first))
deps.push_back(setTxIndex[inp.first]);
}
entry.push_back(Pair("depends", deps));
int64_t nSigOps = tx.GetLegacySigOpCount();
nSigOps += tx.GetP2SHSigOpCount(mapInputs);
entry.push_back(Pair("sigops", nSigOps));
} }
entry.push_back(Pair("depends", deps));
int64_t nSigOps = tx.GetLegacySigOpCount();
if (tx.HaveInputs(view))
{
entry.push_back(Pair("fee", (int64_t)(tx.GetValueIn(view) - tx.GetValueOut())));
nSigOps += tx.GetP2SHSigOpCount(view);
}
entry.push_back(Pair("sigops", nSigOps));
transactions.push_back(entry); transactions.push_back(entry);
} }
@ -364,18 +362,17 @@ Value submitblock(const Array& params, bool fHelp)
vector<unsigned char> blockData(ParseHex(params[0].get_str())); vector<unsigned char> blockData(ParseHex(params[0].get_str()));
CDataStream ssBlock(blockData, SER_NETWORK, PROTOCOL_VERSION); CDataStream ssBlock(blockData, SER_NETWORK, PROTOCOL_VERSION);
CBlock block; CBlock pblock;
try { try {
ssBlock >> block; ssBlock >> pblock;
} }
catch (std::exception &e) { catch (std::exception &e) {
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed"); throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed");
} }
bool fAccepted = ProcessBlock(NULL, &block); bool fAccepted = ProcessBlock(NULL, &pblock);
if (!fAccepted) if (!fAccepted)
return "rejected"; return "rejected";
return Value::null; return Value::null;
} }

85
src/rpcrawtransaction.cpp
View File

@ -118,7 +118,7 @@ Value getrawtransaction(const Array& params, bool fHelp)
CTransaction tx; CTransaction tx;
uint256 hashBlock = 0; uint256 hashBlock = 0;
if (!GetTransaction(hash, tx, hashBlock)) if (!GetTransaction(hash, tx, hashBlock, true))
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available about transaction"); throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available about transaction");
CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION); CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
@ -335,26 +335,22 @@ Value signrawtransaction(const Array& params, bool fHelp)
bool fComplete = true; bool fComplete = true;
// Fetch previous transactions (inputs): // Fetch previous transactions (inputs):
map<COutPoint, CScript> mapPrevOut; CCoinsView viewDummy;
for (unsigned int i = 0; i < mergedTx.vin.size(); i++) CCoinsViewCache view(viewDummy);
{ {
CTransaction tempTx; LOCK(mempool.cs);
MapPrevTx mapPrevTx; CCoinsDB coinsdb("r");
CTxDB txdb("r"); CCoinsViewDB viewDB(coinsdb);
map<uint256, CTxIndex> unused; CCoinsViewMemPool viewMempool(viewDB, mempool);
bool fInvalid; view.SetBackend(viewMempool); // temporarily switch cache backend to db+mempool view
// FetchInputs aborts on failure, so we go one at a time. BOOST_FOREACH(const CTxIn& txin, mergedTx.vin) {
tempTx.vin.push_back(mergedTx.vin[i]);
tempTx.FetchInputs(txdb, unused, false, false, mapPrevTx, fInvalid);
// Copy results into mapPrevOut:
BOOST_FOREACH(const CTxIn& txin, tempTx.vin)
{
const uint256& prevHash = txin.prevout.hash; const uint256& prevHash = txin.prevout.hash;
if (mapPrevTx.count(prevHash) && mapPrevTx[prevHash].second.vout.size()>txin.prevout.n) CCoins coins;
mapPrevOut[txin.prevout] = mapPrevTx[prevHash].second.vout[txin.prevout.n].scriptPubKey; view.GetCoins(prevHash, coins); // this is certainly allowed to fail
} }
view.SetBackend(viewDummy); // switch back to avoid locking db/mempool too long
} }
// Add previous txouts given in the RPC call: // Add previous txouts given in the RPC call:
@ -386,20 +382,19 @@ Value signrawtransaction(const Array& params, bool fHelp)
vector<unsigned char> pkData(ParseHex(pkHex)); vector<unsigned char> pkData(ParseHex(pkHex));
CScript scriptPubKey(pkData.begin(), pkData.end()); CScript scriptPubKey(pkData.begin(), pkData.end());
COutPoint outpoint(txid, nOut); CCoins coins;
if (mapPrevOut.count(outpoint)) if (view.GetCoins(txid, coins)) {
{ if (coins.IsAvailable(nOut) && coins.vout[nOut].scriptPubKey != scriptPubKey) {
// Complain if scriptPubKey doesn't match
if (mapPrevOut[outpoint] != scriptPubKey)
{
string err("Previous output scriptPubKey mismatch:\n"); string err("Previous output scriptPubKey mismatch:\n");
err = err + mapPrevOut[outpoint].ToString() + "\nvs:\n"+ err = err + coins.vout[nOut].scriptPubKey.ToString() + "\nvs:\n"+
scriptPubKey.ToString(); scriptPubKey.ToString();
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, err); throw JSONRPCError(RPC_DESERIALIZATION_ERROR, err);
} }
// what todo if txid is known, but the actual output isn't?
} }
else coins.vout[nOut].scriptPubKey = scriptPubKey;
mapPrevOut[outpoint] = scriptPubKey; coins.vout[nOut].nValue = 0; // we don't know the actual output value
view.SetCoins(txid, coins);
} }
} }
@ -452,12 +447,13 @@ Value signrawtransaction(const Array& params, bool fHelp)
for (unsigned int i = 0; i < mergedTx.vin.size(); i++) for (unsigned int i = 0; i < mergedTx.vin.size(); i++)
{ {
CTxIn& txin = mergedTx.vin[i]; CTxIn& txin = mergedTx.vin[i];
if (mapPrevOut.count(txin.prevout) == 0) CCoins coins;
if (!view.GetCoins(txin.prevout.hash, coins) || !coins.IsAvailable(txin.prevout.n))
{ {
fComplete = false; fComplete = false;
continue; continue;
} }
const CScript& prevPubKey = mapPrevOut[txin.prevout]; const CScript& prevPubKey = coins.vout[txin.prevout.n].scriptPubKey;
txin.scriptSig.clear(); txin.scriptSig.clear();
// Only sign SIGHASH_SINGLE if there's a corresponding output: // Only sign SIGHASH_SINGLE if there's a corresponding output:
@ -505,24 +501,27 @@ Value sendrawtransaction(const Array& params, bool fHelp)
} }
uint256 hashTx = tx.GetHash(); uint256 hashTx = tx.GetHash();
// See if the transaction is already in a block bool fHave = false;
// or in the memory pool: CCoins existingCoins;
CTransaction existingTx;
uint256 hashBlock = 0;
if (GetTransaction(hashTx, existingTx, hashBlock))
{ {
if (hashBlock != 0) CCoinsDB coinsdb("r");
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, string("transaction already in block ")+hashBlock.GetHex()); {
CCoinsViewDB coinsviewDB(coinsdb);
CCoinsViewMemPool coinsview(coinsviewDB, mempool);
fHave = coinsview.GetCoins(hashTx, existingCoins);
}
if (!fHave) {
// push to local node
if (!tx.AcceptToMemoryPool(coinsdb))
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX rejected");
}
}
if (fHave) {
if (existingCoins.nHeight < 1000000000)
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "transaction already in block chain");
// Not in block, but already in the memory pool; will drop // Not in block, but already in the memory pool; will drop
// through to re-relay it. // through to re-relay it.
} } else {
else
{
// push to local node
CTxDB txdb("r");
if (!tx.AcceptToMemoryPool(txdb))
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX rejected");
SyncWithWallets(tx, NULL, true); SyncWithWallets(tx, NULL, true);
} }
RelayMessage(CInv(MSG_TX, hashTx), tx); RelayMessage(CInv(MSG_TX, hashTx), tx);

5
src/script.cpp
View File

@ -1719,7 +1719,7 @@ bool SignSignature(const CKeyStore &keystore, const CTransaction& txFrom, CTrans
return SignSignature(keystore, txout.scriptPubKey, txTo, nIn, nHashType); return SignSignature(keystore, txout.scriptPubKey, txTo, nIn, nHashType);
} }
bool VerifySignature(const CTransaction& txFrom, const CTransaction& txTo, unsigned int nIn, bool fValidatePayToScriptHash, bool fStrictEncodings, int nHashType) bool VerifySignature(const CCoins& txFrom, const CTransaction& txTo, unsigned int nIn, bool fValidatePayToScriptHash, bool fStrictEncodings, int nHashType)
{ {
assert(nIn < txTo.vin.size()); assert(nIn < txTo.vin.size());
const CTxIn& txin = txTo.vin[nIn]; const CTxIn& txin = txTo.vin[nIn];
@ -1727,9 +1727,6 @@ bool VerifySignature(const CTransaction& txFrom, const CTransaction& txTo, unsig
return false; return false;
const CTxOut& txout = txFrom.vout[txin.prevout.n]; const CTxOut& txout = txFrom.vout[txin.prevout.n];
if (txin.prevout.hash != txFrom.GetHash())
return false;
return VerifyScript(txin.scriptSig, txout.scriptPubKey, txTo, nIn, fValidatePayToScriptHash, fStrictEncodings, nHashType); return VerifyScript(txin.scriptSig, txout.scriptPubKey, txTo, nIn, fValidatePayToScriptHash, fStrictEncodings, nHashType);
} }

3
src/script.h
View File

@ -14,6 +14,7 @@
#include "keystore.h" #include "keystore.h"
#include "bignum.h" #include "bignum.h"
class CCoins;
class CTransaction; class CTransaction;
/** Signature hash types/flags */ /** Signature hash types/flags */
@ -667,7 +668,7 @@ bool SignSignature(const CKeyStore& keystore, const CScript& fromPubKey, CTransa
bool SignSignature(const CKeyStore& keystore, const CTransaction& txFrom, CTransaction& txTo, unsigned int nIn, int nHashType=SIGHASH_ALL); bool SignSignature(const CKeyStore& keystore, const CTransaction& txFrom, CTransaction& txTo, unsigned int nIn, int nHashType=SIGHASH_ALL);
bool VerifyScript(const CScript& scriptSig, const CScript& scriptPubKey, const CTransaction& txTo, unsigned int nIn, bool VerifyScript(const CScript& scriptSig, const CScript& scriptPubKey, const CTransaction& txTo, unsigned int nIn,
bool fValidatePayToScriptHash, bool fStrictEncodings, int nHashType); bool fValidatePayToScriptHash, bool fStrictEncodings, int nHashType);
bool VerifySignature(const CTransaction& txFrom, const CTransaction& txTo, unsigned int nIn, bool fValidatePayToScriptHash, bool fStrictEncodings, int nHashType); bool VerifySignature(const CCoins& txFrom, const CTransaction& txTo, unsigned int nIn, bool fValidatePayToScriptHash, bool fStrictEncodings, int nHashType);
// Given two sets of signatures for scriptPubKey, possibly with OP_0 placeholders, // Given two sets of signatures for scriptPubKey, possibly with OP_0 placeholders,
// combine them intelligently and return the result. // combine them intelligently and return the result.

10
src/test/DoS_tests.cpp
View File

@ -278,7 +278,7 @@ BOOST_AUTO_TEST_CASE(DoS_checkSig)
mst1 = boost::posix_time::microsec_clock::local_time(); mst1 = boost::posix_time::microsec_clock::local_time();
for (unsigned int i = 0; i < 5; i++) for (unsigned int i = 0; i < 5; i++)
for (unsigned int j = 0; j < tx.vin.size(); j++) for (unsigned int j = 0; j < tx.vin.size(); j++)
BOOST_CHECK(VerifySignature(orphans[j], tx, j, true, true, SIGHASH_ALL)); BOOST_CHECK(VerifySignature(CCoins(orphans[j], MEMPOOL_HEIGHT), tx, j, true, true, SIGHASH_ALL));
mst2 = boost::posix_time::microsec_clock::local_time(); mst2 = boost::posix_time::microsec_clock::local_time();
msdiff = mst2 - mst1; msdiff = mst2 - mst1;
long nManyValidate = msdiff.total_milliseconds(); long nManyValidate = msdiff.total_milliseconds();
@ -289,13 +289,13 @@ BOOST_AUTO_TEST_CASE(DoS_checkSig)
// Empty a signature, validation should fail: // Empty a signature, validation should fail:
CScript save = tx.vin[0].scriptSig; CScript save = tx.vin[0].scriptSig;
tx.vin[0].scriptSig = CScript(); tx.vin[0].scriptSig = CScript();
BOOST_CHECK(!VerifySignature(orphans[0], tx, 0, true, true, SIGHASH_ALL)); BOOST_CHECK(!VerifySignature(CCoins(orphans[0], MEMPOOL_HEIGHT), tx, 0, true, true, SIGHASH_ALL));
tx.vin[0].scriptSig = save; tx.vin[0].scriptSig = save;
// Swap signatures, validation should fail: // Swap signatures, validation should fail:
std::swap(tx.vin[0].scriptSig, tx.vin[1].scriptSig); std::swap(tx.vin[0].scriptSig, tx.vin[1].scriptSig);
BOOST_CHECK(!VerifySignature(orphans[0], tx, 0, true, true, SIGHASH_ALL)); BOOST_CHECK(!VerifySignature(CCoins(orphans[0], MEMPOOL_HEIGHT), tx, 0, true, true, SIGHASH_ALL));
BOOST_CHECK(!VerifySignature(orphans[1], tx, 1, true, true, SIGHASH_ALL)); BOOST_CHECK(!VerifySignature(CCoins(orphans[1], MEMPOOL_HEIGHT), tx, 1, true, true, SIGHASH_ALL));
std::swap(tx.vin[0].scriptSig, tx.vin[1].scriptSig); std::swap(tx.vin[0].scriptSig, tx.vin[1].scriptSig);
// Exercise -maxsigcachesize code: // Exercise -maxsigcachesize code:
@ -305,7 +305,7 @@ BOOST_AUTO_TEST_CASE(DoS_checkSig)
BOOST_CHECK(SignSignature(keystore, orphans[0], tx, 0)); BOOST_CHECK(SignSignature(keystore, orphans[0], tx, 0));
BOOST_CHECK(tx.vin[0].scriptSig != oldSig); BOOST_CHECK(tx.vin[0].scriptSig != oldSig);
for (unsigned int j = 0; j < tx.vin.size(); j++) for (unsigned int j = 0; j < tx.vin.size(); j++)
BOOST_CHECK(VerifySignature(orphans[j], tx, j, true, true, SIGHASH_ALL)); BOOST_CHECK(VerifySignature(CCoins(orphans[j], MEMPOOL_HEIGHT), tx, j, true, true, SIGHASH_ALL));
mapArgs.erase("-maxsigcachesize"); mapArgs.erase("-maxsigcachesize");
LimitOrphanTxSize(0); LimitOrphanTxSize(0);

26
src/test/script_P2SH_tests.cpp
View File

@ -105,7 +105,7 @@ BOOST_AUTO_TEST_CASE(sign)
{ {
CScript sigSave = txTo[i].vin[0].scriptSig; CScript sigSave = txTo[i].vin[0].scriptSig;
txTo[i].vin[0].scriptSig = txTo[j].vin[0].scriptSig; txTo[i].vin[0].scriptSig = txTo[j].vin[0].scriptSig;
bool sigOK = VerifySignature(txFrom, txTo[i], 0, true, true, 0); bool sigOK = VerifySignature(CCoins(txFrom, 0), txTo[i], 0, true, true, 0);
if (i == j) if (i == j)
BOOST_CHECK_MESSAGE(sigOK, strprintf("VerifySignature %d %d", i, j)); BOOST_CHECK_MESSAGE(sigOK, strprintf("VerifySignature %d %d", i, j));
else else
@ -243,7 +243,8 @@ BOOST_AUTO_TEST_CASE(switchover)
BOOST_AUTO_TEST_CASE(AreInputsStandard) BOOST_AUTO_TEST_CASE(AreInputsStandard)
{ {
std::map<uint256, std::pair<CTxIndex, CTransaction> > mapInputs; CCoinsView coinsDummy;
CCoinsViewCache coins(coinsDummy);
CBasicKeyStore keystore; CBasicKeyStore keystore;
CKey key[3]; CKey key[3];
vector<CKey> keys; vector<CKey> keys;
@ -264,23 +265,29 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
CScript pay1of3; pay1of3.SetMultisig(1, keys); CScript pay1of3; pay1of3.SetMultisig(1, keys);
txFrom.vout[0].scriptPubKey = payScriptHash1; txFrom.vout[0].scriptPubKey = payScriptHash1;
txFrom.vout[0].nValue = 1000;
txFrom.vout[1].scriptPubKey = pay1; txFrom.vout[1].scriptPubKey = pay1;
txFrom.vout[1].nValue = 2000;
txFrom.vout[2].scriptPubKey = pay1of3; txFrom.vout[2].scriptPubKey = pay1of3;
txFrom.vout[2].nValue = 3000;
// Last three non-standard: // Last three non-standard:
CScript empty; CScript empty;
keystore.AddCScript(empty); keystore.AddCScript(empty);
txFrom.vout[3].scriptPubKey = empty; txFrom.vout[3].scriptPubKey = empty;
txFrom.vout[3].nValue = 4000;
// Can't use SetPayToScriptHash, it checks for the empty Script. So: // Can't use SetPayToScriptHash, it checks for the empty Script. So:
txFrom.vout[4].scriptPubKey << OP_HASH160 << Hash160(empty) << OP_EQUAL; txFrom.vout[4].scriptPubKey << OP_HASH160 << Hash160(empty) << OP_EQUAL;
txFrom.vout[4].nValue = 5000;
CScript oneOfEleven; CScript oneOfEleven;
oneOfEleven << OP_1; oneOfEleven << OP_1;
for (int i = 0; i < 11; i++) for (int i = 0; i < 11; i++)
oneOfEleven << key[0].GetPubKey(); oneOfEleven << key[0].GetPubKey();
oneOfEleven << OP_11 << OP_CHECKMULTISIG; oneOfEleven << OP_11 << OP_CHECKMULTISIG;
txFrom.vout[5].scriptPubKey.SetDestination(oneOfEleven.GetID()); txFrom.vout[5].scriptPubKey.SetDestination(oneOfEleven.GetID());
txFrom.vout[5].nValue = 6000;
mapInputs[txFrom.GetHash()] = make_pair(CTxIndex(), txFrom); coins.SetCoins(txFrom.GetHash(), CCoins(txFrom, 0));
CTransaction txTo; CTransaction txTo;
txTo.vout.resize(1); txTo.vout.resize(1);
@ -297,21 +304,22 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
txTo.vin[2].prevout.hash = txFrom.GetHash(); txTo.vin[2].prevout.hash = txFrom.GetHash();
BOOST_CHECK(SignSignature(keystore, txFrom, txTo, 2)); BOOST_CHECK(SignSignature(keystore, txFrom, txTo, 2));
BOOST_CHECK(txTo.AreInputsStandard(mapInputs)); BOOST_CHECK(txTo.AreInputsStandard(coins));
BOOST_CHECK_EQUAL(txTo.GetP2SHSigOpCount(mapInputs), 1); BOOST_CHECK_EQUAL(txTo.GetP2SHSigOpCount(coins), 1);
// Make sure adding crap to the scriptSigs makes them non-standard: // Make sure adding crap to the scriptSigs makes them non-standard:
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
{ {
CScript t = txTo.vin[i].scriptSig; CScript t = txTo.vin[i].scriptSig;
txTo.vin[i].scriptSig = (CScript() << 11) + t; txTo.vin[i].scriptSig = (CScript() << 11) + t;
BOOST_CHECK(!txTo.AreInputsStandard(mapInputs)); BOOST_CHECK(!txTo.AreInputsStandard(coins));
txTo.vin[i].scriptSig = t; txTo.vin[i].scriptSig = t;
} }
CTransaction txToNonStd; CTransaction txToNonStd;
txToNonStd.vout.resize(1); txToNonStd.vout.resize(1);
txToNonStd.vout[0].scriptPubKey.SetDestination(key[1].GetPubKey().GetID()); txToNonStd.vout[0].scriptPubKey.SetDestination(key[1].GetPubKey().GetID());
txToNonStd.vout[0].nValue = 1000;
txToNonStd.vin.resize(2); txToNonStd.vin.resize(2);
txToNonStd.vin[0].prevout.n = 4; txToNonStd.vin[0].prevout.n = 4;
txToNonStd.vin[0].prevout.hash = txFrom.GetHash(); txToNonStd.vin[0].prevout.hash = txFrom.GetHash();
@ -320,11 +328,11 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
txToNonStd.vin[1].prevout.hash = txFrom.GetHash(); txToNonStd.vin[1].prevout.hash = txFrom.GetHash();
txToNonStd.vin[1].scriptSig << OP_0 << Serialize(oneOfEleven); txToNonStd.vin[1].scriptSig << OP_0 << Serialize(oneOfEleven);
BOOST_CHECK(!txToNonStd.AreInputsStandard(mapInputs)); BOOST_CHECK(!txToNonStd.AreInputsStandard(coins));
BOOST_CHECK_EQUAL(txToNonStd.GetP2SHSigOpCount(mapInputs), 11); BOOST_CHECK_EQUAL(txToNonStd.GetP2SHSigOpCount(coins), 11);
txToNonStd.vin[0].scriptSig.clear(); txToNonStd.vin[0].scriptSig.clear();
BOOST_CHECK(!txToNonStd.AreInputsStandard(mapInputs)); BOOST_CHECK(!txToNonStd.AreInputsStandard(coins));
} }
BOOST_AUTO_TEST_SUITE_END() BOOST_AUTO_TEST_SUITE_END()

30
src/test/transaction_tests.cpp
View File

@ -173,7 +173,7 @@ BOOST_AUTO_TEST_CASE(basic_transaction_tests)
// paid to a TX_PUBKEYHASH. // paid to a TX_PUBKEYHASH.
// //
static std::vector<CTransaction> static std::vector<CTransaction>
SetupDummyInputs(CBasicKeyStore& keystoreRet, MapPrevTx& inputsRet) SetupDummyInputs(CBasicKeyStore& keystoreRet, CCoinsView & coinsRet)
{ {
std::vector<CTransaction> dummyTransactions; std::vector<CTransaction> dummyTransactions;
dummyTransactions.resize(2); dummyTransactions.resize(2);
@ -192,14 +192,14 @@ SetupDummyInputs(CBasicKeyStore& keystoreRet, MapPrevTx& inputsRet)
dummyTransactions[0].vout[0].scriptPubKey << key[0].GetPubKey() << OP_CHECKSIG; dummyTransactions[0].vout[0].scriptPubKey << key[0].GetPubKey() << OP_CHECKSIG;
dummyTransactions[0].vout[1].nValue = 50*CENT; dummyTransactions[0].vout[1].nValue = 50*CENT;
dummyTransactions[0].vout[1].scriptPubKey << key[1].GetPubKey() << OP_CHECKSIG; dummyTransactions[0].vout[1].scriptPubKey << key[1].GetPubKey() << OP_CHECKSIG;
inputsRet[dummyTransactions[0].GetHash()] = make_pair(CTxIndex(), dummyTransactions[0]); coinsRet.SetCoins(dummyTransactions[0].GetHash(), CCoins(dummyTransactions[0], 0));
dummyTransactions[1].vout.resize(2); dummyTransactions[1].vout.resize(2);
dummyTransactions[1].vout[0].nValue = 21*CENT; dummyTransactions[1].vout[0].nValue = 21*CENT;
dummyTransactions[1].vout[0].scriptPubKey.SetDestination(key[2].GetPubKey().GetID()); dummyTransactions[1].vout[0].scriptPubKey.SetDestination(key[2].GetPubKey().GetID());
dummyTransactions[1].vout[1].nValue = 22*CENT; dummyTransactions[1].vout[1].nValue = 22*CENT;
dummyTransactions[1].vout[1].scriptPubKey.SetDestination(key[3].GetPubKey().GetID()); dummyTransactions[1].vout[1].scriptPubKey.SetDestination(key[3].GetPubKey().GetID());
inputsRet[dummyTransactions[1].GetHash()] = make_pair(CTxIndex(), dummyTransactions[1]); coinsRet.SetCoins(dummyTransactions[1].GetHash(), CCoins(dummyTransactions[1], 0));
return dummyTransactions; return dummyTransactions;
} }
@ -207,8 +207,9 @@ SetupDummyInputs(CBasicKeyStore& keystoreRet, MapPrevTx& inputsRet)
BOOST_AUTO_TEST_CASE(test_Get) BOOST_AUTO_TEST_CASE(test_Get)
{ {
CBasicKeyStore keystore; CBasicKeyStore keystore;
MapPrevTx dummyInputs; CCoinsView coinsDummy;
std::vector<CTransaction> dummyTransactions = SetupDummyInputs(keystore, dummyInputs); CCoinsViewCache coins(coinsDummy);
std::vector<CTransaction> dummyTransactions = SetupDummyInputs(keystore, coins);
CTransaction t1; CTransaction t1;
t1.vin.resize(3); t1.vin.resize(3);
@ -225,25 +226,24 @@ BOOST_AUTO_TEST_CASE(test_Get)
t1.vout[0].nValue = 90*CENT; t1.vout[0].nValue = 90*CENT;
t1.vout[0].scriptPubKey << OP_1; t1.vout[0].scriptPubKey << OP_1;
BOOST_CHECK(t1.AreInputsStandard(dummyInputs)); BOOST_CHECK(t1.AreInputsStandard(coins));
BOOST_CHECK_EQUAL(t1.GetValueIn(dummyInputs), (50+21+22)*CENT); BOOST_CHECK_EQUAL(t1.GetValueIn(coins), (50+21+22)*CENT);
// Adding extra junk to the scriptSig should make it non-standard: // Adding extra junk to the scriptSig should make it non-standard:
t1.vin[0].scriptSig << OP_11; t1.vin[0].scriptSig << OP_11;
BOOST_CHECK(!t1.AreInputsStandard(dummyInputs)); BOOST_CHECK(!t1.AreInputsStandard(coins));
// ... as should not having enough: // ... as should not having enough:
t1.vin[0].scriptSig = CScript(); t1.vin[0].scriptSig = CScript();
BOOST_CHECK(!t1.AreInputsStandard(dummyInputs)); BOOST_CHECK(!t1.AreInputsStandard(coins));
} }
BOOST_AUTO_TEST_CASE(test_GetThrow) BOOST_AUTO_TEST_CASE(test_GetThrow)
{ {
CBasicKeyStore keystore; CBasicKeyStore keystore;
MapPrevTx dummyInputs; CCoinsView coinsDummy;
std::vector<CTransaction> dummyTransactions = SetupDummyInputs(keystore, dummyInputs); CCoinsViewCache coins(coinsDummy);
std::vector<CTransaction> dummyTransactions = SetupDummyInputs(keystore, coins);
MapPrevTx missingInputs;
CTransaction t1; CTransaction t1;
t1.vin.resize(3); t1.vin.resize(3);
@ -257,8 +257,8 @@ BOOST_AUTO_TEST_CASE(test_GetThrow)
t1.vout[0].nValue = 90*CENT; t1.vout[0].nValue = 90*CENT;
t1.vout[0].scriptPubKey << OP_1; t1.vout[0].scriptPubKey << OP_1;
BOOST_CHECK_THROW(t1.AreInputsStandard(missingInputs), runtime_error); BOOST_CHECK_THROW(t1.AreInputsStandard(coinsDummy), runtime_error);
BOOST_CHECK_THROW(t1.GetValueIn(missingInputs), runtime_error); BOOST_CHECK_THROW(t1.GetValueIn(coinsDummy), runtime_error);
} }
BOOST_AUTO_TEST_SUITE_END() BOOST_AUTO_TEST_SUITE_END()

63
src/wallet.cpp
View File

@ -685,7 +685,7 @@ void CWalletTx::GetAccountAmounts(const string& strAccount, int64& nReceived,
} }
} }
void CWalletTx::AddSupportingTransactions(CTxDB& txdb) void CWalletTx::AddSupportingTransactions()
{ {
vtxPrev.clear(); vtxPrev.clear();
@ -696,7 +696,6 @@ void CWalletTx::AddSupportingTransactions(CTxDB& txdb)
BOOST_FOREACH(const CTxIn& txin, vin) BOOST_FOREACH(const CTxIn& txin, vin)
vWorkQueue.push_back(txin.prevout.hash); vWorkQueue.push_back(txin.prevout.hash);
// This critsect is OK because txdb is already open
{ {
LOCK(pwallet->cs_wallet); LOCK(pwallet->cs_wallet);
map<uint256, const CMerkleTx*> mapWalletPrev; map<uint256, const CMerkleTx*> mapWalletPrev;
@ -720,15 +719,6 @@ void CWalletTx::AddSupportingTransactions(CTxDB& txdb)
{ {
tx = *mapWalletPrev[hash]; tx = *mapWalletPrev[hash];
} }
else if (!fClient && txdb.ReadDiskTx(hash, tx))
{
;
}
else
{
printf("ERROR: AddSupportingTransactions() : unsupported transaction\n");
continue;
}
int nDepth = tx.SetMerkleBranch(); int nDepth = tx.SetMerkleBranch();
vtxPrev.push_back(tx); vtxPrev.push_back(tx);
@ -775,49 +765,36 @@ int CWallet::ScanForWalletTransactions(CBlockIndex* pindexStart, bool fUpdate)
return ret; return ret;
} }
int CWallet::ScanForWalletTransaction(const uint256& hashTx)
{
CTransaction tx;
tx.ReadFromDisk(COutPoint(hashTx, 0));
if (AddToWalletIfInvolvingMe(tx, NULL, true, true))
return 1;
return 0;
}
void CWallet::ReacceptWalletTransactions() void CWallet::ReacceptWalletTransactions()
{ {
CTxDB txdb("r"); CCoinsDB coinsdb("r");
bool fRepeat = true; bool fRepeat = true;
while (fRepeat) while (fRepeat)
{ {
LOCK(cs_wallet); LOCK(cs_wallet);
fRepeat = false; fRepeat = false;
vector<CDiskTxPos> vMissingTx; bool fMissing = false;
BOOST_FOREACH(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet) BOOST_FOREACH(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet)
{ {
CWalletTx& wtx = item.second; CWalletTx& wtx = item.second;
if (wtx.IsCoinBase() && wtx.IsSpent(0)) if (wtx.IsCoinBase() && wtx.IsSpent(0))
continue; continue;
CTxIndex txindex; CCoins coins;
bool fUpdated = false; bool fUpdated = false;
if (txdb.ReadTxIndex(wtx.GetHash(), txindex)) bool fNotFound = coinsdb.ReadCoins(wtx.GetHash(), coins);
if (!fNotFound || wtx.GetDepthInMainChain() > 0)
{ {
// Update fSpent if a tx got spent somewhere else by a copy of wallet.dat // Update fSpent if a tx got spent somewhere else by a copy of wallet.dat
if (txindex.vSpent.size() != wtx.vout.size()) for (unsigned int i = 0; i < wtx.vout.size(); i++)
{
printf("ERROR: ReacceptWalletTransactions() : txindex.vSpent.size() %"PRIszu" != wtx.vout.size() %"PRIszu"\n", txindex.vSpent.size(), wtx.vout.size());
continue;
}
for (unsigned int i = 0; i < txindex.vSpent.size(); i++)
{ {
if (wtx.IsSpent(i)) if (wtx.IsSpent(i))
continue; continue;
if (!txindex.vSpent[i].IsNull() && IsMine(wtx.vout[i])) if ((i >= coins.vout.size() || coins.vout[i].IsNull()) && IsMine(wtx.vout[i]))
{ {
wtx.MarkSpent(i); wtx.MarkSpent(i);
fUpdated = true; fUpdated = true;
vMissingTx.push_back(txindex.vSpent[i]); fMissing = true;
} }
} }
if (fUpdated) if (fUpdated)
@ -831,10 +808,10 @@ void CWallet::ReacceptWalletTransactions()
{ {
// Re-accept any txes of ours that aren't already in a block // Re-accept any txes of ours that aren't already in a block
if (!wtx.IsCoinBase()) if (!wtx.IsCoinBase())
wtx.AcceptWalletTransaction(txdb, false); wtx.AcceptWalletTransaction(coinsdb, false);
} }
} }
if (!vMissingTx.empty()) if (fMissing)
{ {
// TODO: optimize this to scan just part of the block chain? // TODO: optimize this to scan just part of the block chain?
if (ScanForWalletTransactions(pindexGenesisBlock)) if (ScanForWalletTransactions(pindexGenesisBlock))
@ -843,21 +820,21 @@ void CWallet::ReacceptWalletTransactions()
} }
} }
void CWalletTx::RelayWalletTransaction(CTxDB& txdb) void CWalletTx::RelayWalletTransaction(CCoinsDB& coinsdb)
{ {
BOOST_FOREACH(const CMerkleTx& tx, vtxPrev) BOOST_FOREACH(const CMerkleTx& tx, vtxPrev)
{ {
if (!tx.IsCoinBase()) if (!tx.IsCoinBase())
{ {
uint256 hash = tx.GetHash(); uint256 hash = tx.GetHash();
if (!txdb.ContainsTx(hash)) if (!coinsdb.HaveCoins(hash))
RelayMessage(CInv(MSG_TX, hash), (CTransaction)tx); RelayMessage(CInv(MSG_TX, hash), (CTransaction)tx);
} }
} }
if (!IsCoinBase()) if (!IsCoinBase())
{ {
uint256 hash = GetHash(); uint256 hash = GetHash();
if (!txdb.ContainsTx(hash)) if (!coinsdb.HaveCoins(hash))
{ {
printf("Relaying wtx %s\n", hash.ToString().substr(0,10).c_str()); printf("Relaying wtx %s\n", hash.ToString().substr(0,10).c_str());
RelayMessage(CInv(MSG_TX, hash), (CTransaction)*this); RelayMessage(CInv(MSG_TX, hash), (CTransaction)*this);
@ -867,8 +844,8 @@ void CWalletTx::RelayWalletTransaction(CTxDB& txdb)
void CWalletTx::RelayWalletTransaction() void CWalletTx::RelayWalletTransaction()
{ {
CTxDB txdb("r"); CCoinsDB coinsdb("r");
RelayWalletTransaction(txdb); RelayWalletTransaction(coinsdb);
} }
void CWallet::ResendWalletTransactions() void CWallet::ResendWalletTransactions()
@ -891,7 +868,7 @@ void CWallet::ResendWalletTransactions()
// Rebroadcast any of our txes that aren't in a block yet // Rebroadcast any of our txes that aren't in a block yet
printf("ResendWalletTransactions()\n"); printf("ResendWalletTransactions()\n");
CTxDB txdb("r"); CCoinsDB coinsdb("r");
{ {
LOCK(cs_wallet); LOCK(cs_wallet);
// Sort them in chronological order // Sort them in chronological order
@ -907,7 +884,7 @@ void CWallet::ResendWalletTransactions()
BOOST_FOREACH(PAIRTYPE(const unsigned int, CWalletTx*)& item, mapSorted) BOOST_FOREACH(PAIRTYPE(const unsigned int, CWalletTx*)& item, mapSorted)
{ {
CWalletTx& wtx = *item.second; CWalletTx& wtx = *item.second;
wtx.RelayWalletTransaction(txdb); wtx.RelayWalletTransaction(coinsdb);
} }
} }
} }
@ -1162,8 +1139,6 @@ bool CWallet::CreateTransaction(const vector<pair<CScript, int64> >& vecSend, CW
{ {
LOCK2(cs_main, cs_wallet); LOCK2(cs_main, cs_wallet);
// txdb must be opened before the mapWallet lock
CTxDB txdb("r");
{ {
nFeeRet = nTransactionFee; nFeeRet = nTransactionFee;
loop loop
@ -1253,7 +1228,7 @@ bool CWallet::CreateTransaction(const vector<pair<CScript, int64> >& vecSend, CW
} }
// Fill vtxPrev by copying from previous transactions vtxPrev // Fill vtxPrev by copying from previous transactions vtxPrev
wtxNew.AddSupportingTransactions(txdb); wtxNew.AddSupportingTransactions();
wtxNew.fTimeReceivedIsTxTime = true; wtxNew.fTimeReceivedIsTxTime = true;
break; break;

7
src/wallet.h
View File

@ -166,7 +166,6 @@ public:
bool EraseFromWallet(uint256 hash); bool EraseFromWallet(uint256 hash);
void WalletUpdateSpent(const CTransaction& prevout); void WalletUpdateSpent(const CTransaction& prevout);
int ScanForWalletTransactions(CBlockIndex* pindexStart, bool fUpdate = false); int ScanForWalletTransactions(CBlockIndex* pindexStart, bool fUpdate = false);
int ScanForWalletTransaction(const uint256& hashTx);
void ReacceptWalletTransactions(); void ReacceptWalletTransactions();
void ResendWalletTransactions(); void ResendWalletTransactions();
int64 GetBalance() const; int64 GetBalance() const;
@ -659,12 +658,12 @@ public:
int64 GetTxTime() const; int64 GetTxTime() const;
int GetRequestCount() const; int GetRequestCount() const;
void AddSupportingTransactions(CTxDB& txdb); void AddSupportingTransactions();
bool AcceptWalletTransaction(CTxDB& txdb, bool fCheckInputs=true); bool AcceptWalletTransaction(CCoinsDB& coinsdb, bool fCheckInputs=true);
bool AcceptWalletTransaction(); bool AcceptWalletTransaction();
void RelayWalletTransaction(CTxDB& txdb); void RelayWalletTransaction(CCoinsDB& coinsdb);
void RelayWalletTransaction(); void RelayWalletTransaction();
}; };