Replace x=0 with .SetNull(), x==0 with IsNull(), x!=0 with !IsNull(). Replace uses of uint256(0) with uint256().tags/v0.15.1
@@ -315,7 +315,7 @@ static bool findSighashFlags(int& flags, const string& flagStr) | |||
uint256 ParseHashUO(map<string,UniValue>& o, string strKey) | |||
{ | |||
if (!o.count(strKey)) | |||
return 0; | |||
return uint256(); | |||
return ParseHashUV(o[strKey], strKey); | |||
} | |||
@@ -485,7 +485,7 @@ static void MutateTx(CMutableTransaction& tx, const string& command, | |||
static void OutputTxJSON(const CTransaction& tx) | |||
{ | |||
UniValue entry(UniValue::VOBJ); | |||
TxToUniv(tx, 0, entry); | |||
TxToUniv(tx, uint256(), entry); | |||
string jsonOutput = entry.write(4); | |||
fprintf(stdout, "%s\n", jsonOutput.c_str()); |
@@ -150,14 +150,14 @@ public: | |||
nFile = 0; | |||
nDataPos = 0; | |||
nUndoPos = 0; | |||
nChainWork = 0; | |||
nChainWork = uint256(); | |||
nTx = 0; | |||
nChainTx = 0; | |||
nStatus = 0; | |||
nSequenceId = 0; | |||
nVersion = 0; | |||
hashMerkleRoot = 0; | |||
hashMerkleRoot = uint256(); | |||
nTime = 0; | |||
nBits = 0; | |||
nNonce = 0; | |||
@@ -282,11 +282,11 @@ public: | |||
uint256 hashPrev; | |||
CDiskBlockIndex() { | |||
hashPrev = 0; | |||
hashPrev = uint256(); | |||
} | |||
explicit CDiskBlockIndex(const CBlockIndex* pindex) : CBlockIndex(*pindex) { | |||
hashPrev = (pprev ? pprev->GetBlockHash() : 0); | |||
hashPrev = (pprev ? pprev->GetBlockHash() : uint256()); | |||
} | |||
ADD_SERIALIZE_METHODS; |
@@ -141,7 +141,7 @@ public: | |||
txNew.vout[0].nValue = 50 * COIN; | |||
txNew.vout[0].scriptPubKey = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG; | |||
genesis.vtx.push_back(txNew); | |||
genesis.hashPrevBlock = 0; | |||
genesis.hashPrevBlock.SetNull(); | |||
genesis.hashMerkleRoot = genesis.BuildMerkleTree(); | |||
genesis.nVersion = 1; | |||
genesis.nTime = 1231006505; |
@@ -42,7 +42,7 @@ bool CCoins::Spend(uint32_t nPos) | |||
bool CCoinsView::GetCoins(const uint256 &txid, CCoins &coins) const { return false; } | |||
bool CCoinsView::HaveCoins(const uint256 &txid) const { return false; } | |||
uint256 CCoinsView::GetBestBlock() const { return uint256(0); } | |||
uint256 CCoinsView::GetBestBlock() const { return uint256(); } | |||
bool CCoinsView::BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) { return false; } | |||
bool CCoinsView::GetStats(CCoinsStats &stats) const { return false; } | |||
@@ -57,7 +57,7 @@ bool CCoinsViewBacked::GetStats(CCoinsStats &stats) const { return base->GetStat | |||
CCoinsKeyHasher::CCoinsKeyHasher() : salt(GetRandHash()) {} | |||
CCoinsViewCache::CCoinsViewCache(CCoinsView *baseIn) : CCoinsViewBacked(baseIn), hasModifier(false), hashBlock(0) { } | |||
CCoinsViewCache::CCoinsViewCache(CCoinsView *baseIn) : CCoinsViewBacked(baseIn), hasModifier(false) { } | |||
CCoinsViewCache::~CCoinsViewCache() | |||
{ | |||
@@ -128,7 +128,7 @@ bool CCoinsViewCache::HaveCoins(const uint256 &txid) const { | |||
} | |||
uint256 CCoinsViewCache::GetBestBlock() const { | |||
if (hashBlock == uint256(0)) | |||
if (hashBlock.IsNull()) | |||
hashBlock = base->GetBestBlock(); | |||
return hashBlock; | |||
} |
@@ -297,7 +297,7 @@ struct CCoinsStats | |||
uint256 hashSerialized; | |||
CAmount nTotalAmount; | |||
CCoinsStats() : nHeight(0), hashBlock(0), nTransactions(0), nTransactionOutputs(0), nSerializedSize(0), hashSerialized(0), nTotalAmount(0) {} | |||
CCoinsStats() : nHeight(0), nTransactions(0), nTransactionOutputs(0), nSerializedSize(0), nTotalAmount(0) {} | |||
}; | |||
@@ -127,7 +127,7 @@ void TxToUniv(const CTransaction& tx, const uint256& hashBlock, UniValue& entry) | |||
} | |||
entry.pushKV("vout", vout); | |||
if (hashBlock != 0) | |||
if (!hashBlock.IsNull()) | |||
entry.pushKV("blockhash", hashBlock.GetHex()); | |||
entry.pushKV("hex", EncodeHexTx(tx)); // the hex-encoded transaction. used the name "hex" to be consistent with the verbose output of "getrawtransaction". |
@@ -84,7 +84,7 @@ bool CKey::Sign(const uint256 &hash, std::vector<unsigned char>& vchSig, uint32_ | |||
nonce += test_case; | |||
int nSigLen = 72; | |||
int ret = secp256k1_ecdsa_sign((const unsigned char*)&hash, (unsigned char*)&vchSig[0], &nSigLen, begin(), (unsigned char*)&nonce); | |||
nonce = 0; | |||
nonce = uint256(); | |||
if (ret) { | |||
vchSig.resize(nSigLen); | |||
return true; | |||
@@ -116,7 +116,7 @@ bool CKey::SignCompact(const uint256 &hash, std::vector<unsigned char>& vchSig) | |||
uint256 nonce; | |||
prng.Generate((unsigned char*)&nonce, 32); | |||
int ret = secp256k1_ecdsa_sign_compact((const unsigned char*)&hash, &vchSig[1], begin(), (unsigned char*)&nonce, &rec); | |||
nonce = 0; | |||
nonce = uint256(); | |||
if (ret) | |||
break; | |||
} while(true); |
@@ -261,7 +261,7 @@ struct CNodeState { | |||
nMisbehavior = 0; | |||
fShouldBan = false; | |||
pindexBestKnownBlock = NULL; | |||
hashLastUnknownBlock = uint256(0); | |||
hashLastUnknownBlock.SetNull(); | |||
pindexLastCommonBlock = NULL; | |||
fSyncStarted = false; | |||
nStallingSince = 0; | |||
@@ -349,12 +349,12 @@ void ProcessBlockAvailability(NodeId nodeid) { | |||
CNodeState *state = State(nodeid); | |||
assert(state != NULL); | |||
if (state->hashLastUnknownBlock != 0) { | |||
if (!state->hashLastUnknownBlock.IsNull()) { | |||
BlockMap::iterator itOld = mapBlockIndex.find(state->hashLastUnknownBlock); | |||
if (itOld != mapBlockIndex.end() && itOld->second->nChainWork > 0) { | |||
if (state->pindexBestKnownBlock == NULL || itOld->second->nChainWork >= state->pindexBestKnownBlock->nChainWork) | |||
state->pindexBestKnownBlock = itOld->second; | |||
state->hashLastUnknownBlock = uint256(0); | |||
state->hashLastUnknownBlock.SetNull(); | |||
} | |||
} | |||
} | |||
@@ -1712,7 +1712,7 @@ bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pin | |||
return false; | |||
// verify that the view's current state corresponds to the previous block | |||
uint256 hashPrevBlock = pindex->pprev == NULL ? uint256(0) : pindex->pprev->GetBlockHash(); | |||
uint256 hashPrevBlock = pindex->pprev == NULL ? uint256() : pindex->pprev->GetBlockHash(); | |||
assert(hashPrevBlock == view.GetBestBlock()); | |||
// Special case for the genesis block, skipping connection of its transactions | |||
@@ -2835,7 +2835,7 @@ boost::filesystem::path GetBlockPosFilename(const CDiskBlockPos &pos, const char | |||
CBlockIndex * InsertBlockIndex(uint256 hash) | |||
{ | |||
if (hash == 0) | |||
if (hash.IsNull()) | |||
return NULL; | |||
// Return existing | |||
@@ -3369,7 +3369,7 @@ void static ProcessGetData(CNode* pfrom) | |||
vector<CInv> vInv; | |||
vInv.push_back(CInv(MSG_BLOCK, chainActive.Tip()->GetBlockHash())); | |||
pfrom->PushMessage("inv", vInv); | |||
pfrom->hashContinue = 0; | |||
pfrom->hashContinue.SetNull(); | |||
} | |||
} | |||
} | |||
@@ -3604,7 +3604,7 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv, | |||
// Use deterministic randomness to send to the same nodes for 24 hours | |||
// at a time so the setAddrKnowns of the chosen nodes prevent repeats | |||
static uint256 hashSalt; | |||
if (hashSalt == 0) | |||
if (hashSalt.IsNull()) | |||
hashSalt = GetRandHash(); | |||
uint64_t hashAddr = addr.GetHash(); | |||
uint256 hashRand = hashSalt ^ (hashAddr<<32) ^ ((GetTime()+hashAddr)/(24*60*60)); | |||
@@ -3738,7 +3738,7 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv, | |||
if (pindex) | |||
pindex = chainActive.Next(pindex); | |||
int nLimit = 500; | |||
LogPrint("net", "getblocks %d to %s limit %d from peer=%d\n", (pindex ? pindex->nHeight : -1), hashStop==uint256(0) ? "end" : hashStop.ToString(), nLimit, pfrom->id); | |||
LogPrint("net", "getblocks %d to %s limit %d from peer=%d\n", (pindex ? pindex->nHeight : -1), hashStop.IsNull() ? "end" : hashStop.ToString(), nLimit, pfrom->id); | |||
for (; pindex; pindex = chainActive.Next(pindex)) | |||
{ | |||
if (pindex->GetBlockHash() == hashStop) | |||
@@ -3954,7 +3954,7 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv, | |||
// TODO: optimize: if pindexLast is an ancestor of chainActive.Tip or pindexBestHeader, continue | |||
// from there instead. | |||
LogPrint("net", "more getheaders (%d) to end to peer=%d (startheight:%d)\n", pindexLast->nHeight, pfrom->id, pfrom->nStartingHeight); | |||
pfrom->PushMessage("getheaders", chainActive.GetLocator(pindexLast), uint256(0)); | |||
pfrom->PushMessage("getheaders", chainActive.GetLocator(pindexLast), uint256()); | |||
} | |||
} | |||
@@ -4452,7 +4452,7 @@ bool SendMessages(CNode* pto, bool fSendTrickle) | |||
nSyncStarted++; | |||
CBlockIndex *pindexStart = pindexBestHeader->pprev ? pindexBestHeader->pprev : pindexBestHeader; | |||
LogPrint("net", "initial getheaders (%d) to peer=%d (startheight:%d)\n", pindexStart->nHeight, pto->id, pto->nStartingHeight); | |||
pto->PushMessage("getheaders", chainActive.GetLocator(pindexStart), uint256(0)); | |||
pto->PushMessage("getheaders", chainActive.GetLocator(pindexStart), uint256()); | |||
} | |||
} | |||
@@ -4483,7 +4483,7 @@ bool SendMessages(CNode* pto, bool fSendTrickle) | |||
{ | |||
// 1/4 of tx invs blast to all immediately | |||
static uint256 hashSalt; | |||
if (hashSalt == 0) | |||
if (hashSalt.IsNull()) | |||
hashSalt = GetRandHash(); | |||
uint256 hashRand = inv.hash ^ hashSalt; | |||
hashRand = Hash(BEGIN(hashRand), END(hashRand)); |
@@ -76,7 +76,7 @@ uint256 CPartialMerkleTree::TraverseAndExtract(int height, unsigned int pos, uns | |||
if (nBitsUsed >= vBits.size()) { | |||
// overflowed the bits array - failure | |||
fBad = true; | |||
return 0; | |||
return uint256(); | |||
} | |||
bool fParentOfMatch = vBits[nBitsUsed++]; | |||
if (height==0 || !fParentOfMatch) { | |||
@@ -84,7 +84,7 @@ uint256 CPartialMerkleTree::TraverseAndExtract(int height, unsigned int pos, uns | |||
if (nHashUsed >= vHash.size()) { | |||
// overflowed the hash array - failure | |||
fBad = true; | |||
return 0; | |||
return uint256(); | |||
} | |||
const uint256 &hash = vHash[nHashUsed++]; | |||
if (height==0 && fParentOfMatch) // in case of height 0, we have a matched txid | |||
@@ -128,16 +128,16 @@ uint256 CPartialMerkleTree::ExtractMatches(std::vector<uint256> &vMatch) { | |||
vMatch.clear(); | |||
// An empty set will not work | |||
if (nTransactions == 0) | |||
return 0; | |||
return uint256(); | |||
// check for excessively high numbers of transactions | |||
if (nTransactions > MAX_BLOCK_SIZE / 60) // 60 is the lower bound for the size of a serialized CTransaction | |||
return 0; | |||
return uint256(); | |||
// there can never be more hashes provided than one for every txid | |||
if (vHash.size() > nTransactions) | |||
return 0; | |||
return uint256(); | |||
// there must be at least one bit per node in the partial tree, and at least one node per hash | |||
if (vBits.size() < vHash.size()) | |||
return 0; | |||
return uint256(); | |||
// calculate height of tree | |||
int nHeight = 0; | |||
while (CalcTreeWidth(nHeight) > 1) | |||
@@ -147,12 +147,12 @@ uint256 CPartialMerkleTree::ExtractMatches(std::vector<uint256> &vMatch) { | |||
uint256 hashMerkleRoot = TraverseAndExtract(nHeight, 0, nBitsUsed, nHashUsed, vMatch); | |||
// verify that no problems occured during the tree traversal | |||
if (fBad) | |||
return 0; | |||
return uint256(); | |||
// verify that all bits were consumed (except for the padding caused by serializing it as a byte sequence) | |||
if ((nBitsUsed+7)/8 != (vBits.size()+7)/8) | |||
return 0; | |||
return uint256(); | |||
// verify that all hashes were consumed | |||
if (nHashUsed != vHash.size()) | |||
return 0; | |||
return uint256(); | |||
return hashMerkleRoot; | |||
} |
@@ -1949,7 +1949,7 @@ CNode::CNode(SOCKET hSocketIn, CAddress addrIn, std::string addrNameIn, bool fIn | |||
nRefCount = 0; | |||
nSendSize = 0; | |||
nSendOffset = 0; | |||
hashContinue = 0; | |||
hashContinue = uint256(); | |||
nStartingHeight = -1; | |||
fGetAddr = false; | |||
fRelayTxes = false; |
@@ -74,7 +74,7 @@ uint256 CBlock::BuildMerkleTree(bool* fMutated) const | |||
if (fMutated) { | |||
*fMutated = mutated; | |||
} | |||
return (vMerkleTree.empty() ? 0 : vMerkleTree.back()); | |||
return (vMerkleTree.empty() ? uint256() : vMerkleTree.back()); | |||
} | |||
std::vector<uint256> CBlock::GetMerkleBranch(int nIndex) const | |||
@@ -96,7 +96,7 @@ std::vector<uint256> CBlock::GetMerkleBranch(int nIndex) const | |||
uint256 CBlock::CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex) | |||
{ | |||
if (nIndex == -1) | |||
return 0; | |||
return uint256(); | |||
for (std::vector<uint256>::const_iterator it(vMerkleBranch.begin()); it != vMerkleBranch.end(); ++it) | |||
{ | |||
if (nIndex & 1) |
@@ -53,8 +53,8 @@ public: | |||
void SetNull() | |||
{ | |||
nVersion = CBlockHeader::CURRENT_VERSION; | |||
hashPrevBlock = 0; | |||
hashMerkleRoot = 0; | |||
hashPrevBlock.SetNull(); | |||
hashMerkleRoot.SetNull(); | |||
nTime = 0; | |||
nBits = 0; | |||
nNonce = 0; |
@@ -72,7 +72,7 @@ void CTransaction::UpdateHash() const | |||
*const_cast<uint256*>(&hash) = SerializeHash(*this); | |||
} | |||
CTransaction::CTransaction() : hash(0), nVersion(CTransaction::CURRENT_VERSION), vin(), vout(), nLockTime(0) { } | |||
CTransaction::CTransaction() : nVersion(CTransaction::CURRENT_VERSION), vin(), vout(), nLockTime(0) { } | |||
CTransaction::CTransaction(const CMutableTransaction &tx) : nVersion(tx.nVersion), vin(tx.vin), vout(tx.vout), nLockTime(tx.nLockTime) { | |||
UpdateHash(); |
@@ -28,8 +28,8 @@ public: | |||
READWRITE(FLATDATA(*this)); | |||
} | |||
void SetNull() { hash = 0; n = (uint32_t) -1; } | |||
bool IsNull() const { return (hash == 0 && n == (uint32_t) -1); } | |||
void SetNull() { hash.SetNull(); n = (uint32_t) -1; } | |||
bool IsNull() const { return (hash.IsNull() && n == (uint32_t) -1); } | |||
friend bool operator<(const COutPoint& a, const COutPoint& b) | |||
{ |
@@ -96,7 +96,7 @@ void CAddress::Init() | |||
CInv::CInv() | |||
{ | |||
type = 0; | |||
hash = 0; | |||
hash.SetNull(); | |||
} | |||
CInv::CInv(int typeIn, const uint256& hashIn) |
@@ -27,7 +27,7 @@ | |||
class CKeyID : public uint160 | |||
{ | |||
public: | |||
CKeyID() : uint160(0) {} | |||
CKeyID() : uint160() {} | |||
CKeyID(const uint160& in) : uint160(in) {} | |||
}; | |||
@@ -240,7 +240,7 @@ static bool rest_tx(AcceptedConnection* conn, | |||
throw RESTERR(HTTP_BAD_REQUEST, "Invalid hash: " + hashStr); | |||
CTransaction tx; | |||
uint256 hashBlock = 0; | |||
uint256 hashBlock = uint256(); | |||
if (!GetTransaction(hash, tx, hashBlock, true)) | |||
throw RESTERR(HTTP_NOT_FOUND, hashStr + " not found"); | |||
@@ -70,7 +70,7 @@ Object blockToJSON(const CBlock& block, const CBlockIndex* blockindex, bool txDe | |||
if(txDetails) | |||
{ | |||
Object objTx; | |||
TxToJSON(tx, uint256(0), objTx); | |||
TxToJSON(tx, uint256(), objTx); | |||
txs.push_back(objTx); | |||
} | |||
else |
@@ -89,7 +89,7 @@ void TxToJSON(const CTransaction& tx, const uint256 hashBlock, Object& entry) | |||
} | |||
entry.push_back(Pair("vout", vout)); | |||
if (hashBlock != 0) { | |||
if (!hashBlock.IsNull()) { | |||
entry.push_back(Pair("blockhash", hashBlock.GetHex())); | |||
BlockMap::iterator mi = mapBlockIndex.find(hashBlock); | |||
if (mi != mapBlockIndex.end() && (*mi).second) { | |||
@@ -178,7 +178,7 @@ Value getrawtransaction(const Array& params, bool fHelp) | |||
fVerbose = (params[1].get_int() != 0); | |||
CTransaction tx; | |||
uint256 hashBlock = 0; | |||
uint256 hashBlock; | |||
if (!GetTransaction(hash, tx, hashBlock, true)) | |||
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available about transaction"); | |||
@@ -438,7 +438,7 @@ Value decoderawtransaction(const Array& params, bool fHelp) | |||
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed"); | |||
Object result; | |||
TxToJSON(tx, 0, result); | |||
TxToJSON(tx, uint256(), result); | |||
return result; | |||
} |
@@ -1477,7 +1477,7 @@ Value listsinceblock(const Array& params, bool fHelp) | |||
if (params.size() > 0) | |||
{ | |||
uint256 blockId = 0; | |||
uint256 blockId; | |||
blockId.SetHex(params[0].get_str()); | |||
BlockMap::iterator it = mapBlockIndex.find(blockId); | |||
@@ -1510,7 +1510,7 @@ Value listsinceblock(const Array& params, bool fHelp) | |||
} | |||
CBlockIndex *pblockLast = chainActive[chainActive.Height() + 1 - target_confirms]; | |||
uint256 lastblock = pblockLast ? pblockLast->GetBlockHash() : 0; | |||
uint256 lastblock = pblockLast ? pblockLast->GetBlockHash() : uint256(); | |||
Object ret; | |||
ret.push_back(Pair("transactions", transactions)); |
@@ -20,7 +20,7 @@ class CScript; | |||
class CScriptID : public uint160 | |||
{ | |||
public: | |||
CScriptID() : uint160(0) {} | |||
CScriptID() : uint160() {} | |||
CScriptID(const CScript& in); | |||
CScriptID(const uint160& in) : uint160(in) {} | |||
}; |
@@ -46,7 +46,7 @@ BOOST_AUTO_TEST_CASE(pmt_test1) | |||
// calculate actual merkle root and height | |||
uint256 merkleRoot1 = block.BuildMerkleTree(); | |||
std::vector<uint256> vTxid(nTx, 0); | |||
std::vector<uint256> vTxid(nTx, uint256()); | |||
for (unsigned int j=0; j<nTx; j++) | |||
vTxid[j] = block.vtx[j].GetHash(); | |||
int nHeight = 1, nTx_ = nTx; | |||
@@ -88,7 +88,7 @@ BOOST_AUTO_TEST_CASE(pmt_test1) | |||
// check that it has the same merkle root as the original, and a valid one | |||
BOOST_CHECK(merkleRoot1 == merkleRoot2); | |||
BOOST_CHECK(merkleRoot2 != 0); | |||
BOOST_CHECK(!merkleRoot2.IsNull()); | |||
// check that it contains the matched transactions (in the same order!) | |||
BOOST_CHECK(vMatchTxid1 == vMatchTxid2); | |||
@@ -112,7 +112,7 @@ BOOST_AUTO_TEST_CASE(pmt_malleability) | |||
CPartialMerkleTree tree(vTxid, vMatch); | |||
std::vector<uint256> vTxid2; | |||
BOOST_CHECK(tree.ExtractMatches(vTxid) == 0); | |||
BOOST_CHECK(tree.ExtractMatches(vTxid).IsNull()); | |||
} | |||
BOOST_AUTO_TEST_SUITE_END() |
@@ -210,7 +210,7 @@ BOOST_AUTO_TEST_CASE(set) | |||
BOOST_AUTO_TEST_CASE(is) | |||
{ | |||
// Test CScript::IsPayToScriptHash() | |||
uint160 dummy(0); | |||
uint160 dummy; | |||
CScript p2sh; | |||
p2sh << OP_HASH160 << ToByteVector(dummy) << OP_EQUAL; | |||
BOOST_CHECK(p2sh.IsPayToScriptHash()); |
@@ -32,7 +32,7 @@ BOOST_AUTO_TEST_CASE(GetSigOpCount) | |||
BOOST_CHECK_EQUAL(s1.GetSigOpCount(false), 0U); | |||
BOOST_CHECK_EQUAL(s1.GetSigOpCount(true), 0U); | |||
uint160 dummy(0); | |||
uint160 dummy; | |||
s1 << OP_1 << ToByteVector(dummy) << ToByteVector(dummy) << OP_2 << OP_CHECKMULTISIG; | |||
BOOST_CHECK_EQUAL(s1.GetSigOpCount(true), 2U); | |||
s1 << OP_IF << OP_CHECKSIG << OP_ENDIF; |
@@ -39,7 +39,7 @@ bool CCoinsViewDB::HaveCoins(const uint256 &txid) const { | |||
uint256 CCoinsViewDB::GetBestBlock() const { | |||
uint256 hashBestChain; | |||
if (!db.Read('B', hashBestChain)) | |||
return uint256(0); | |||
return uint256(); | |||
return hashBestChain; | |||
} | |||
@@ -56,7 +56,7 @@ bool CCoinsViewDB::BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) { | |||
CCoinsMap::iterator itOld = it++; | |||
mapCoins.erase(itOld); | |||
} | |||
if (hashBlock != uint256(0)) | |||
if (!hashBlock.IsNull()) | |||
BatchWriteHashBestChain(batch, hashBlock); | |||
LogPrint("coindb", "Committing %u changed transactions (out of %u) to coin database...\n", (unsigned int)changed, (unsigned int)count); | |||
@@ -179,7 +179,7 @@ bool CBlockTreeDB::LoadBlockIndexGuts() | |||
boost::scoped_ptr<leveldb::Iterator> pcursor(NewIterator()); | |||
CDataStream ssKeySet(SER_DISK, CLIENT_VERSION); | |||
ssKeySet << make_pair('b', uint256(0)); | |||
ssKeySet << make_pair('b', uint256()); | |||
pcursor->Seek(ssKeySet.str()); | |||
// Load mapBlockIndex |
@@ -579,7 +579,7 @@ bool CWallet::AddToWallet(const CWalletTx& wtxIn, bool fFromLoadWallet) | |||
wtx.nOrderPos = IncOrderPosNext(); | |||
wtx.nTimeSmart = wtx.nTimeReceived; | |||
if (wtxIn.hashBlock != 0) | |||
if (!wtxIn.hashBlock.IsNull()) | |||
{ | |||
if (mapBlockIndex.count(wtxIn.hashBlock)) | |||
{ | |||
@@ -630,7 +630,7 @@ bool CWallet::AddToWallet(const CWalletTx& wtxIn, bool fFromLoadWallet) | |||
if (!fInsertedNew) | |||
{ | |||
// Merge | |||
if (wtxIn.hashBlock != 0 && wtxIn.hashBlock != wtx.hashBlock) | |||
if (!wtxIn.hashBlock.IsNull() && wtxIn.hashBlock != wtx.hashBlock) | |||
{ | |||
wtx.hashBlock = wtxIn.hashBlock; | |||
fUpdated = true; | |||
@@ -795,7 +795,7 @@ int CWalletTx::GetRequestCount() const | |||
if (IsCoinBase()) | |||
{ | |||
// Generated block | |||
if (hashBlock != 0) | |||
if (!hashBlock.IsNull()) | |||
{ | |||
map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(hashBlock); | |||
if (mi != pwallet->mapRequestCount.end()) | |||
@@ -811,7 +811,7 @@ int CWalletTx::GetRequestCount() const | |||
nRequests = (*mi).second; | |||
// How about the block it's in? | |||
if (nRequests == 0 && hashBlock != 0) | |||
if (nRequests == 0 && !hashBlock.IsNull()) | |||
{ | |||
map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(hashBlock); | |||
if (mi != pwallet->mapRequestCount.end()) | |||
@@ -2317,7 +2317,7 @@ int CMerkleTx::SetMerkleBranch(const CBlock& block) | |||
int CMerkleTx::GetDepthInMainChainINTERNAL(const CBlockIndex* &pindexRet) const | |||
{ | |||
if (hashBlock == 0 || nIndex == -1) | |||
if (hashBlock.IsNull() || nIndex == -1) | |||
return 0; | |||
AssertLockHeld(cs_main); | |||
@@ -519,7 +519,7 @@ public: | |||
void Init() | |||
{ | |||
hashBlock = 0; | |||
hashBlock = uint256(); | |||
nIndex = -1; | |||
fMerkleVerified = false; | |||
} |
@@ -439,7 +439,7 @@ ReadKeyValue(CWallet* pwallet, CDataStream& ssKey, CDataStream& ssValue, | |||
} | |||
CKey key; | |||
CPrivKey pkey; | |||
uint256 hash = 0; | |||
uint256 hash; | |||
if (strType == "key") | |||
{ | |||
@@ -464,7 +464,7 @@ ReadKeyValue(CWallet* pwallet, CDataStream& ssKey, CDataStream& ssValue, | |||
bool fSkipCheck = false; | |||
if (hash != 0) | |||
if (!hash.IsNull()) | |||
{ | |||
// hash pubkey/privkey to accelerate wallet load | |||
std::vector<unsigned char> vchKey; |