phantom/bitcoin
1
0
Fork 0
mirror of https://github.com/bitcoin/bitcoin.git synced 2025-04-29 14:59:39 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Use DataStream where possible

Browse source
This commit is contained in:
MarcoFalke 2023-01-03 13:21:44 +01:00
parent fa9becfe1c
commit fa29e73cda
No known key found for this signature in database
GPG key ID: CE2B75697E69A548
48 changed files with 144 additions and 151 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/bench/load_external.cpp
View file

@ -27,7 +27,7 @@ static void LoadExternalBlockFile(benchmark::Bench& bench)
// Create a single block as in the blocks files (magic bytes, block size, // Create a single block as in the blocks files (magic bytes, block size,
// block data) as a stream object. // block data) as a stream object.
const fs::path blkfile{testing_setup.get()->m_path_root / "blk.dat"}; const fs::path blkfile{testing_setup.get()->m_path_root / "blk.dat"};
CDataStream ss(SER_DISK, 0); DataStream ss{};
auto params{testing_setup->m_node.chainman->GetParams()}; auto params{testing_setup->m_node.chainman->GetParams()};
ss << params.MessageStart(); ss << params.MessageStart();
ss << static_cast<uint32_t>(benchmark::data::block413567.size()); ss << static_cast<uint32_t>(benchmark::data::block413567.size());

2
src/bench/prevector.cpp
View file

@ -61,7 +61,7 @@ static void PrevectorResize(benchmark::Bench& bench)
template <typename T> template <typename T>
static void PrevectorDeserialize(benchmark::Bench& bench) static void PrevectorDeserialize(benchmark::Bench& bench)
{ {
CDataStream s0(SER_NETWORK, 0); DataStream s0{};
prevector<28, T> t0; prevector<28, T> t0;
t0.resize(28); t0.resize(28);
for (auto x = 0; x < 900; ++x) { for (auto x = 0; x < 900; ++x) {

2
src/bitcoin-util.cpp
View file

@ -139,7 +139,7 @@ static int Grind(const std::vector<std::string>& args, std::string& strPrint)
return EXIT_FAILURE; return EXIT_FAILURE;
} }
CDataStream ss(SER_NETWORK, PROTOCOL_VERSION); DataStream ss{};
ss << header; ss << header;
strPrint = HexStr(ss); strPrint = HexStr(ss);
return EXIT_SUCCESS; return EXIT_SUCCESS;

2
src/blockencodings.cpp
View file

@ -29,7 +29,7 @@ CBlockHeaderAndShortTxIDs::CBlockHeaderAndShortTxIDs(const CBlock& block) :
} }
void CBlockHeaderAndShortTxIDs::FillShortTxIDSelector() const { void CBlockHeaderAndShortTxIDs::FillShortTxIDSelector() const {
CDataStream stream(SER_NETWORK, PROTOCOL_VERSION); DataStream stream{};
stream << header << nonce; stream << header << nonce;
CSHA256 hasher; CSHA256 hasher;
hasher.Write((unsigned char*)&(*stream.begin()), stream.end() - stream.begin()); hasher.Write((unsigned char*)&(*stream.begin()), stream.end() - stream.begin());

4
src/common/bloom.cpp
View file

@ -60,7 +60,7 @@ void CBloomFilter::insert(Span<const unsigned char> vKey)
void CBloomFilter::insert(const COutPoint& outpoint) void CBloomFilter::insert(const COutPoint& outpoint)
{ {
CDataStream stream(SER_NETWORK, PROTOCOL_VERSION); DataStream stream{};
stream << outpoint; stream << outpoint;
insert(MakeUCharSpan(stream)); insert(MakeUCharSpan(stream));
} }
@ -81,7 +81,7 @@ bool CBloomFilter::contains(Span<const unsigned char> vKey) const
bool CBloomFilter::contains(const COutPoint& outpoint) const bool CBloomFilter::contains(const COutPoint& outpoint) const
{ {
CDataStream stream(SER_NETWORK, PROTOCOL_VERSION); DataStream stream{};
stream << outpoint; stream << outpoint;
return contains(MakeUCharSpan(stream)); return contains(MakeUCharSpan(stream));
} }

2
src/core_read.cpp
View file

@ -207,7 +207,7 @@ bool DecodeHexBlockHeader(CBlockHeader& header, const std::string& hex_header)
if (!IsHex(hex_header)) return false; if (!IsHex(hex_header)) return false;
const std::vector<unsigned char> header_data{ParseHex(hex_header)}; const std::vector<unsigned char> header_data{ParseHex(hex_header)};
CDataStream ser_header(header_data, SER_NETWORK, PROTOCOL_VERSION); DataStream ser_header{header_data};
try { try {
ser_header >> header; ser_header >> header;
} catch (const std::exception&) { } catch (const std::exception&) {

14
src/dbwrapper.h
View file

@ -68,7 +68,7 @@ private:
const CDBWrapper &parent; const CDBWrapper &parent;
leveldb::WriteBatch batch; leveldb::WriteBatch batch;
CDataStream ssKey; DataStream ssKey{};
CDataStream ssValue; CDataStream ssValue;
size_t size_estimate; size_t size_estimate;
@ -77,7 +77,7 @@ public:
/** /**
* @param[in] _parent CDBWrapper that this batch is to be submitted to * @param[in] _parent CDBWrapper that this batch is to be submitted to
*/ */
explicit CDBBatch(const CDBWrapper &_parent) : parent(_parent), ssKey(SER_DISK, CLIENT_VERSION), ssValue(SER_DISK, CLIENT_VERSION), size_estimate(0) { }; explicit CDBBatch(const CDBWrapper& _parent) : parent(_parent), ssValue(SER_DISK, CLIENT_VERSION), size_estimate(0){};
void Clear() void Clear()
{ {
@ -151,7 +151,7 @@ public:
void SeekToFirst(); void SeekToFirst();
template<typename K> void Seek(const K& key) { template<typename K> void Seek(const K& key) {
CDataStream ssKey(SER_DISK, CLIENT_VERSION); DataStream ssKey{};
ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE); ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
ssKey << key; ssKey << key;
leveldb::Slice slKey((const char*)ssKey.data(), ssKey.size()); leveldb::Slice slKey((const char*)ssKey.data(), ssKey.size());
@ -163,7 +163,7 @@ public:
template<typename K> bool GetKey(K& key) { template<typename K> bool GetKey(K& key) {
leveldb::Slice slKey = piter->key(); leveldb::Slice slKey = piter->key();
try { try {
CDataStream ssKey{MakeByteSpan(slKey), SER_DISK, CLIENT_VERSION}; DataStream ssKey{MakeByteSpan(slKey)};
ssKey >> key; ssKey >> key;
} catch (const std::exception&) { } catch (const std::exception&) {
return false; return false;
@ -247,7 +247,7 @@ public:
template <typename K, typename V> template <typename K, typename V>
bool Read(const K& key, V& value) const bool Read(const K& key, V& value) const
{ {
CDataStream ssKey(SER_DISK, CLIENT_VERSION); DataStream ssKey{};
ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE); ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
ssKey << key; ssKey << key;
leveldb::Slice slKey((const char*)ssKey.data(), ssKey.size()); leveldb::Slice slKey((const char*)ssKey.data(), ssKey.size());
@ -289,7 +289,7 @@ public:
template <typename K> template <typename K>
bool Exists(const K& key) const bool Exists(const K& key) const
{ {
CDataStream ssKey(SER_DISK, CLIENT_VERSION); DataStream ssKey{};
ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE); ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
ssKey << key; ssKey << key;
leveldb::Slice slKey((const char*)ssKey.data(), ssKey.size()); leveldb::Slice slKey((const char*)ssKey.data(), ssKey.size());
@ -331,7 +331,7 @@ public:
template<typename K> template<typename K>
size_t EstimateSize(const K& key_begin, const K& key_end) const size_t EstimateSize(const K& key_begin, const K& key_end) const
{ {
CDataStream ssKey1(SER_DISK, CLIENT_VERSION), ssKey2(SER_DISK, CLIENT_VERSION); DataStream ssKey1{}, ssKey2{};
ssKey1.reserve(DBWRAPPER_PREALLOC_KEY_SIZE); ssKey1.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
ssKey2.reserve(DBWRAPPER_PREALLOC_KEY_SIZE); ssKey2.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
ssKey1 << key_begin; ssKey1 << key_begin;

5
src/kernel/coinstats.cpp
View file

@ -48,8 +48,9 @@ uint64_t GetBogoSize(const CScript& script_pub_key)
script_pub_key.size() /* scriptPubKey */; script_pub_key.size() /* scriptPubKey */;
} }
CDataStream TxOutSer(const COutPoint& outpoint, const Coin& coin) { DataStream TxOutSer(const COutPoint& outpoint, const Coin& coin)
CDataStream ss(SER_DISK, PROTOCOL_VERSION); {
DataStream ss{};
ss << outpoint; ss << outpoint;
ss << static_cast<uint32_t>(coin.nHeight * 2 + coin.fCoinBase); ss << static_cast<uint32_t>(coin.nHeight * 2 + coin.fCoinBase);
ss << coin.out; ss << coin.out;

2
src/kernel/coinstats.h
View file

@ -72,7 +72,7 @@ struct CCoinsStats {
uint64_t GetBogoSize(const CScript& script_pub_key); uint64_t GetBogoSize(const CScript& script_pub_key);
CDataStream TxOutSer(const COutPoint& outpoint, const Coin& coin); DataStream TxOutSer(const COutPoint& outpoint, const Coin& coin);
std::optional<CCoinsStats> ComputeUTXOStats(CoinStatsHashType hash_type, CCoinsView* view, node::BlockManager& blockman, const std::function<void()>& interruption_point = {}); std::optional<CCoinsStats> ComputeUTXOStats(CoinStatsHashType hash_type, CCoinsView* view, node::BlockManager& blockman, const std::function<void()>& interruption_point = {});
} // namespace kernel } // namespace kernel

2
src/net_processing.cpp
View file

@ -3361,7 +3361,7 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
// If the peer is old enough to have the old alert system, send it the final alert. // If the peer is old enough to have the old alert system, send it the final alert.
if (greatest_common_version <= 70012) { if (greatest_common_version <= 70012) {
CDataStream finalAlert(ParseHex("60010000000000000000000000ffffff7f00000000ffffff7ffeffff7f01ffffff7f00000000ffffff7f00ffffff7f002f555247454e543a20416c657274206b657920636f6d70726f6d697365642c2075706772616465207265717569726564004630440220653febd6410f470f6bae11cad19c48413becb1ac2c17f908fd0fd53bdc3abd5202206d0e9c96fe88d4a0f01ed9dedae2b6f9e00da94cad0fecaae66ecf689bf71b50"), SER_NETWORK, PROTOCOL_VERSION); DataStream finalAlert{ParseHex("60010000000000000000000000ffffff7f00000000ffffff7ffeffff7f01ffffff7f00000000ffffff7f00ffffff7f002f555247454e543a20416c657274206b657920636f6d70726f6d697365642c2075706772616465207265717569726564004630440220653febd6410f470f6bae11cad19c48413becb1ac2c17f908fd0fd53bdc3abd5202206d0e9c96fe88d4a0f01ed9dedae2b6f9e00da94cad0fecaae66ecf689bf71b50")};
m_connman.PushMessage(&pfrom, CNetMsgMaker(greatest_common_version).Make("alert", finalAlert)); m_connman.PushMessage(&pfrom, CNetMsgMaker(greatest_common_version).Make("alert", finalAlert));
} }

4
src/qt/recentrequeststablemodel.cpp
View file

@ -175,7 +175,7 @@ void RecentRequestsTableModel::addNewRequest(const SendCoinsRecipient &recipient
newEntry.date = QDateTime::currentDateTime(); newEntry.date = QDateTime::currentDateTime();
newEntry.recipient = recipient; newEntry.recipient = recipient;
CDataStream ss(SER_DISK, CLIENT_VERSION); DataStream ss{};
ss << newEntry; ss << newEntry;
if (!walletModel->wallet().setAddressReceiveRequest(DecodeDestination(recipient.address.toStdString()), ToString(newEntry.id), ss.str())) if (!walletModel->wallet().setAddressReceiveRequest(DecodeDestination(recipient.address.toStdString()), ToString(newEntry.id), ss.str()))
@ -188,7 +188,7 @@ void RecentRequestsTableModel::addNewRequest(const SendCoinsRecipient &recipient
void RecentRequestsTableModel::addNewRequest(const std::string &recipient) void RecentRequestsTableModel::addNewRequest(const std::string &recipient)
{ {
std::vector<uint8_t> data(recipient.begin(), recipient.end()); std::vector<uint8_t> data(recipient.begin(), recipient.end());
CDataStream ss(data, SER_DISK, CLIENT_VERSION); DataStream ss{data};
RecentRequestEntry entry; RecentRequestEntry entry;
ss >> entry; ss >> entry;

2
src/qt/test/wallettests.cpp
View file

@ -289,7 +289,7 @@ void TestGUI(interfaces::Node& node)
std::vector<std::string> requests = walletModel.wallet().getAddressReceiveRequests(); std::vector<std::string> requests = walletModel.wallet().getAddressReceiveRequests();
QCOMPARE(requests.size(), size_t{1}); QCOMPARE(requests.size(), size_t{1});
RecentRequestEntry entry; RecentRequestEntry entry;
CDataStream{MakeUCharSpan(requests[0]), SER_DISK, CLIENT_VERSION} >> entry; DataStream{MakeUCharSpan(requests[0])} >> entry;
QCOMPARE(entry.nVersion, int{1}); QCOMPARE(entry.nVersion, int{1});
QCOMPARE(entry.id, int64_t{1}); QCOMPARE(entry.id, int64_t{1});
QVERIFY(entry.date.isValid()); QVERIFY(entry.date.isValid());

20
src/rest.cpp
View file

@ -236,7 +236,7 @@ static bool rest_headers(const std::any& context,
switch (rf) { switch (rf) {
case RESTResponseFormat::BINARY: { case RESTResponseFormat::BINARY: {
CDataStream ssHeader(SER_NETWORK, PROTOCOL_VERSION); DataStream ssHeader{};
for (const CBlockIndex *pindex : headers) { for (const CBlockIndex *pindex : headers) {
ssHeader << pindex->GetBlockHeader(); ssHeader << pindex->GetBlockHeader();
} }
@ -248,7 +248,7 @@ static bool rest_headers(const std::any& context,
} }
case RESTResponseFormat::HEX: { case RESTResponseFormat::HEX: {
CDataStream ssHeader(SER_NETWORK, PROTOCOL_VERSION); DataStream ssHeader{};
for (const CBlockIndex *pindex : headers) { for (const CBlockIndex *pindex : headers) {
ssHeader << pindex->GetBlockHeader(); ssHeader << pindex->GetBlockHeader();
} }
@ -435,7 +435,7 @@ static bool rest_filter_header(const std::any& context, HTTPRequest* req, const
switch (rf) { switch (rf) {
case RESTResponseFormat::BINARY: { case RESTResponseFormat::BINARY: {
CDataStream ssHeader{SER_NETWORK, PROTOCOL_VERSION}; DataStream ssHeader{};
for (const uint256& header : filter_headers) { for (const uint256& header : filter_headers) {
ssHeader << header; ssHeader << header;
} }
@ -446,7 +446,7 @@ static bool rest_filter_header(const std::any& context, HTTPRequest* req, const
return true; return true;
} }
case RESTResponseFormat::HEX: { case RESTResponseFormat::HEX: {
CDataStream ssHeader{SER_NETWORK, PROTOCOL_VERSION}; DataStream ssHeader{};
for (const uint256& header : filter_headers) { for (const uint256& header : filter_headers) {
ssHeader << header; ssHeader << header;
} }
@ -534,7 +534,7 @@ static bool rest_block_filter(const std::any& context, HTTPRequest* req, const s
switch (rf) { switch (rf) {
case RESTResponseFormat::BINARY: { case RESTResponseFormat::BINARY: {
CDataStream ssResp{SER_NETWORK, PROTOCOL_VERSION}; DataStream ssResp{};
ssResp << filter; ssResp << filter;
std::string binaryResp = ssResp.str(); std::string binaryResp = ssResp.str();
@ -543,7 +543,7 @@ static bool rest_block_filter(const std::any& context, HTTPRequest* req, const s
return true; return true;
} }
case RESTResponseFormat::HEX: { case RESTResponseFormat::HEX: {
CDataStream ssResp{SER_NETWORK, PROTOCOL_VERSION}; DataStream ssResp{};
ssResp << filter; ssResp << filter;
std::string strHex = HexStr(ssResp) + "\n"; std::string strHex = HexStr(ssResp) + "\n";
@ -793,7 +793,7 @@ static bool rest_getutxos(const std::any& context, HTTPRequest* req, const std::
if (fInputParsed) //don't allow sending input over URI and HTTP RAW DATA if (fInputParsed) //don't allow sending input over URI and HTTP RAW DATA
return RESTERR(req, HTTP_BAD_REQUEST, "Combination of URI scheme inputs and raw post data is not allowed"); return RESTERR(req, HTTP_BAD_REQUEST, "Combination of URI scheme inputs and raw post data is not allowed");
CDataStream oss(SER_NETWORK, PROTOCOL_VERSION); DataStream oss{};
oss << strRequestMutable; oss << strRequestMutable;
oss >> fCheckMemPool; oss >> fCheckMemPool;
oss >> vOutPoints; oss >> vOutPoints;
@ -866,7 +866,7 @@ static bool rest_getutxos(const std::any& context, HTTPRequest* req, const std::
case RESTResponseFormat::BINARY: { case RESTResponseFormat::BINARY: {
// serialize data // serialize data
// use exact same output as mentioned in Bip64 // use exact same output as mentioned in Bip64
CDataStream ssGetUTXOResponse(SER_NETWORK, PROTOCOL_VERSION); DataStream ssGetUTXOResponse{};
ssGetUTXOResponse << active_height << active_hash << bitmap << outs; ssGetUTXOResponse << active_height << active_hash << bitmap << outs;
std::string ssGetUTXOResponseString = ssGetUTXOResponse.str(); std::string ssGetUTXOResponseString = ssGetUTXOResponse.str();
@ -876,7 +876,7 @@ static bool rest_getutxos(const std::any& context, HTTPRequest* req, const std::
} }
case RESTResponseFormat::HEX: { case RESTResponseFormat::HEX: {
CDataStream ssGetUTXOResponse(SER_NETWORK, PROTOCOL_VERSION); DataStream ssGetUTXOResponse{};
ssGetUTXOResponse << active_height << active_hash << bitmap << outs; ssGetUTXOResponse << active_height << active_hash << bitmap << outs;
std::string strHex = HexStr(ssGetUTXOResponse) + "\n"; std::string strHex = HexStr(ssGetUTXOResponse) + "\n";
@ -946,7 +946,7 @@ static bool rest_blockhash_by_height(const std::any& context, HTTPRequest* req,
} }
switch (rf) { switch (rf) {
case RESTResponseFormat::BINARY: { case RESTResponseFormat::BINARY: {
CDataStream ss_blockhash(SER_NETWORK, PROTOCOL_VERSION); DataStream ss_blockhash{};
ss_blockhash << pblockindex->GetBlockHash(); ss_blockhash << pblockindex->GetBlockHash();
req->WriteHeader("Content-Type", "application/octet-stream"); req->WriteHeader("Content-Type", "application/octet-stream");
req->WriteReply(HTTP_OK, ss_blockhash.str()); req->WriteReply(HTTP_OK, ss_blockhash.str());

2
src/rpc/blockchain.cpp
View file

@ -565,7 +565,7 @@ static RPCHelpMan getblockheader()
if (!fVerbose) if (!fVerbose)
{ {
CDataStream ssBlock(SER_NETWORK, PROTOCOL_VERSION); DataStream ssBlock{};
ssBlock << pblockindex->GetBlockHeader(); ssBlock << pblockindex->GetBlockHeader();
std::string strHex = HexStr(ssBlock); std::string strHex = HexStr(ssBlock);
return strHex; return strHex;

4
src/rpc/txoutproof.cpp
View file

@ -112,7 +112,7 @@ static RPCHelpMan gettxoutproof()
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Not all transactions found in specified or retrieved block"); throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Not all transactions found in specified or retrieved block");
} }
CDataStream ssMB(SER_NETWORK, PROTOCOL_VERSION | SERIALIZE_TRANSACTION_NO_WITNESS); DataStream ssMB{};
CMerkleBlock mb(block, setTxids); CMerkleBlock mb(block, setTxids);
ssMB << mb; ssMB << mb;
std::string strHex = HexStr(ssMB); std::string strHex = HexStr(ssMB);
@ -138,7 +138,7 @@ static RPCHelpMan verifytxoutproof()
RPCExamples{""}, RPCExamples{""},
[&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
{ {
CDataStream ssMB(ParseHexV(request.params[0], "proof"), SER_NETWORK, PROTOCOL_VERSION | SERIALIZE_TRANSACTION_NO_WITNESS); DataStream ssMB{ParseHexV(request.params[0], "proof")};
CMerkleBlock merkleBlock; CMerkleBlock merkleBlock;
ssMB >> merkleBlock; ssMB >> merkleBlock;

6
src/test/blockencodings_tests.cpp
View file

@ -310,7 +310,7 @@ BOOST_AUTO_TEST_CASE(TransactionsRequestSerializationTest) {
req1.indexes[2] = 3; req1.indexes[2] = 3;
req1.indexes[3] = 4; req1.indexes[3] = 4;
CDataStream stream(SER_NETWORK, PROTOCOL_VERSION); DataStream stream{};
stream << req1; stream << req1;
BlockTransactionsRequest req2; BlockTransactionsRequest req2;
@ -330,7 +330,7 @@ BOOST_AUTO_TEST_CASE(TransactionsRequestDeserializationMaxTest) {
req0.blockhash = InsecureRand256(); req0.blockhash = InsecureRand256();
req0.indexes.resize(1); req0.indexes.resize(1);
req0.indexes[0] = 0xffff; req0.indexes[0] = 0xffff;
CDataStream stream(SER_NETWORK, PROTOCOL_VERSION); DataStream stream{};
stream << req0; stream << req0;
BlockTransactionsRequest req1; BlockTransactionsRequest req1;
@ -350,7 +350,7 @@ BOOST_AUTO_TEST_CASE(TransactionsRequestDeserializationOverflowTest) {
req0.indexes[0] = 0x7000; req0.indexes[0] = 0x7000;
req0.indexes[1] = 0x10000 - 0x7000 - 2; req0.indexes[1] = 0x10000 - 0x7000 - 2;
req0.indexes[2] = 0; req0.indexes[2] = 0;
CDataStream stream(SER_NETWORK, PROTOCOL_VERSION); DataStream stream{};
stream << req0.blockhash; stream << req0.blockhash;
WriteCompactSize(stream, req0.indexes.size()); WriteCompactSize(stream, req0.indexes.size());
WriteCompactSize(stream, req0.indexes[0]); WriteCompactSize(stream, req0.indexes[0]);

2
src/test/blockfilter_tests.cpp
View file

@ -110,7 +110,7 @@ BOOST_AUTO_TEST_CASE(blockfilter_basic_test)
// Test serialization/unserialization. // Test serialization/unserialization.
BlockFilter block_filter2; BlockFilter block_filter2;
CDataStream stream(SER_NETWORK, PROTOCOL_VERSION); DataStream stream{};
stream << block_filter; stream << block_filter;
stream >> block_filter2; stream >> block_filter2;

8
src/test/bloom_tests.cpp
View file

@ -39,7 +39,7 @@ BOOST_AUTO_TEST_CASE(bloom_create_insert_serialize)
filter.insert(ParseHex("b9300670b4c5366e95b2699e8b18bc75e5f729c5")); filter.insert(ParseHex("b9300670b4c5366e95b2699e8b18bc75e5f729c5"));
BOOST_CHECK_MESSAGE(filter.contains(ParseHex("b9300670b4c5366e95b2699e8b18bc75e5f729c5")), "Bloom filter doesn't contain just-inserted object (3)!"); BOOST_CHECK_MESSAGE(filter.contains(ParseHex("b9300670b4c5366e95b2699e8b18bc75e5f729c5")), "Bloom filter doesn't contain just-inserted object (3)!");
CDataStream stream(SER_NETWORK, PROTOCOL_VERSION); DataStream stream{};
stream << filter; stream << filter;
std::vector<uint8_t> expected = ParseHex("03614e9b050000000000000001"); std::vector<uint8_t> expected = ParseHex("03614e9b050000000000000001");
@ -66,7 +66,7 @@ BOOST_AUTO_TEST_CASE(bloom_create_insert_serialize_with_tweak)
filter.insert(ParseHex("b9300670b4c5366e95b2699e8b18bc75e5f729c5")); filter.insert(ParseHex("b9300670b4c5366e95b2699e8b18bc75e5f729c5"));
BOOST_CHECK_MESSAGE(filter.contains(ParseHex("b9300670b4c5366e95b2699e8b18bc75e5f729c5")), "Bloom filter doesn't contain just-inserted object (3)!"); BOOST_CHECK_MESSAGE(filter.contains(ParseHex("b9300670b4c5366e95b2699e8b18bc75e5f729c5")), "Bloom filter doesn't contain just-inserted object (3)!");
CDataStream stream(SER_NETWORK, PROTOCOL_VERSION); DataStream stream{};
stream << filter; stream << filter;
std::vector<uint8_t> expected = ParseHex("03ce4299050000000100008001"); std::vector<uint8_t> expected = ParseHex("03ce4299050000000100008001");
@ -87,7 +87,7 @@ BOOST_AUTO_TEST_CASE(bloom_create_insert_key)
uint160 hash = pubkey.GetID(); uint160 hash = pubkey.GetID();
filter.insert(hash); filter.insert(hash);
CDataStream stream(SER_NETWORK, PROTOCOL_VERSION); DataStream stream{};
stream << filter; stream << filter;
std::vector<unsigned char> expected = ParseHex("038fc16b080000000000000001"); std::vector<unsigned char> expected = ParseHex("038fc16b080000000000000001");
@ -340,7 +340,7 @@ BOOST_AUTO_TEST_CASE(merkle_block_3_and_serialize)
for (unsigned int i = 0; i < vMatched.size(); i++) for (unsigned int i = 0; i < vMatched.size(); i++)
BOOST_CHECK(vMatched[i] == merkleBlock.vMatchedTxn[i].second); BOOST_CHECK(vMatched[i] == merkleBlock.vMatchedTxn[i].second);
CDataStream merkleStream(SER_NETWORK, PROTOCOL_VERSION); DataStream merkleStream{};
merkleStream << merkleBlock; merkleStream << merkleBlock;
std::vector<uint8_t> expected = ParseHex("0100000079cda856b143d9db2c1caff01d1aecc8630d30625d10e8b4b8b0000000000000b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f196367291b4d4c86041b8fa45d630100000001b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f19630101"); std::vector<uint8_t> expected = ParseHex("0100000079cda856b143d9db2c1caff01d1aecc8630d30625d10e8b4b8b0000000000000b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f196367291b4d4c86041b8fa45d630100000001b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f19630101");

12
src/test/coins_tests.cpp
View file

@ -498,7 +498,7 @@ BOOST_AUTO_TEST_CASE(updatecoins_simulation_test)
BOOST_AUTO_TEST_CASE(ccoins_serialization) BOOST_AUTO_TEST_CASE(ccoins_serialization)
{ {
// Good example // Good example
CDataStream ss1(ParseHex("97f23c835800816115944e077fe7c803cfa57f29b36bf87c1d35"), SER_DISK, CLIENT_VERSION); DataStream ss1{ParseHex("97f23c835800816115944e077fe7c803cfa57f29b36bf87c1d35")};
Coin cc1; Coin cc1;
ss1 >> cc1; ss1 >> cc1;
BOOST_CHECK_EQUAL(cc1.fCoinBase, false); BOOST_CHECK_EQUAL(cc1.fCoinBase, false);
@ -507,7 +507,7 @@ BOOST_AUTO_TEST_CASE(ccoins_serialization)
BOOST_CHECK_EQUAL(HexStr(cc1.out.scriptPubKey), HexStr(GetScriptForDestination(PKHash(uint160(ParseHex("816115944e077fe7c803cfa57f29b36bf87c1d35")))))); BOOST_CHECK_EQUAL(HexStr(cc1.out.scriptPubKey), HexStr(GetScriptForDestination(PKHash(uint160(ParseHex("816115944e077fe7c803cfa57f29b36bf87c1d35"))))));
// Good example // Good example
CDataStream ss2(ParseHex("8ddf77bbd123008c988f1a4a4de2161e0f50aac7f17e7f9555caa4"), SER_DISK, CLIENT_VERSION); DataStream ss2{ParseHex("8ddf77bbd123008c988f1a4a4de2161e0f50aac7f17e7f9555caa4")};
Coin cc2; Coin cc2;
ss2 >> cc2; ss2 >> cc2;
BOOST_CHECK_EQUAL(cc2.fCoinBase, true); BOOST_CHECK_EQUAL(cc2.fCoinBase, true);
@ -516,7 +516,7 @@ BOOST_AUTO_TEST_CASE(ccoins_serialization)
BOOST_CHECK_EQUAL(HexStr(cc2.out.scriptPubKey), HexStr(GetScriptForDestination(PKHash(uint160(ParseHex("8c988f1a4a4de2161e0f50aac7f17e7f9555caa4")))))); BOOST_CHECK_EQUAL(HexStr(cc2.out.scriptPubKey), HexStr(GetScriptForDestination(PKHash(uint160(ParseHex("8c988f1a4a4de2161e0f50aac7f17e7f9555caa4"))))));
// Smallest possible example // Smallest possible example
CDataStream ss3(ParseHex("000006"), SER_DISK, CLIENT_VERSION); DataStream ss3{ParseHex("000006")};
Coin cc3; Coin cc3;
ss3 >> cc3; ss3 >> cc3;
BOOST_CHECK_EQUAL(cc3.fCoinBase, false); BOOST_CHECK_EQUAL(cc3.fCoinBase, false);
@ -525,7 +525,7 @@ BOOST_AUTO_TEST_CASE(ccoins_serialization)
BOOST_CHECK_EQUAL(cc3.out.scriptPubKey.size(), 0U); BOOST_CHECK_EQUAL(cc3.out.scriptPubKey.size(), 0U);
// scriptPubKey that ends beyond the end of the stream // scriptPubKey that ends beyond the end of the stream
CDataStream ss4(ParseHex("000007"), SER_DISK, CLIENT_VERSION); DataStream ss4{ParseHex("000007")};
try { try {
Coin cc4; Coin cc4;
ss4 >> cc4; ss4 >> cc4;
@ -534,11 +534,11 @@ BOOST_AUTO_TEST_CASE(ccoins_serialization)
} }
// Very large scriptPubKey (3*10^9 bytes) past the end of the stream // Very large scriptPubKey (3*10^9 bytes) past the end of the stream
CDataStream tmp(SER_DISK, CLIENT_VERSION); DataStream tmp{};
uint64_t x = 3000000000ULL; uint64_t x = 3000000000ULL;
tmp << VARINT(x); tmp << VARINT(x);
BOOST_CHECK_EQUAL(HexStr(tmp), "8a95c0bb00"); BOOST_CHECK_EQUAL(HexStr(tmp), "8a95c0bb00");
CDataStream ss5(ParseHex("00008a95c0bb00"), SER_DISK, CLIENT_VERSION); DataStream ss5{ParseHex("00008a95c0bb00")};
try { try {
Coin cc5; Coin cc5;
ss5 >> cc5; ss5 >> cc5;

4
src/test/crypto_tests.cpp
View file

@ -925,7 +925,7 @@ BOOST_AUTO_TEST_CASE(muhash_tests)
// Test MuHash3072 serialization // Test MuHash3072 serialization
MuHash3072 serchk = FromInt(1); serchk *= FromInt(2); MuHash3072 serchk = FromInt(1); serchk *= FromInt(2);
std::string ser_exp = "1fa093295ea30a6a3acdc7b3f770fa538eff537528e990e2910e40bbcfd7f6696b1256901929094694b56316de342f593303dd12ac43e06dce1be1ff8301c845beb15468fff0ef002dbf80c29f26e6452bccc91b5cb9437ad410d2a67ea847887fa3c6a6553309946880fe20db2c73fe0641adbd4e86edfee0d9f8cd0ee1230898873dc13ed8ddcaf045c80faa082774279007a2253f8922ee3ef361d378a6af3ddaf180b190ac97e556888c36b3d1fb1c85aab9ccd46e3deaeb7b7cf5db067a7e9ff86b658cf3acd6662bbcce37232daa753c48b794356c020090c831a8304416e2aa7ad633c0ddb2f11be1be316a81be7f7e472071c042cb68faef549c221ebff209273638b741aba5a81675c45a5fa92fea4ca821d7a324cb1e1a2ccd3b76c4228ec8066dad2a5df6e1bd0de45c7dd5de8070bdb46db6c554cf9aefc9b7b2bbf9f75b1864d9f95005314593905c0109b71f703d49944ae94477b51dac10a816bb6d1c700bafabc8bd86fac8df24be519a2f2836b16392e18036cb13e48c5c010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; std::string ser_exp = "1fa093295ea30a6a3acdc7b3f770fa538eff537528e990e2910e40bbcfd7f6696b1256901929094694b56316de342f593303dd12ac43e06dce1be1ff8301c845beb15468fff0ef002dbf80c29f26e6452bccc91b5cb9437ad410d2a67ea847887fa3c6a6553309946880fe20db2c73fe0641adbd4e86edfee0d9f8cd0ee1230898873dc13ed8ddcaf045c80faa082774279007a2253f8922ee3ef361d378a6af3ddaf180b190ac97e556888c36b3d1fb1c85aab9ccd46e3deaeb7b7cf5db067a7e9ff86b658cf3acd6662bbcce37232daa753c48b794356c020090c831a8304416e2aa7ad633c0ddb2f11be1be316a81be7f7e472071c042cb68faef549c221ebff209273638b741aba5a81675c45a5fa92fea4ca821d7a324cb1e1a2ccd3b76c4228ec8066dad2a5df6e1bd0de45c7dd5de8070bdb46db6c554cf9aefc9b7b2bbf9f75b1864d9f95005314593905c0109b71f703d49944ae94477b51dac10a816bb6d1c700bafabc8bd86fac8df24be519a2f2836b16392e18036cb13e48c5c010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
CDataStream ss_chk(SER_DISK, PROTOCOL_VERSION); DataStream ss_chk{};
ss_chk << serchk; ss_chk << serchk;
BOOST_CHECK_EQUAL(ser_exp, HexStr(ss_chk.str())); BOOST_CHECK_EQUAL(ser_exp, HexStr(ss_chk.str()));
@ -938,7 +938,7 @@ BOOST_AUTO_TEST_CASE(muhash_tests)
BOOST_CHECK_EQUAL(HexStr(out), HexStr(out3)); BOOST_CHECK_EQUAL(HexStr(out), HexStr(out3));
// Test MuHash3072 overflow, meaning the internal data is larger than the modulus. // Test MuHash3072 overflow, meaning the internal data is larger than the modulus.
CDataStream ss_max(ParseHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"), SER_DISK, PROTOCOL_VERSION); DataStream ss_max{ParseHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")};
MuHash3072 overflowchk; MuHash3072 overflowchk;
ss_max >> overflowchk; ss_max >> overflowchk;

6
src/test/fuzz/integer.cpp
View file

@ -152,7 +152,7 @@ FUZZ_TARGET_INIT(integer, initialize_integer)
const CScriptID script_id{u160}; const CScriptID script_id{u160};
{ {
CDataStream stream(SER_NETWORK, INIT_PROTO_VERSION); DataStream stream{};
uint256 deserialized_u256; uint256 deserialized_u256;
stream << u256; stream << u256;
@ -217,7 +217,7 @@ FUZZ_TARGET_INIT(integer, initialize_integer)
} }
{ {
CDataStream stream(SER_NETWORK, INIT_PROTO_VERSION); DataStream stream{};
ser_writedata64(stream, u64); ser_writedata64(stream, u64);
const uint64_t deserialized_u64 = ser_readdata64(stream); const uint64_t deserialized_u64 = ser_readdata64(stream);
@ -245,7 +245,7 @@ FUZZ_TARGET_INIT(integer, initialize_integer)
} }
{ {
CDataStream stream(SER_NETWORK, INIT_PROTO_VERSION); DataStream stream{};
WriteCompactSize(stream, u64); WriteCompactSize(stream, u64);
try { try {

2
src/test/fuzz/key.cpp
View file

@ -111,7 +111,7 @@ FUZZ_TARGET_INIT(key, initialize_key)
} }
{ {
CDataStream data_stream{SER_NETWORK, INIT_PROTO_VERSION}; DataStream data_stream{};
pubkey.Serialize(data_stream); pubkey.Serialize(data_stream);
CPubKey pubkey_deserialized; CPubKey pubkey_deserialized;

4
src/test/fuzz/prevector.cpp
View file

@ -59,8 +59,8 @@ public:
--pos; --pos;
assert(v == real_vector[pos]); assert(v == real_vector[pos]);
} }
CDataStream ss1(SER_DISK, 0); DataStream ss1{};
CDataStream ss2(SER_DISK, 0); DataStream ss2{};
ss1 << real_vector; ss1 << real_vector;
ss2 << pre_vector; ss2 << pre_vector;
assert(ss1.size() == ss2.size()); assert(ss1.size() == ss2.size());

2
src/test/fuzz/rpc.cpp
View file

@ -253,7 +253,7 @@ std::string ConsumeScalarRPCArgument(FuzzedDataProvider& fuzzed_data_provider)
if (!opt_block_header) { if (!opt_block_header) {
return; return;
} }
CDataStream data_stream{SER_NETWORK, PROTOCOL_VERSION}; DataStream data_stream{};
data_stream << *opt_block_header; data_stream << *opt_block_header;
r = HexStr(data_stream); r = HexStr(data_stream);
}, },

4
src/test/fuzz/string.cpp
View file

@ -196,7 +196,7 @@ FUZZ_TARGET(string)
} }
{ {
CDataStream data_stream{SER_NETWORK, INIT_PROTO_VERSION}; DataStream data_stream{};
std::string s; std::string s;
auto limited_string = LIMITED_STRING(s, 10); auto limited_string = LIMITED_STRING(s, 10);
data_stream << random_string_1; data_stream << random_string_1;
@ -212,7 +212,7 @@ FUZZ_TARGET(string)
} }
} }
{ {
CDataStream data_stream{SER_NETWORK, INIT_PROTO_VERSION}; DataStream data_stream{};
const auto limited_string = LIMITED_STRING(random_string_1, 10); const auto limited_string = LIMITED_STRING(random_string_1, 10);
data_stream << limited_string; data_stream << limited_string;
std::string deserialized_string; std::string deserialized_string;

5
src/test/fuzz/tx_in.cpp
View file

@ -14,12 +14,9 @@
FUZZ_TARGET(tx_in) FUZZ_TARGET(tx_in)
{ {
CDataStream ds(buffer, SER_NETWORK, INIT_PROTO_VERSION); DataStream ds{buffer};
CTxIn tx_in; CTxIn tx_in;
try { try {
int version;
ds >> version;
ds.SetVersion(version);
ds >> tx_in; ds >> tx_in;
} catch (const std::ios_base::failure&) { } catch (const std::ios_base::failure&) {
return; return;

5
src/test/fuzz/tx_out.cpp
View file

@ -13,12 +13,9 @@
FUZZ_TARGET(tx_out) FUZZ_TARGET(tx_out)
{ {
CDataStream ds(buffer, SER_NETWORK, INIT_PROTO_VERSION); DataStream ds{buffer};
CTxOut tx_out; CTxOut tx_out;
try { try {
int version;
ds >> version;
ds.SetVersion(version);
ds >> tx_out; ds >> tx_out;
} catch (const std::ios_base::failure&) { } catch (const std::ios_base::failure&) {
return; return;

4
src/test/key_tests.cpp
View file

@ -233,7 +233,7 @@ BOOST_AUTO_TEST_CASE(key_key_negation)
static CPubKey UnserializePubkey(const std::vector<uint8_t>& data) static CPubKey UnserializePubkey(const std::vector<uint8_t>& data)
{ {
CDataStream stream{SER_NETWORK, INIT_PROTO_VERSION}; DataStream stream{};
stream << data; stream << data;
CPubKey pubkey; CPubKey pubkey;
stream >> pubkey; stream >> pubkey;
@ -251,7 +251,7 @@ static unsigned int GetLen(unsigned char chHeader)
static void CmpSerializationPubkey(const CPubKey& pubkey) static void CmpSerializationPubkey(const CPubKey& pubkey)
{ {
CDataStream stream{SER_NETWORK, INIT_PROTO_VERSION}; DataStream stream{};
stream << pubkey; stream << pubkey;
CPubKey pubkey2; CPubKey pubkey2;
stream >> pubkey2; stream >> pubkey2;

2
src/test/pmt_tests.cpp
View file

@ -69,7 +69,7 @@ BOOST_AUTO_TEST_CASE(pmt_test1)
CPartialMerkleTree pmt1(vTxid, vMatch); CPartialMerkleTree pmt1(vTxid, vMatch);
// serialize // serialize
CDataStream ss(SER_NETWORK, PROTOCOL_VERSION); DataStream ss{};
ss << pmt1; ss << pmt1;
// verify CPartialMerkleTree's size guarantees // verify CPartialMerkleTree's size guarantees

4
src/test/prevector_tests.cpp
View file

@ -66,8 +66,8 @@ class prevector_tester {
for (const T& v : reverse_iterate(const_pre_vector)) { for (const T& v : reverse_iterate(const_pre_vector)) {
local_check(v == real_vector[--pos]); local_check(v == real_vector[--pos]);
} }
CDataStream ss1(SER_DISK, 0); DataStream ss1{};
CDataStream ss2(SER_DISK, 0); DataStream ss2{};
ss1 << real_vector; ss1 << real_vector;
ss2 << pre_vector; ss2 << pre_vector;
local_check_equal(ss1.size(), ss2.size()); local_check_equal(ss1.size(), ss2.size());

2
src/test/serfloat_tests.cpp
View file

@ -111,7 +111,7 @@ Python code to generate the below hashes:
*/ */
BOOST_AUTO_TEST_CASE(doubles) BOOST_AUTO_TEST_CASE(doubles)
{ {
CDataStream ss(SER_DISK, 0); DataStream ss{};
// encode // encode
for (int i = 0; i < 1000; i++) { for (int i = 0; i < 1000; i++) {
ss << EncodeDouble(i); ss << EncodeDouble(i);

10
src/test/serialize_tests.cpp
View file

@ -90,8 +90,8 @@ BOOST_AUTO_TEST_CASE(varints)
{ {
// encode // encode
CDataStream ss(SER_DISK, 0); DataStream ss{};
CDataStream::size_type size = 0; DataStream::size_type size = 0;
for (int i = 0; i < 100000; i++) { for (int i = 0; i < 100000; i++) {
ss << VARINT_MODE(i, VarIntMode::NONNEGATIVE_SIGNED); ss << VARINT_MODE(i, VarIntMode::NONNEGATIVE_SIGNED);
size += ::GetSerializeSize(VARINT_MODE(i, VarIntMode::NONNEGATIVE_SIGNED), 0); size += ::GetSerializeSize(VARINT_MODE(i, VarIntMode::NONNEGATIVE_SIGNED), 0);
@ -120,7 +120,7 @@ BOOST_AUTO_TEST_CASE(varints)
BOOST_AUTO_TEST_CASE(varints_bitpatterns) BOOST_AUTO_TEST_CASE(varints_bitpatterns)
{ {
CDataStream ss(SER_DISK, 0); DataStream ss{};
ss << VARINT_MODE(0, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "00"); ss.clear(); ss << VARINT_MODE(0, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "00"); ss.clear();
ss << VARINT_MODE(0x7f, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "7f"); ss.clear(); ss << VARINT_MODE(0x7f, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "7f"); ss.clear();
ss << VARINT_MODE(int8_t{0x7f}, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "7f"); ss.clear(); ss << VARINT_MODE(int8_t{0x7f}, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "7f"); ss.clear();
@ -141,7 +141,7 @@ BOOST_AUTO_TEST_CASE(varints_bitpatterns)
BOOST_AUTO_TEST_CASE(compactsize) BOOST_AUTO_TEST_CASE(compactsize)
{ {
CDataStream ss(SER_DISK, 0); DataStream ss{};
std::vector<char>::size_type i, j; std::vector<char>::size_type i, j;
for (i = 1; i <= MAX_SIZE; i *= 2) for (i = 1; i <= MAX_SIZE; i *= 2)
@ -182,7 +182,7 @@ BOOST_AUTO_TEST_CASE(noncanonical)
{ {
// Write some non-canonical CompactSize encodings, and // Write some non-canonical CompactSize encodings, and
// make sure an exception is thrown when read back. // make sure an exception is thrown when read back.
CDataStream ss(SER_DISK, 0); DataStream ss{};
std::vector<char>::size_type n; std::vector<char>::size_type n;
// zero encoded with three bytes: // zero encoded with three bytes:

14
src/test/streams_tests.cpp
View file

@ -128,9 +128,9 @@ BOOST_AUTO_TEST_CASE(streams_vector_reader_rvalue)
BOOST_AUTO_TEST_CASE(bitstream_reader_writer) BOOST_AUTO_TEST_CASE(bitstream_reader_writer)
{ {
CDataStream data(SER_NETWORK, INIT_PROTO_VERSION); DataStream data{};
BitStreamWriter<CDataStream> bit_writer(data); BitStreamWriter bit_writer{data};
bit_writer.Write(0, 1); bit_writer.Write(0, 1);
bit_writer.Write(2, 2); bit_writer.Write(2, 2);
bit_writer.Write(6, 3); bit_writer.Write(6, 3);
@ -141,7 +141,7 @@ BOOST_AUTO_TEST_CASE(bitstream_reader_writer)
bit_writer.Write(30497, 16); bit_writer.Write(30497, 16);
bit_writer.Flush(); bit_writer.Flush();
CDataStream data_copy(data); DataStream data_copy{data};
uint32_t serialized_int1; uint32_t serialized_int1;
data >> serialized_int1; data >> serialized_int1;
BOOST_CHECK_EQUAL(serialized_int1, uint32_t{0x7700C35A}); // NOTE: Serialized as LE BOOST_CHECK_EQUAL(serialized_int1, uint32_t{0x7700C35A}); // NOTE: Serialized as LE
@ -149,7 +149,7 @@ BOOST_AUTO_TEST_CASE(bitstream_reader_writer)
data >> serialized_int2; data >> serialized_int2;
BOOST_CHECK_EQUAL(serialized_int2, uint16_t{0x1072}); // NOTE: Serialized as LE BOOST_CHECK_EQUAL(serialized_int2, uint16_t{0x1072}); // NOTE: Serialized as LE
BitStreamReader<CDataStream> bit_reader(data_copy); BitStreamReader bit_reader{data_copy};
BOOST_CHECK_EQUAL(bit_reader.Read(1), 0U); BOOST_CHECK_EQUAL(bit_reader.Read(1), 0U);
BOOST_CHECK_EQUAL(bit_reader.Read(2), 2U); BOOST_CHECK_EQUAL(bit_reader.Read(2), 2U);
BOOST_CHECK_EQUAL(bit_reader.Read(3), 6U); BOOST_CHECK_EQUAL(bit_reader.Read(3), 6U);
@ -167,7 +167,7 @@ BOOST_AUTO_TEST_CASE(streams_serializedata_xor)
// Degenerate case // Degenerate case
{ {
CDataStream ds{in, 0, 0}; DataStream ds{in};
ds.Xor({0x00, 0x00}); ds.Xor({0x00, 0x00});
BOOST_CHECK_EQUAL(""s, ds.str()); BOOST_CHECK_EQUAL(""s, ds.str());
} }
@ -177,7 +177,7 @@ BOOST_AUTO_TEST_CASE(streams_serializedata_xor)
// Single character key // Single character key
{ {
CDataStream ds{in, 0, 0}; DataStream ds{in};
ds.Xor({0xff}); ds.Xor({0xff});
BOOST_CHECK_EQUAL("\xf0\x0f"s, ds.str()); BOOST_CHECK_EQUAL("\xf0\x0f"s, ds.str());
} }
@ -189,7 +189,7 @@ BOOST_AUTO_TEST_CASE(streams_serializedata_xor)
in.push_back(std::byte{0x0f}); in.push_back(std::byte{0x0f});
{ {
CDataStream ds{in, 0, 0}; DataStream ds{in};
ds.Xor({0xff, 0x0f}); ds.Xor({0xff, 0x0f});
BOOST_CHECK_EQUAL("\x0f\x00"s, ds.str()); BOOST_CHECK_EQUAL("\x0f\x00"s, ds.str());
} }

2
src/test/uint256_tests.cpp
View file

@ -187,7 +187,7 @@ BOOST_AUTO_TEST_CASE( methods ) // GetHex SetHex begin() end() size() GetLow64 G
BOOST_CHECK(GetSerializeSize(R1L, PROTOCOL_VERSION) == 32); BOOST_CHECK(GetSerializeSize(R1L, PROTOCOL_VERSION) == 32);
BOOST_CHECK(GetSerializeSize(ZeroL, PROTOCOL_VERSION) == 32); BOOST_CHECK(GetSerializeSize(ZeroL, PROTOCOL_VERSION) == 32);
CDataStream ss(0, PROTOCOL_VERSION); DataStream ss{};
ss << R1L; ss << R1L;
BOOST_CHECK(ss.str() == std::string(R1Array,R1Array+32)); BOOST_CHECK(ss.str() == std::string(R1Array,R1Array+32));
ss >> TmpL; ss >> TmpL;

16
src/wallet/bdb.cpp
View file

@ -479,8 +479,8 @@ bool BerkeleyDatabase::Rewrite(const char* pszSkip)
std::unique_ptr<DatabaseCursor> cursor = db.GetNewCursor(); std::unique_ptr<DatabaseCursor> cursor = db.GetNewCursor();
if (cursor) { if (cursor) {
while (fSuccess) { while (fSuccess) {
CDataStream ssKey(SER_DISK, CLIENT_VERSION); DataStream ssKey{};
CDataStream ssValue(SER_DISK, CLIENT_VERSION); DataStream ssValue{};
DatabaseCursor::Status ret1 = cursor->Next(ssKey, ssValue); DatabaseCursor::Status ret1 = cursor->Next(ssKey, ssValue);
if (ret1 == DatabaseCursor::Status::DONE) { if (ret1 == DatabaseCursor::Status::DONE) {
break; break;
@ -667,7 +667,7 @@ BerkeleyCursor::BerkeleyCursor(BerkeleyDatabase& database)
} }
} }
DatabaseCursor::Status BerkeleyCursor::Next(CDataStream& ssKey, CDataStream& ssValue) DatabaseCursor::Status BerkeleyCursor::Next(DataStream& ssKey, DataStream& ssValue)
{ {
if (m_cursor == nullptr) return Status::FAIL; if (m_cursor == nullptr) return Status::FAIL;
// Read at cursor // Read at cursor
@ -682,10 +682,8 @@ DatabaseCursor::Status BerkeleyCursor::Next(CDataStream& ssKey, CDataStream& ssV
} }
// Convert to streams // Convert to streams
ssKey.SetType(SER_DISK);
ssKey.clear(); ssKey.clear();
ssKey.write({AsBytePtr(datKey.get_data()), datKey.get_size()}); ssKey.write({AsBytePtr(datKey.get_data()), datKey.get_size()});
ssValue.SetType(SER_DISK);
ssValue.clear(); ssValue.clear();
ssValue.write({AsBytePtr(datValue.get_data()), datValue.get_size()}); ssValue.write({AsBytePtr(datValue.get_data()), datValue.get_size()});
return Status::MORE; return Status::MORE;
@ -755,7 +753,7 @@ std::string BerkeleyDatabaseVersion()
return DbEnv::version(nullptr, nullptr, nullptr); return DbEnv::version(nullptr, nullptr, nullptr);
} }
bool BerkeleyBatch::ReadKey(CDataStream&& key, CDataStream& value) bool BerkeleyBatch::ReadKey(DataStream&& key, DataStream& value)
{ {
if (!pdb) if (!pdb)
return false; return false;
@ -771,7 +769,7 @@ bool BerkeleyBatch::ReadKey(CDataStream&& key, CDataStream& value)
return false; return false;
} }
bool BerkeleyBatch::WriteKey(CDataStream&& key, CDataStream&& value, bool overwrite) bool BerkeleyBatch::WriteKey(DataStream&& key, DataStream&& value, bool overwrite)
{ {
if (!pdb) if (!pdb)
return false; return false;
@ -786,7 +784,7 @@ bool BerkeleyBatch::WriteKey(CDataStream&& key, CDataStream&& value, bool overwr
return (ret == 0); return (ret == 0);
} }
bool BerkeleyBatch::EraseKey(CDataStream&& key) bool BerkeleyBatch::EraseKey(DataStream&& key)
{ {
if (!pdb) if (!pdb)
return false; return false;
@ -799,7 +797,7 @@ bool BerkeleyBatch::EraseKey(CDataStream&& key)
return (ret == 0 || ret == DB_NOTFOUND); return (ret == 0 || ret == DB_NOTFOUND);
} }
bool BerkeleyBatch::HasKey(CDataStream&& key) bool BerkeleyBatch::HasKey(DataStream&& key)
{ {
if (!pdb) if (!pdb)
return false; return false;

10
src/wallet/bdb.h
View file

@ -194,17 +194,17 @@ public:
explicit BerkeleyCursor(BerkeleyDatabase& database); explicit BerkeleyCursor(BerkeleyDatabase& database);
~BerkeleyCursor() override; ~BerkeleyCursor() override;
Status Next(CDataStream& key, CDataStream& value) override; Status Next(DataStream& key, DataStream& value) override;
}; };
/** RAII class that provides access to a Berkeley database */ /** RAII class that provides access to a Berkeley database */
class BerkeleyBatch : public DatabaseBatch class BerkeleyBatch : public DatabaseBatch
{ {
private: private:
bool ReadKey(CDataStream&& key, CDataStream& value) override; bool ReadKey(DataStream&& key, DataStream& value) override;
bool WriteKey(CDataStream&& key, CDataStream&& value, bool overwrite = true) override; bool WriteKey(DataStream&& key, DataStream&& value, bool overwrite = true) override;
bool EraseKey(CDataStream&& key) override; bool EraseKey(DataStream&& key) override;
bool HasKey(CDataStream&& key) override; bool HasKey(DataStream&& key) override;
protected: protected:
Db* pdb; Db* pdb;

28
src/wallet/db.h
View file

@ -38,17 +38,17 @@ public:
DONE, DONE,
}; };
virtual Status Next(CDataStream& key, CDataStream& value) { return Status::FAIL; } virtual Status Next(DataStream& key, DataStream& value) { return Status::FAIL; }
}; };
/** RAII class that provides access to a WalletDatabase */ /** RAII class that provides access to a WalletDatabase */
class DatabaseBatch class DatabaseBatch
{ {
private: private:
virtual bool ReadKey(CDataStream&& key, CDataStream& value) = 0; virtual bool ReadKey(DataStream&& key, DataStream& value) = 0;
virtual bool WriteKey(CDataStream&& key, CDataStream&& value, bool overwrite=true) = 0; virtual bool WriteKey(DataStream&& key, DataStream&& value, bool overwrite = true) = 0;
virtual bool EraseKey(CDataStream&& key) = 0; virtual bool EraseKey(DataStream&& key) = 0;
virtual bool HasKey(CDataStream&& key) = 0; virtual bool HasKey(DataStream&& key) = 0;
public: public:
explicit DatabaseBatch() {} explicit DatabaseBatch() {}
@ -63,7 +63,7 @@ public:
template <typename K, typename T> template <typename K, typename T>
bool Read(const K& key, T& value) bool Read(const K& key, T& value)
{ {
CDataStream ssKey(SER_DISK, CLIENT_VERSION); DataStream ssKey{};
ssKey.reserve(1000); ssKey.reserve(1000);
ssKey << key; ssKey << key;
@ -80,7 +80,7 @@ public:
template <typename K, typename T> template <typename K, typename T>
bool Write(const K& key, const T& value, bool fOverwrite = true) bool Write(const K& key, const T& value, bool fOverwrite = true)
{ {
CDataStream ssKey(SER_DISK, CLIENT_VERSION); DataStream ssKey{};
ssKey.reserve(1000); ssKey.reserve(1000);
ssKey << key; ssKey << key;
@ -94,7 +94,7 @@ public:
template <typename K> template <typename K>
bool Erase(const K& key) bool Erase(const K& key)
{ {
CDataStream ssKey(SER_DISK, CLIENT_VERSION); DataStream ssKey{};
ssKey.reserve(1000); ssKey.reserve(1000);
ssKey << key; ssKey << key;
@ -104,7 +104,7 @@ public:
template <typename K> template <typename K>
bool Exists(const K& key) bool Exists(const K& key)
{ {
CDataStream ssKey(SER_DISK, CLIENT_VERSION); DataStream ssKey{};
ssKey.reserve(1000); ssKey.reserve(1000);
ssKey << key; ssKey << key;
@ -175,17 +175,17 @@ public:
class DummyCursor : public DatabaseCursor class DummyCursor : public DatabaseCursor
{ {
Status Next(CDataStream& key, CDataStream& value) override { return Status::FAIL; } Status Next(DataStream& key, DataStream& value) override { return Status::FAIL; }
}; };
/** RAII class that provides access to a DummyDatabase. Never fails. */ /** RAII class that provides access to a DummyDatabase. Never fails. */
class DummyBatch : public DatabaseBatch class DummyBatch : public DatabaseBatch
{ {
private: private:
bool ReadKey(CDataStream&& key, CDataStream& value) override { return true; } bool ReadKey(DataStream&& key, DataStream& value) override { return true; }
bool WriteKey(CDataStream&& key, CDataStream&& value, bool overwrite=true) override { return true; } bool WriteKey(DataStream&& key, DataStream&& value, bool overwrite = true) override { return true; }
bool EraseKey(CDataStream&& key) override { return true; } bool EraseKey(DataStream&& key) override { return true; }
bool HasKey(CDataStream&& key) override { return true; } bool HasKey(DataStream&& key) override { return true; }
public: public:
void Flush() override {} void Flush() override {}

8
src/wallet/dump.cpp
View file

@ -67,8 +67,8 @@ bool DumpWallet(const ArgsManager& args, CWallet& wallet, bilingual_str& error)
// Read the records // Read the records
while (true) { while (true) {
CDataStream ss_key(SER_DISK, CLIENT_VERSION); DataStream ss_key{};
CDataStream ss_value(SER_DISK, CLIENT_VERSION); DataStream ss_value{};
DatabaseCursor::Status status = cursor->Next(ss_key, ss_value); DatabaseCursor::Status status = cursor->Next(ss_key, ss_value);
if (status == DatabaseCursor::Status::DONE) { if (status == DatabaseCursor::Status::DONE) {
ret = true; ret = true;
@ -255,8 +255,8 @@ bool CreateFromDump(const ArgsManager& args, const std::string& name, const fs::
std::vector<unsigned char> k = ParseHex(key); std::vector<unsigned char> k = ParseHex(key);
std::vector<unsigned char> v = ParseHex(value); std::vector<unsigned char> v = ParseHex(value);
CDataStream ss_key(k, SER_DISK, CLIENT_VERSION); DataStream ss_key{k};
CDataStream ss_value(v, SER_DISK, CLIENT_VERSION); DataStream ss_value{v};
if (!batch->Write(ss_key, ss_value)) { if (!batch->Write(ss_key, ss_value)) {
error = strprintf(_("Error: Unable to write record to new wallet")); error = strprintf(_("Error: Unable to write record to new wallet"));

2
src/wallet/rpc/backup.cpp
View file

@ -334,7 +334,7 @@ RPCHelpMan importprunedfunds()
} }
uint256 hashTx = tx.GetHash(); uint256 hashTx = tx.GetHash();
CDataStream ssMB(ParseHexV(request.params[1], "proof"), SER_NETWORK, PROTOCOL_VERSION); DataStream ssMB{ParseHexV(request.params[1], "proof")};
CMerkleBlock merkleBlock; CMerkleBlock merkleBlock;
ssMB >> merkleBlock; ssMB >> merkleBlock;

2
src/wallet/salvage.cpp
View file

@ -139,7 +139,7 @@ bool RecoverDatabaseFile(const ArgsManager& args, const fs::path& file_path, bil
for (KeyValPair& row : salvagedData) for (KeyValPair& row : salvagedData)
{ {
/* Filter for only private key type KV pairs to be added to the salvaged wallet */ /* Filter for only private key type KV pairs to be added to the salvaged wallet */
CDataStream ssKey(row.first, SER_DISK, CLIENT_VERSION); DataStream ssKey{row.first};
CDataStream ssValue(row.second, SER_DISK, CLIENT_VERSION); CDataStream ssValue(row.second, SER_DISK, CLIENT_VERSION);
std::string strType, strErr; std::string strType, strErr;
bool fReadOK; bool fReadOK;

10
src/wallet/sqlite.cpp
View file

@ -385,7 +385,7 @@ void SQLiteBatch::Close()
} }
} }
bool SQLiteBatch::ReadKey(CDataStream&& key, CDataStream& value) bool SQLiteBatch::ReadKey(DataStream&& key, DataStream& value)
{ {
if (!m_database.m_db) return false; if (!m_database.m_db) return false;
assert(m_read_stmt); assert(m_read_stmt);
@ -412,7 +412,7 @@ bool SQLiteBatch::ReadKey(CDataStream&& key, CDataStream& value)
return true; return true;
} }
bool SQLiteBatch::WriteKey(CDataStream&& key, CDataStream&& value, bool overwrite) bool SQLiteBatch::WriteKey(DataStream&& key, DataStream&& value, bool overwrite)
{ {
if (!m_database.m_db) return false; if (!m_database.m_db) return false;
assert(m_insert_stmt && m_overwrite_stmt); assert(m_insert_stmt && m_overwrite_stmt);
@ -439,7 +439,7 @@ bool SQLiteBatch::WriteKey(CDataStream&& key, CDataStream&& value, bool overwrit
return res == SQLITE_DONE; return res == SQLITE_DONE;
} }
bool SQLiteBatch::EraseKey(CDataStream&& key) bool SQLiteBatch::EraseKey(DataStream&& key)
{ {
if (!m_database.m_db) return false; if (!m_database.m_db) return false;
assert(m_delete_stmt); assert(m_delete_stmt);
@ -457,7 +457,7 @@ bool SQLiteBatch::EraseKey(CDataStream&& key)
return res == SQLITE_DONE; return res == SQLITE_DONE;
} }
bool SQLiteBatch::HasKey(CDataStream&& key) bool SQLiteBatch::HasKey(DataStream&& key)
{ {
if (!m_database.m_db) return false; if (!m_database.m_db) return false;
assert(m_read_stmt); assert(m_read_stmt);
@ -470,7 +470,7 @@ bool SQLiteBatch::HasKey(CDataStream&& key)
return res == SQLITE_ROW; return res == SQLITE_ROW;
} }
DatabaseCursor::Status SQLiteCursor::Next(CDataStream& key, CDataStream& value) DatabaseCursor::Status SQLiteCursor::Next(DataStream& key, DataStream& value)
{ {
int res = sqlite3_step(m_cursor_stmt); int res = sqlite3_step(m_cursor_stmt);
if (res == SQLITE_DONE) { if (res == SQLITE_DONE) {

10
src/wallet/sqlite.h
View file

@ -22,7 +22,7 @@ public:
explicit SQLiteCursor() {} explicit SQLiteCursor() {}
~SQLiteCursor() override; ~SQLiteCursor() override;
Status Next(CDataStream& key, CDataStream& value) override; Status Next(DataStream& key, DataStream& value) override;
}; };
/** RAII class that provides access to a WalletDatabase */ /** RAII class that provides access to a WalletDatabase */
@ -38,10 +38,10 @@ private:
void SetupSQLStatements(); void SetupSQLStatements();
bool ReadKey(CDataStream&& key, CDataStream& value) override; bool ReadKey(DataStream&& key, DataStream& value) override;
bool WriteKey(CDataStream&& key, CDataStream&& value, bool overwrite = true) override; bool WriteKey(DataStream&& key, DataStream&& value, bool overwrite = true) override;
bool EraseKey(CDataStream&& key) override; bool EraseKey(DataStream&& key) override;
bool HasKey(CDataStream&& key) override; bool HasKey(DataStream&& key) override;
public: public:
explicit SQLiteBatch(SQLiteDatabase& database); explicit SQLiteBatch(SQLiteDatabase& database);

4
src/wallet/test/util.cpp
View file

@ -57,8 +57,8 @@ std::unique_ptr<WalletDatabase> DuplicateMockDatabase(WalletDatabase& database,
// Read all records from the original database and write them to the new one // Read all records from the original database and write them to the new one
while (true) { while (true) {
CDataStream key(SER_DISK, CLIENT_VERSION); DataStream key{};
CDataStream value(SER_DISK, CLIENT_VERSION); DataStream value{};
DatabaseCursor::Status status = cursor->Next(key, value); DatabaseCursor::Status status = cursor->Next(key, value);
assert(status != DatabaseCursor::Status::FAIL); assert(status != DatabaseCursor::Status::FAIL);
if (status == DatabaseCursor::Status::DONE) break; if (status == DatabaseCursor::Status::DONE) break;

10
src/wallet/test/wallet_tests.cpp
View file

@ -910,7 +910,7 @@ BOOST_FIXTURE_TEST_CASE(ZapSelectTx, TestChain100Setup)
class FailCursor : public DatabaseCursor class FailCursor : public DatabaseCursor
{ {
public: public:
Status Next(CDataStream& key, CDataStream& value) override { return Status::FAIL; } Status Next(DataStream& key, DataStream& value) override { return Status::FAIL; }
}; };
/** RAII class that provides access to a FailDatabase. Which fails if needed. */ /** RAII class that provides access to a FailDatabase. Which fails if needed. */
@ -918,10 +918,10 @@ class FailBatch : public DatabaseBatch
{ {
private: private:
bool m_pass{true}; bool m_pass{true};
bool ReadKey(CDataStream&& key, CDataStream& value) override { return m_pass; } bool ReadKey(DataStream&& key, DataStream& value) override { return m_pass; }
bool WriteKey(CDataStream&& key, CDataStream&& value, bool overwrite=true) override { return m_pass; } bool WriteKey(DataStream&& key, DataStream&& value, bool overwrite = true) override { return m_pass; }
bool EraseKey(CDataStream&& key) override { return m_pass; } bool EraseKey(DataStream&& key) override { return m_pass; }
bool HasKey(CDataStream&& key) override { return m_pass; } bool HasKey(DataStream&& key) override { return m_pass; }
public: public:
explicit FailBatch(bool pass) : m_pass(pass) {} explicit FailBatch(bool pass) : m_pass(pass) {}

4
src/wallet/test/walletload_tests.cpp
View file

@ -58,8 +58,8 @@ bool HasAnyRecordOfType(WalletDatabase& db, const std::string& key)
std::unique_ptr<DatabaseCursor> cursor = batch->GetNewCursor(); std::unique_ptr<DatabaseCursor> cursor = batch->GetNewCursor();
BOOST_CHECK(cursor); BOOST_CHECK(cursor);
while (true) { while (true) {
CDataStream ssKey(SER_DISK, CLIENT_VERSION); DataStream ssKey{};
CDataStream ssValue(SER_DISK, CLIENT_VERSION); DataStream ssValue{};
DatabaseCursor::Status status = cursor->Next(ssKey, ssValue); DatabaseCursor::Status status = cursor->Next(ssKey, ssValue);
assert(status != DatabaseCursor::Status::FAIL); assert(status != DatabaseCursor::Status::FAIL);
if (status == DatabaseCursor::Status::DONE) break; if (status == DatabaseCursor::Status::DONE) break;

8
src/wallet/wallet.cpp
View file

@ -3783,8 +3783,8 @@ bool CWallet::MigrateToSQLite(bilingual_str& error)
} }
DatabaseCursor::Status status = DatabaseCursor::Status::FAIL; DatabaseCursor::Status status = DatabaseCursor::Status::FAIL;
while (true) { while (true) {
CDataStream ss_key(SER_DISK, CLIENT_VERSION); DataStream ss_key{};
CDataStream ss_value(SER_DISK, CLIENT_VERSION); DataStream ss_value{};
status = cursor->Next(ss_key, ss_value); status = cursor->Next(ss_key, ss_value);
if (status != DatabaseCursor::Status::MORE) { if (status != DatabaseCursor::Status::MORE) {
break; break;
@ -3821,8 +3821,8 @@ bool CWallet::MigrateToSQLite(bilingual_str& error)
bool began = batch->TxnBegin(); bool began = batch->TxnBegin();
assert(began); // This is a critical error, the new db could not be written to. The original db exists as a backup, but we should not continue execution. assert(began); // This is a critical error, the new db could not be written to. The original db exists as a backup, but we should not continue execution.
for (const auto& [key, value] : records) { for (const auto& [key, value] : records) {
CDataStream ss_key(key, SER_DISK, CLIENT_VERSION); DataStream ss_key{key};
CDataStream ss_value(value, SER_DISK, CLIENT_VERSION); DataStream ss_value{value};
if (!batch->Write(ss_key, ss_value)) { if (!batch->Write(ss_key, ss_value)) {
batch->TxnAbort(); batch->TxnAbort();
m_database->Close(); m_database->Close();

14
src/wallet/walletdb.cpp
View file

@ -321,7 +321,7 @@ public:
}; };
static bool static bool
ReadKeyValue(CWallet* pwallet, CDataStream& ssKey, CDataStream& ssValue, ReadKeyValue(CWallet* pwallet, DataStream& ssKey, CDataStream& ssValue,
CWalletScanState &wss, std::string& strType, std::string& strErr, const KeyFilterFn& filter_fn = nullptr) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) CWalletScanState &wss, std::string& strType, std::string& strErr, const KeyFilterFn& filter_fn = nullptr) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
{ {
try { try {
@ -759,7 +759,7 @@ ReadKeyValue(CWallet* pwallet, CDataStream& ssKey, CDataStream& ssValue,
return true; return true;
} }
bool ReadKeyValue(CWallet* pwallet, CDataStream& ssKey, CDataStream& ssValue, std::string& strType, std::string& strErr, const KeyFilterFn& filter_fn) bool ReadKeyValue(CWallet* pwallet, DataStream& ssKey, CDataStream& ssValue, std::string& strType, std::string& strErr, const KeyFilterFn& filter_fn)
{ {
CWalletScanState dummy_wss; CWalletScanState dummy_wss;
LOCK(pwallet->cs_wallet); LOCK(pwallet->cs_wallet);
@ -822,7 +822,7 @@ DBErrors WalletBatch::LoadWallet(CWallet* pwallet)
while (true) while (true)
{ {
// Read next record // Read next record
CDataStream ssKey(SER_DISK, CLIENT_VERSION); DataStream ssKey{};
CDataStream ssValue(SER_DISK, CLIENT_VERSION); CDataStream ssValue(SER_DISK, CLIENT_VERSION);
DatabaseCursor::Status status = cursor->Next(ssKey, ssValue); DatabaseCursor::Status status = cursor->Next(ssKey, ssValue);
if (status == DatabaseCursor::Status::DONE) { if (status == DatabaseCursor::Status::DONE) {
@ -993,8 +993,8 @@ DBErrors WalletBatch::FindWalletTxHashes(std::vector<uint256>& tx_hashes)
while (true) while (true)
{ {
// Read next record // Read next record
CDataStream ssKey(SER_DISK, CLIENT_VERSION); DataStream ssKey{};
CDataStream ssValue(SER_DISK, CLIENT_VERSION); DataStream ssValue{};
DatabaseCursor::Status status = cursor->Next(ssKey, ssValue); DatabaseCursor::Status status = cursor->Next(ssKey, ssValue);
if (status == DatabaseCursor::Status::DONE) { if (status == DatabaseCursor::Status::DONE) {
break; break;
@ -1116,8 +1116,8 @@ bool WalletBatch::EraseRecords(const std::unordered_set<std::string>& types)
while (true) while (true)
{ {
// Read next record // Read next record
CDataStream key(SER_DISK, CLIENT_VERSION); DataStream key{};
CDataStream value(SER_DISK, CLIENT_VERSION); DataStream value{};
DatabaseCursor::Status status = cursor->Next(key, value); DatabaseCursor::Status status = cursor->Next(key, value);
if (status == DatabaseCursor::Status::DONE) { if (status == DatabaseCursor::Status::DONE) {
break; break;

2
src/wallet/walletdb.h
View file

@ -303,7 +303,7 @@ void MaybeCompactWalletDB(WalletContext& context);
using KeyFilterFn = std::function<bool(const std::string&)>; using KeyFilterFn = std::function<bool(const std::string&)>;
//! Unserialize a given Key-Value pair and load it into the wallet //! Unserialize a given Key-Value pair and load it into the wallet
bool ReadKeyValue(CWallet* pwallet, CDataStream& ssKey, CDataStream& ssValue, std::string& strType, std::string& strErr, const KeyFilterFn& filter_fn = nullptr); bool ReadKeyValue(CWallet* pwallet, DataStream& ssKey, CDataStream& ssValue, std::string& strType, std::string& strErr, const KeyFilterFn& filter_fn = nullptr);
/** Return object for accessing dummy database with no read/write capabilities. */ /** Return object for accessing dummy database with no read/write capabilities. */
std::unique_ptr<WalletDatabase> CreateDummyWalletDatabase(); std::unique_ptr<WalletDatabase> CreateDummyWalletDatabase();