mirror/bitcoin
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge bitcoin/bitcoin#25296: Add DataStream without ser-type and ser-version and use it where possible

Browse Source 
fa035fe2d6 Remove unused CDataStream::SetType (MarcoFalke)
fa29e73cda Use DataStream where possible (MarcoFalke)
fa9becfe1c streams: Add DataStream without ser-type and ser-version (MarcoFalke)

Pull request description:

  This was done in the context of https://github.com/bitcoin/bitcoin/pull/25284 , but I think it also makes sense standalone.

  The basic idea is that serialization type should not be initialized when it is not needed. Same for the serialization version.

  So do this here for `DataStream`. `CDataStream` remains in places where it is not yet possible.

ACKs for top commit:
  stickies-v:
    re-ACK [fa035fe](https://github.com/bitcoin/bitcoin/commit/fa035fe2d61d0c98d1bfd0153a0c3b5eb9d40de4)
  aureleoules:
    diff re-ACK fa035fe2d6 https://github.com/bitcoin/bitcoin/compare/fa0e6640bac8c6426af7c5744125c85c0f74b9e5..fa035fe2d61d0c98d1bfd0153a0c3b5eb9d40de4

Tree-SHA512: cb5e53d0df7c94319ffadc6ea1d887fc38516decaf43f0673396d79cc62d450a1a61173654a91b8c2b52d2cecea53fe4a500b8f6466596f35731471163fb051c
This commit is contained in:
fanquake committed 2023-01-26 11:30:34 +00:00
2 parents 77a36033b5 fa035fe2d6
commit 79e007d1d6
49 files changed
+196 -181
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/bench/load_external.cpp
+1 -1
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());
src/bench/prevector.cpp
+1 -1
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) {
src/bitcoin-util.cpp
+1 -1
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;
src/blockencodings.cpp
+1 -1
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());
src/common/bloom.cpp
+2 -2
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));
} }
src/core_read.cpp
+1 -1
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&) {
src/dbwrapper.h
+7 -7
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;
src/kernel/coinstats.cpp
+3 -2
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;
src/kernel/coinstats.h
+1 -1
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
src/net_processing.cpp
+1 -1
View File
@@ -3362,7 +3362,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));
} }
src/qt/recentrequeststablemodel.cpp
+2 -2
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;
src/qt/test/wallettests.cpp
+1 -1
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());
src/rest.cpp
+10 -10
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());
src/rpc/blockchain.cpp
+1 -1
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;
src/rpc/txoutproof.cpp
+2 -2
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;
src/streams.h
+52 -30
View File
@@ -182,16 +182,13 @@ public:
* >> and << read and write unformatted data using the above serialization templates. * >> and << read and write unformatted data using the above serialization templates.
* Fills with data in linear time; some stringstream implementations take N^2 time. * Fills with data in linear time; some stringstream implementations take N^2 time.
*/ */
class CDataStream class DataStream
{ {
protected: protected:
using vector_type = SerializeData; using vector_type = SerializeData;
vector_type vch; vector_type vch;
vector_type::size_type m_read_pos{0}; vector_type::size_type m_read_pos{0};
int nType;
int nVersion;
public: public:
typedef vector_type::allocator_type allocator_type; typedef vector_type::allocator_type allocator_type;
typedef vector_type::size_type size_type; typedef vector_type::size_type size_type;
@@ -203,23 +200,9 @@ public:
typedef vector_type::const_iterator const_iterator; typedef vector_type::const_iterator const_iterator;
typedef vector_type::reverse_iterator reverse_iterator; typedef vector_type::reverse_iterator reverse_iterator;
explicit CDataStream(int nTypeIn, int nVersionIn) explicit DataStream() {}
: nType{nTypeIn}, explicit DataStream(Span<const uint8_t> sp) : DataStream{AsBytes(sp)} {}
nVersion{nVersionIn} {} explicit DataStream(Span<const value_type> sp) : vch(sp.data(), sp.data() + sp.size()) {}
explicit CDataStream(Span<const uint8_t> sp, int type, int version) : CDataStream{AsBytes(sp), type, version} {}
explicit CDataStream(Span<const value_type> sp, int nTypeIn, int nVersionIn)
: vch(sp.data(), sp.data() + sp.size()),
nType{nTypeIn},
nVersion{nVersionIn} {}
template <typename... Args>
CDataStream(int nTypeIn, int nVersionIn, Args&&... args)
: nType{nTypeIn},
nVersion{nVersionIn}
{
::SerializeMany(*this, std::forward<Args>(args)...);
}
std::string str() const std::string str() const
{ {
@@ -271,11 +254,6 @@ public:
bool eof() const { return size() == 0; } bool eof() const { return size() == 0; }
int in_avail() const { return size(); } int in_avail() const { return size(); }
void SetType(int n) { nType = n; }
int GetType() const { return nType; }
void SetVersion(int n) { nVersion = n; }
int GetVersion() const { return nVersion; }
void read(Span<value_type> dst) void read(Span<value_type> dst)
{ {
if (dst.size() == 0) return; if (dst.size() == 0) return;
@@ -283,7 +261,7 @@ public:
// Read from the beginning of the buffer // Read from the beginning of the buffer
auto next_read_pos{CheckedAdd(m_read_pos, dst.size())}; auto next_read_pos{CheckedAdd(m_read_pos, dst.size())};
if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) { if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) {
throw std::ios_base::failure("CDataStream::read(): end of data"); throw std::ios_base::failure("DataStream::read(): end of data");
} }
memcpy(dst.data(), &vch[m_read_pos], dst.size()); memcpy(dst.data(), &vch[m_read_pos], dst.size());
if (next_read_pos.value() == vch.size()) { if (next_read_pos.value() == vch.size()) {
@@ -299,7 +277,7 @@ public:
// Ignore from the beginning of the buffer // Ignore from the beginning of the buffer
auto next_read_pos{CheckedAdd(m_read_pos, num_ignore)}; auto next_read_pos{CheckedAdd(m_read_pos, num_ignore)};
if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) { if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) {
throw std::ios_base::failure("CDataStream::ignore(): end of data"); throw std::ios_base::failure("DataStream::ignore(): end of data");
} }
if (next_read_pos.value() == vch.size()) { if (next_read_pos.value() == vch.size()) {
m_read_pos = 0; m_read_pos = 0;
@@ -324,7 +302,7 @@ public:
} }
template<typename T> template<typename T>
CDataStream& operator<<(const T& obj) DataStream& operator<<(const T& obj)
{ {
// Serialize to this stream // Serialize to this stream
::Serialize(*this, obj); ::Serialize(*this, obj);
@@ -332,7 +310,7 @@ public:
} }
template<typename T> template<typename T>
CDataStream& operator>>(T&& obj) DataStream& operator>>(T&& obj)
{ {
// Unserialize from this stream // Unserialize from this stream
::Unserialize(*this, obj); ::Unserialize(*this, obj);
@@ -363,6 +341,50 @@ public:
} }
}; };
class CDataStream : public DataStream
{
private:
int nType;
int nVersion;
public:
explicit CDataStream(int nTypeIn, int nVersionIn)
: nType{nTypeIn},
nVersion{nVersionIn} {}
explicit CDataStream(Span<const uint8_t> sp, int type, int version) : CDataStream{AsBytes(sp), type, version} {}
explicit CDataStream(Span<const value_type> sp, int nTypeIn, int nVersionIn)
: DataStream{sp},
nType{nTypeIn},
nVersion{nVersionIn} {}
template <typename... Args>
CDataStream(int nTypeIn, int nVersionIn, Args&&... args)
: nType{nTypeIn},
nVersion{nVersionIn}
{
::SerializeMany(*this, std::forward<Args>(args)...);
}
int GetType() const { return nType; }
void SetVersion(int n) { nVersion = n; }
int GetVersion() const { return nVersion; }
template <typename T>
CDataStream& operator<<(const T& obj)
{
::Serialize(*this, obj);
return *this;
}
template <typename T>
CDataStream& operator>>(T&& obj)
{
::Unserialize(*this, obj);
return *this;
}
};
template <typename IStream> template <typename IStream>
class BitStreamReader class BitStreamReader
{ {
src/test/blockencodings_tests.cpp
+3 -3
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]);
src/test/blockfilter_tests.cpp
+1 -1
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;
src/test/bloom_tests.cpp
+4 -4
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");
src/test/coins_tests.cpp
+6 -6
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;
src/test/crypto_tests.cpp
+2 -2
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;
src/test/fuzz/integer.cpp
+3 -3
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 {
src/test/fuzz/key.cpp
+1 -1
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;
src/test/fuzz/prevector.cpp
+2 -2
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());
src/test/fuzz/rpc.cpp
+1 -1
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);
}, },
src/test/fuzz/string.cpp
+2 -2
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;
src/test/fuzz/tx_in.cpp
+1 -4
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;
src/test/fuzz/tx_out.cpp
+1 -4
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;
src/test/key_tests.cpp
+2 -2
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;
src/test/pmt_tests.cpp
+1 -1
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
src/test/prevector_tests.cpp
+2 -2
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());
src/test/serfloat_tests.cpp
+1 -1
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);
src/test/serialize_tests.cpp
+5 -5
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:
src/test/streams_tests.cpp
+7 -7
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());
} }
src/test/uint256_tests.cpp
+1 -1
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;
src/wallet/bdb.cpp
+7 -9
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;
src/wallet/bdb.h
+5 -5
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;
src/wallet/db.h
+14 -14
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 {}
src/wallet/dump.cpp
+4 -4
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"));
src/wallet/rpc/backup.cpp
+1 -1
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;
src/wallet/salvage.cpp
+1 -1
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;
src/wallet/sqlite.cpp
+5 -5
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) {
src/wallet/sqlite.h
+5 -5
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);
src/wallet/test/util.cpp
+2 -2
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;
src/wallet/test/wallet_tests.cpp
+5 -5
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) {}
src/wallet/test/walletload_tests.cpp
+2 -2
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;
src/wallet/wallet.cpp
+4 -4
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();
src/wallet/walletdb.cpp
+7 -7
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;
src/wallet/walletdb.h
+1 -1
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();