ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2026-06-09 03:36:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove unused code

Browse Source
This commit is contained in:
Bart
2026-06-08 18:53:55 -04:00
parent 9922f214e9
commit b642668a0f
9 changed files with 18 additions and 285 deletions
Download Patch File Download Diff File Expand all files Collapse all files

135
src/test/app/ValidatorList_test.cpp
View File

@@ -2239,8 +2239,7 @@ private:
{
testcase("Sha512 hashing");
// Tests that ValidatorList hash_append helpers with a single blob
// returns the same result as xrpl::Sha512Half used by the
// TMValidatorList protocol message handler
// return the same result as xrpl::Sha512Half
std::string const manifest = "This is not really a manifest";
std::string const blob = "This is not really a blob";
std::string const signature = "This is not really a signature";
@@ -2261,17 +2260,6 @@ private:
BEAST_EXPECT(global != sha512Half(blob, blobMap, version));
}
{
protocol::TMValidatorList msg1;
msg1.set_manifest(manifest);
msg1.set_blob(blob);
msg1.set_signature(signature);
msg1.set_version(version);
BEAST_EXPECT(global == sha512Half(msg1));
msg1.set_signature(blob);
BEAST_EXPECT(global != sha512Half(msg1));
}
{
protocol::TMValidatorListCollection msg2;
msg2.set_manifest(manifest);
@@ -2309,19 +2297,7 @@ private:
BEAST_EXPECT(!ec);
return std::make_pair(header, buffers);
};
auto extractProtocolMessage1 = [this, &extractHeader](Message& message) {
auto [header, buffers] = extractHeader(message);
if (BEAST_EXPECT(header) &&
BEAST_EXPECT(header->messageType == protocol::mtVALIDATOR_LIST))
{
auto const msg =
detail::parseMessageContent<protocol::TMValidatorList>(*header, buffers.data());
BEAST_EXPECT(msg);
return msg;
}
return std::shared_ptr<protocol::TMValidatorList>();
};
auto extractProtocolMessage2 = [this, &extractHeader](Message& message) {
auto extractProtocolMessage = [this, &extractHeader](Message& message) {
auto [header, buffers] = extractHeader(message);
if (BEAST_EXPECT(header) &&
BEAST_EXPECT(header->messageType == protocol::mtVALIDATOR_LIST_COLLECTION))
@@ -2334,7 +2310,7 @@ private:
return std::shared_ptr<protocol::TMValidatorListCollection>();
};
auto verifyMessage =
[this, manifestCutoff, &extractProtocolMessage1, &extractProtocolMessage2](
[this, manifestCutoff, &extractProtocolMessage](
auto const version,
auto const& manifest,
auto const& blobInfos,
@@ -2354,42 +2330,11 @@ private:
messageWithHash.message->getBuffer(compression::Compressed::Off).size();
// This size is arbitrary, but shouldn't change
BEAST_EXPECT(size == msgIter->first);
if (expectedSeqs.size() == 1)
{
auto const msg = extractProtocolMessage1(*messageWithHash.message);
auto const expectedVersion = 1;
if (BEAST_EXPECT(msg))
{
BEAST_EXPECT(msg->version() == expectedVersion);
if (!BEAST_EXPECT(seqIter != expectedSeqs.end()))
continue;
auto const& expectedBlob = blobInfos.at(*seqIter);
BEAST_EXPECT((*seqIter < manifestCutoff) == !!expectedBlob.manifest);
auto const expectedManifest =
*seqIter < manifestCutoff && expectedBlob.manifest
? *expectedBlob.manifest
: manifest;
BEAST_EXPECT(msg->manifest() == expectedManifest);
BEAST_EXPECT(msg->blob() == expectedBlob.blob);
BEAST_EXPECT(msg->signature() == expectedBlob.signature);
++seqIter;
BEAST_EXPECT(seqIter == expectedSeqs.end());
BEAST_EXPECT(
messageWithHash.hash ==
sha512Half(
expectedManifest,
expectedBlob.blob,
expectedBlob.signature,
expectedVersion));
}
}
else
{
std::vector<ValidatorBlobInfo> hashingBlobs;
hashingBlobs.reserve(msgIter->second.size());
auto const msg = extractProtocolMessage2(*messageWithHash.message);
auto const msg = extractProtocolMessage(*messageWithHash.message);
if (BEAST_EXPECT(msg))
{
BEAST_EXPECT(msg->version() == version);
@@ -2457,66 +2402,10 @@ private:
std::vector<ValidatorList::MessageWithHash> messages;
// Version 1
// This peer has a VL ahead of our "current"
verifyBuildMessages(
ValidatorList::buildValidatorListMessages(
1, 8, maxSequence, version, manifest, blobInfos, messages),
0,
0);
BEAST_EXPECT(messages.empty());
// Don't repeat the work if messages is populated, even though the
// peerSequence provided indicates it should. Note that this
// situation is contrived for this test and should never happen in
// real code.
messages.emplace_back();
verifyBuildMessages(
ValidatorList::buildValidatorListMessages(
1, 3, maxSequence, version, manifest, blobInfos, messages),
5,
0);
BEAST_EXPECT(messages.size() == 1 && !messages.front().message);
// Generate a version 1 message
messages.clear();
verifyBuildMessages(
ValidatorList::buildValidatorListMessages(
1, 3, maxSequence, version, manifest, blobInfos, messages),
5,
1);
if (BEAST_EXPECT(messages.size() == 1) && BEAST_EXPECT(messages.front().message))
{
auto const& messageWithHash = messages.front();
auto const msg = extractProtocolMessage1(*messageWithHash.message);
auto const size =
messageWithHash.message->getBuffer(compression::Compressed::Off).size();
// This size is arbitrary, but shouldn't change
BEAST_EXPECT(size == 108);
auto const& expected = blobInfos.at(5);
if (BEAST_EXPECT(msg))
{
BEAST_EXPECT(msg->version() == 1);
// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
BEAST_EXPECT(msg->manifest() == *expected.manifest);
BEAST_EXPECT(msg->blob() == expected.blob);
BEAST_EXPECT(msg->signature() == expected.signature);
}
BEAST_EXPECT(
messageWithHash.hash ==
// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
sha512Half(*expected.manifest, expected.blob, expected.signature, 1));
}
// Version 2
messages.clear();
// This peer has a VL ahead of us.
verifyBuildMessages(
ValidatorList::buildValidatorListMessages(
2, maxSequence * 2, maxSequence, version, manifest, blobInfos, messages),
maxSequence * 2, maxSequence, version, manifest, blobInfos, messages),
0,
0);
BEAST_EXPECT(messages.empty());
@@ -2528,16 +2417,16 @@ private:
messages.emplace_back();
verifyBuildMessages(
ValidatorList::buildValidatorListMessages(
2, 3, maxSequence, version, manifest, blobInfos, messages),
3, maxSequence, version, manifest, blobInfos, messages),
maxSequence,
0);
BEAST_EXPECT(messages.size() == 1 && !messages.front().message);
// Generate a version 2 message. Don't send the current
// Generate a message. Don't send the current
messages.clear();
verifyBuildMessages(
ValidatorList::buildValidatorListMessages(
2, 5, maxSequence, version, manifest, blobInfos, messages),
5, maxSequence, version, manifest, blobInfos, messages),
maxSequence,
4);
verifyMessage(version, manifest, blobInfos, messages, {{372, {6, 7, 10, 12}}});
@@ -2548,7 +2437,7 @@ private:
messages.clear();
verifyBuildMessages(
ValidatorList::buildValidatorListMessages(
2, 5, maxSequence, version, manifest, blobInfos, messages, 300),
5, maxSequence, version, manifest, blobInfos, messages, 300),
maxSequence,
4);
verifyMessage(version, manifest, blobInfos, messages, {{212, {6, 7}}, {192, {10, 12}}});
@@ -2558,7 +2447,7 @@ private:
messages.clear();
verifyBuildMessages(
ValidatorList::buildValidatorListMessages(
2, 5, maxSequence, version, manifest, blobInfos, messages, 200),
5, maxSequence, version, manifest, blobInfos, messages, 200),
maxSequence,
4);
verifyMessage(
@@ -2568,7 +2457,7 @@ private:
messages.clear();
verifyBuildMessages(
ValidatorList::buildValidatorListMessages(
2, 5, maxSequence, version, manifest, blobInfos, messages, 150),
5, maxSequence, version, manifest, blobInfos, messages, 150),
maxSequence,
4);
verifyMessage(
@@ -2583,7 +2472,7 @@ private:
messages.clear();
verifyBuildMessages(
ValidatorList::buildValidatorListMessages(
2, 5, maxSequence, version, manifest, blobInfos, messages, 108),
5, maxSequence, version, manifest, blobInfos, messages, 108),
maxSequence,
4);
verifyMessage(

30
src/test/overlay/compression_test.cpp
View File

@@ -292,33 +292,6 @@ public:
return getObject;
}
static std::shared_ptr<protocol::TMValidatorList>
buildValidatorList()
{
auto list = std::make_shared<protocol::TMValidatorList>();
auto master = randomKeyPair(KeyType::Ed25519);
auto signing = randomKeyPair(KeyType::Ed25519);
STObject st(sfGeneric);
st[sfSequence] = 0;
st[sfPublicKey] = std::get<0>(master);
st[sfSigningPubKey] = std::get<0>(signing);
st[sfDomain] = makeSlice(std::string("example.com"));
sign(st, HashPrefix::Manifest, KeyType::Ed25519, std::get<1>(master), sfMasterSignature);
sign(st, HashPrefix::Manifest, KeyType::Ed25519, std::get<1>(signing));
Serializer s;
st.add(s);
list->set_manifest(s.data(), s.size());
list->set_version(3);
STObject const signature(sfSignature);
xrpl::sign(st, HashPrefix::Manifest, KeyType::Ed25519, std::get<1>(signing));
Serializer s1;
st.add(s1);
list->set_signature(s1.data(), s1.size());
list->set_blob(strHex(s.slice()));
return list;
}
static std::shared_ptr<protocol::TMValidatorListCollection>
buildValidatorListCollection()
{
@@ -359,7 +332,6 @@ public:
protocol::TMGetLedger const getLedger;
protocol::TMLedgerData const ledgerData;
protocol::TMGetObjectByHash const getObject;
protocol::TMValidatorList const validatorList;
protocol::TMValidatorListCollection const validatorListCollection;
// 4.5KB
@@ -386,8 +358,6 @@ public:
doTest(buildLedgerData(500000, *logs), protocol::mtLEDGER_DATA, 100, "TMLedgerData500000");
// 7.7KB
doTest(buildGetObjectByHash(), protocol::mtGET_OBJECTS, 4, "TMGetObjectByHash");
// 895B
doTest(buildValidatorList(), protocol::mtVALIDATOR_LIST, 4, "TMValidatorList");
doTest(
buildValidatorListCollection(),
protocol::mtVALIDATOR_LIST_COLLECTION,

13
src/xrpld/app/misc/ValidatorList.h
View File

@@ -16,7 +16,6 @@
#include <shared_mutex>
namespace protocol {
class TMValidatorList;
class TMValidatorListCollection;
} // namespace protocol
@@ -333,9 +332,6 @@ public:
static std::vector<ValidatorBlobInfo>
parseBlobs(std::uint32_t version, json::Value const& body);
static std::vector<ValidatorBlobInfo>
parseBlobs(protocol::TMValidatorList const& body);
static std::vector<ValidatorBlobInfo>
parseBlobs(protocol::TMValidatorListCollection const& body);
@@ -353,7 +349,6 @@ public:
[[nodiscard]] static std::pair<std::size_t, std::size_t>
buildValidatorListMessages(
std::size_t messageVersion,
std::uint64_t peerSequence,
std::size_t maxSequence,
std::uint32_t rawVersion,
@@ -917,14 +912,6 @@ hash_append(Hasher& h, std::map<std::size_t, ValidatorBlobInfo> const& blobs)
namespace protocol {
template <class Hasher>
void
hash_append(Hasher& h, TMValidatorList const& msg)
{
using beast::hash_append;
hash_append(h, msg.manifest(), msg.blob(), msg.signature(), msg.version());
}
template <class Hasher>
void
hash_append(Hasher& h, TMValidatorListCollection const& msg)

97
src/xrpld/app/misc/detail/ValidatorList.cpp
View File

@@ -451,13 +451,6 @@ ValidatorList::parseBlobs(std::uint32_t version, json::Value const& body)
}
}
// static
std::vector<ValidatorBlobInfo>
ValidatorList::parseBlobs(protocol::TMValidatorList const& body)
{
return {{.blob = body.blob(), .signature = body.signature(), .manifest = {}}};
}
// static
std::vector<ValidatorBlobInfo>
ValidatorList::parseBlobs(protocol::TMValidatorListCollection const& body)
@@ -478,7 +471,7 @@ ValidatorList::parseBlobs(protocol::TMValidatorListCollection const& body)
}
XRPL_ASSERT(
result.size() == body.blobs_size(),
"xrpl::ValidatorList::parseBlobs(TMValidatorList) : result size "
"xrpl::ValidatorList::parseBlobs(TMValidatorListCollection) : result size "
"match");
return result;
}
@@ -522,29 +515,6 @@ splitMessageParts(
{
if (end <= begin)
return 0;
if (end - begin == 1)
{
protocol::TMValidatorList smallMsg;
smallMsg.set_version(1);
smallMsg.set_manifest(largeMsg.manifest());
auto const& blob = largeMsg.blobs(begin);
smallMsg.set_blob(blob.blob());
smallMsg.set_signature(blob.signature());
// This is only possible if "downgrading" a v2 UNL to v1.
if (blob.has_manifest())
smallMsg.set_manifest(blob.manifest());
XRPL_ASSERT(
Message::totalSize(smallMsg) <= kMaximumMessageSize,
"xrpl::splitMessageParts : maximum message size");
messages.emplace_back(
std::make_shared<Message>(smallMsg, protocol::mtVALIDATOR_LIST),
sha512Half(smallMsg),
1);
return messages.back().numVLs;
}
std::optional<protocol::TMValidatorListCollection> smallMsg;
smallMsg.emplace();
@@ -570,37 +540,6 @@ splitMessageParts(
return messages.back().numVLs;
}
// Build a v1 protocol message using only the current VL
std::size_t
buildValidatorListMessage(
std::vector<ValidatorList::MessageWithHash>& messages,
std::uint32_t rawVersion,
std::string const& rawManifest,
ValidatorBlobInfo const& currentBlob,
std::size_t maxSize)
{
XRPL_ASSERT(
messages.empty(),
"xrpl::buildValidatorListMessage(ValidatorBlobInfo) : empty messages "
"input");
protocol::TMValidatorList msg;
auto const manifest = currentBlob.manifest ? *currentBlob.manifest : rawManifest;
auto const version = 1;
msg.set_manifest(manifest);
msg.set_blob(currentBlob.blob);
msg.set_signature(currentBlob.signature);
// Override the version
msg.set_version(version);
XRPL_ASSERT(
Message::totalSize(msg) <= kMaximumMessageSize,
"xrpl::buildValidatorListMessage(ValidatorBlobInfo) : maximum "
"message size");
messages.emplace_back(
std::make_shared<Message>(msg, protocol::mtVALIDATOR_LIST), sha512Half(msg), 1);
return 1;
}
// Build a v2 protocol message using all the VLs with sequence larger than the
// peer's
std::size_t
@@ -652,7 +591,6 @@ buildValidatorListMessage(
// static
std::pair<std::size_t, std::size_t>
ValidatorList::buildValidatorListMessages(
std::size_t messageVersion,
std::uint64_t peerSequence,
std::size_t maxSequence,
std::uint32_t rawVersion,
@@ -665,14 +603,12 @@ ValidatorList::buildValidatorListMessages(
!blobInfos.empty(),
"xrpl::ValidatorList::buildValidatorListMessages : empty messages "
"input");
auto const& [currentSeq, currentBlob] = *blobInfos.begin();
auto numVLs = std::accumulate(
messages.begin(), messages.end(), 0, [](std::size_t total, MessageWithHash const& m) {
return total + m.numVLs;
});
if (messageVersion == 2 && peerSequence < maxSequence)
if (peerSequence < maxSequence)
{
// Version 2
if (messages.empty())
{
numVLs = buildValidatorListMessage(
@@ -680,36 +616,13 @@ ValidatorList::buildValidatorListMessages(
if (messages.empty())
{
// No message was generated. Create an empty placeholder so we
// dont' repeat the work later.
// don't repeat the work later.
messages.emplace_back();
}
}
// Don't send it next time.
return {maxSequence, numVLs};
}
if (messageVersion == 1 && peerSequence < currentSeq)
{
// Version 1
if (messages.empty())
{
numVLs = buildValidatorListMessage(
messages,
rawVersion,
currentBlob.manifest ? *currentBlob.manifest : rawManifest,
currentBlob,
maxSize);
if (messages.empty())
{
// No message was generated. Create an empty placeholder so we
// dont' repeat the work later.
messages.emplace_back();
}
}
// Don't send it next time.
return {currentSeq, numVLs};
}
return {0, 0};
}
@@ -727,10 +640,8 @@ ValidatorList::sendValidatorList(
HashRouter& hashRouter,
beast::Journal j)
{
// v1 messages are no longer supported.
std::size_t const messageVersion = 2;
auto const [newPeerSequence, numVLs] = buildValidatorListMessages(
messageVersion, peerSequence, maxSequence, rawVersion, rawManifest, blobInfos, messages);
peerSequence, maxSequence, rawVersion, rawManifest, blobInfos, messages);
if (newPeerSequence != 0u)
{
XRPL_ASSERT(

1
src/xrpld/overlay/detail/Message.cpp
View File

@@ -82,7 +82,6 @@ Message::compress()
case protocol::mtGET_LEDGER:
case protocol::mtLEDGER_DATA:
case protocol::mtGET_OBJECTS:
case protocol::mtVALIDATOR_LIST:
case protocol::mtVALIDATOR_LIST_COLLECTION:
case protocol::mtREPLAY_DELTA_RESPONSE:
case protocol::mtTRANSACTIONS:

19
src/xrpld/overlay/detail/PeerImp.cpp
View File

@@ -547,8 +547,9 @@ PeerImp::supportsFeature(ProtocolFeature f) const
{
case ProtocolFeature::LedgerReplay:
return ledgerReplayEnabled_;
default:
return false;
}
return false;
}
//------------------------------------------------------------------------------
@@ -2266,22 +2267,6 @@ PeerImp::onValidatorListMessage(
}
}
void
PeerImp::onMessage(std::shared_ptr<protocol::TMValidatorList> const& m)
{
try
{
onValidatorListMessage(
"ValidatorList", m->manifest(), m->version(), ValidatorList::parseBlobs(*m));
}
catch (std::exception const& e)
{
JLOG(pJournal_.warn()) << "ValidatorList: Exception, " << e.what();
using namespace std::string_literals;
fee_.update(Resource::kFeeInvalidData, e.what());
}
}
void
PeerImp::onMessage(std::shared_ptr<protocol::TMValidatorListCollection> const& m)
{

2
src/xrpld/overlay/detail/PeerImp.h
View File

@@ -548,8 +548,6 @@ public:
void
onMessage(std::shared_ptr<protocol::TMHaveTransactionSet> const& m);
void
onMessage(std::shared_ptr<protocol::TMValidatorList> const& m);
void
onMessage(std::shared_ptr<protocol::TMValidatorListCollection> const& m);
void
onMessage(std::shared_ptr<protocol::TMValidation> const& m);

5
src/xrpld/overlay/detail/ProtocolMessage.h
View File

@@ -62,8 +62,6 @@ protocolMessageName(int type)
return "status";
case protocol::mtHAVE_SET:
return "have_set";
case protocol::mtVALIDATOR_LIST:
return "validator_list";
case protocol::mtVALIDATOR_LIST_COLLECTION:
return "validator_list_collection";
case protocol::mtVALIDATION:
@@ -388,9 +386,6 @@ invokeProtocolMessage(Buffers const& buffers, Handler& handler, std::size_t& hin
case protocol::mtVALIDATION:
success = detail::invoke<protocol::TMValidation>(*header, buffers, handler);
break;
case protocol::mtVALIDATOR_LIST:
success = detail::invoke<protocol::TMValidatorList>(*header, buffers, handler);
break;
case protocol::mtVALIDATOR_LIST_COLLECTION:
success =
detail::invoke<protocol::TMValidatorListCollection>(*header, buffers, handler);

1
src/xrpld/overlay/detail/TrafficCount.cpp
View File

@@ -14,7 +14,6 @@ std::unordered_map<protocol::MessageType, TrafficCount::Category> const kTypeLoo
{protocol::mtMANIFESTS, TrafficCount::Category::Manifests},
{protocol::mtENDPOINTS, TrafficCount::Category::Overlay},
{protocol::mtTRANSACTION, TrafficCount::Category::Transaction},
{protocol::mtVALIDATOR_LIST, TrafficCount::Category::Validatorlist},
{protocol::mtVALIDATOR_LIST_COLLECTION, TrafficCount::Category::Validatorlist},
{protocol::mtVALIDATION, TrafficCount::Category::Validation},
{protocol::mtPROPOSE_LEDGER, TrafficCount::Category::Proposal},