ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2026-08-22 06:40:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: Remove support for protocol version 2.1 (#7432)

Browse Source 
Co-authored-by: Bart <11445373+bthomee@users.noreply.github.com>
Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
Bart
2026-08-14 15:36:47 +00:00
committed by GitHub
parent bd87edfc75
commit 2adffaef72
13 changed files with 114 additions and 437 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -2253,8 +2253,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";
@@ -2275,17 +2274,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);
@@ -2323,19 +2311,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))
@@ -2347,92 +2323,55 @@ private:
}
return std::shared_ptr<protocol::TMValidatorListCollection>();
};
auto verifyMessage =
[this, manifestCutoff, &extractProtocolMessage1, &extractProtocolMessage2](
auto const version,
auto const& manifest,
auto const& blobInfos,
auto const& messages,
std::vector<std::pair<std::size_t, std::vector<std::uint32_t>>> expectedInfo) {
BEAST_EXPECT(messages.size() == expectedInfo.size());
auto msgIter = expectedInfo.begin();
for (auto const& messageWithHash : messages)
auto verifyMessage = [this, manifestCutoff, &extractProtocolMessage](
auto const version,
auto const& manifest,
auto const& blobInfos,
auto const& messages,
std::vector<std::vector<std::uint32_t>> expectedInfo) {
BEAST_EXPECT(messages.size() == expectedInfo.size());
auto msgIter = expectedInfo.begin();
for (auto const& messageWithHash : messages)
{
if (!BEAST_EXPECT(msgIter != expectedInfo.end()))
break;
if (!BEAST_EXPECT(messageWithHash.message))
continue;
auto const& expectedSeqs = *msgIter;
auto seqIter = expectedSeqs.begin();
{
if (!BEAST_EXPECT(msgIter != expectedInfo.end()))
break;
if (!BEAST_EXPECT(messageWithHash.message))
continue;
auto const& expectedSeqs = msgIter->second;
auto seqIter = expectedSeqs.begin();
auto const size =
messageWithHash.message->getBuffer(compression::Compressed::Off).size();
// This size is arbitrary, but shouldn't change
BEAST_EXPECT(size == msgIter->first);
if (expectedSeqs.size() == 1)
std::vector<ValidatorBlobInfo> hashingBlobs;
hashingBlobs.reserve(expectedSeqs.size());
auto const msg = extractProtocolMessage(*messageWithHash.message);
if (BEAST_EXPECT(msg))
{
auto const msg = extractProtocolMessage1(*messageWithHash.message);
auto const expectedVersion = 1;
if (BEAST_EXPECT(msg))
BEAST_EXPECT(msg->version() == version);
BEAST_EXPECT(msg->manifest() == manifest);
for (auto const& blobInfo : msg->blobs())
{
BEAST_EXPECT(msg->version() == expectedVersion);
if (!BEAST_EXPECT(seqIter != expectedSeqs.end()))
continue;
break;
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);
hashingBlobs.push_back(expectedBlob);
BEAST_EXPECT(blobInfo.has_manifest() == !!expectedBlob.manifest);
BEAST_EXPECT(blobInfo.has_manifest() == (*seqIter < manifestCutoff));
if (*seqIter < manifestCutoff)
BEAST_EXPECT(blobInfo.manifest() == *expectedBlob.manifest);
BEAST_EXPECT(blobInfo.blob() == expectedBlob.blob);
BEAST_EXPECT(blobInfo.signature() == expectedBlob.signature);
++seqIter;
BEAST_EXPECT(seqIter == expectedSeqs.end());
BEAST_EXPECT(
messageWithHash.hash ==
sha512Half(
expectedManifest,
expectedBlob.blob,
expectedBlob.signature,
expectedVersion));
}
BEAST_EXPECT(seqIter == expectedSeqs.end());
}
else
{
std::vector<ValidatorBlobInfo> hashingBlobs;
hashingBlobs.reserve(msgIter->second.size());
auto const msg = extractProtocolMessage2(*messageWithHash.message);
if (BEAST_EXPECT(msg))
{
BEAST_EXPECT(msg->version() == version);
BEAST_EXPECT(msg->manifest() == manifest);
for (auto const& blobInfo : msg->blobs())
{
if (!BEAST_EXPECT(seqIter != expectedSeqs.end()))
break;
auto const& expectedBlob = blobInfos.at(*seqIter);
hashingBlobs.push_back(expectedBlob);
BEAST_EXPECT(blobInfo.has_manifest() == !!expectedBlob.manifest);
BEAST_EXPECT(
blobInfo.has_manifest() == (*seqIter < manifestCutoff));
if (*seqIter < manifestCutoff)
BEAST_EXPECT(blobInfo.manifest() == *expectedBlob.manifest);
BEAST_EXPECT(blobInfo.blob() == expectedBlob.blob);
BEAST_EXPECT(blobInfo.signature() == expectedBlob.signature);
++seqIter;
}
BEAST_EXPECT(seqIter == expectedSeqs.end());
}
BEAST_EXPECT(
messageWithHash.hash == sha512Half(manifest, hashingBlobs, version));
}
++msgIter;
BEAST_EXPECT(
messageWithHash.hash == sha512Half(manifest, hashingBlobs, version));
}
BEAST_EXPECT(msgIter == expectedInfo.end());
};
++msgIter;
}
BEAST_EXPECT(msgIter == expectedInfo.end());
};
auto verifyBuildMessages = [this](
std::pair<std::size_t, std::size_t> const& result,
std::size_t expectedSequence,
@@ -2471,66 +2410,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());
@@ -2542,19 +2425,19 @@ 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}}});
verifyMessage(version, manifest, blobInfos, messages, {{6, 7, 10, 12}});
// Test message splitting on size limits.
@@ -2562,50 +2445,39 @@ 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}}});
verifyMessage(version, manifest, blobInfos, messages, {{6, 7}, {10, 12}});
// Set a limit between the size of the two earlier messages so one
// will split and the other won't
messages.clear();
verifyBuildMessages(
ValidatorList::buildValidatorListMessages(
2, 5, maxSequence, version, manifest, blobInfos, messages, 200),
5, maxSequence, version, manifest, blobInfos, messages, 200),
maxSequence,
4);
verifyMessage(
version, manifest, blobInfos, messages, {{108, {6}}, {108, {7}}, {192, {10, 12}}});
verifyMessage(version, manifest, blobInfos, messages, {{6}, {7}, {10, 12}});
// Set a limit so that all the VLs are sent individually
messages.clear();
verifyBuildMessages(
ValidatorList::buildValidatorListMessages(
2, 5, maxSequence, version, manifest, blobInfos, messages, 150),
5, maxSequence, version, manifest, blobInfos, messages, 150),
maxSequence,
4);
verifyMessage(
version,
manifest,
blobInfos,
messages,
{{108, {6}}, {108, {7}}, {110, {10}}, {110, {12}}});
verifyMessage(version, manifest, blobInfos, messages, {{6}, {7}, {10}, {12}});
// Set a limit smaller than some of the messages. Because single
// messages send regardless, they will all still be sent
messages.clear();
verifyBuildMessages(
ValidatorList::buildValidatorListMessages(
2, 5, maxSequence, version, manifest, blobInfos, messages, 108),
5, maxSequence, version, manifest, blobInfos, messages, 108),
maxSequence,
4);
verifyMessage(
version,
manifest,
blobInfos,
messages,
{{108, {6}}, {108, {7}}, {110, {10}}, {110, {12}}});
verifyMessage(version, manifest, blobInfos, messages, {{6}, {7}, {10}, {12}});
}
void

38
src/test/overlay/ProtocolVersion_test.cpp
View File

@@ -33,22 +33,30 @@ public:
void
run() override
{
testcase("Convert protocol version to string");
BEAST_EXPECT(to_string(makeProtocol(1, 3)) == "XRPL/1.3");
BEAST_EXPECT(to_string(makeProtocol(2, 0)) == "XRPL/2.0");
BEAST_EXPECT(to_string(makeProtocol(2, 1)) == "XRPL/2.1");
BEAST_EXPECT(to_string(makeProtocol(10, 10)) == "XRPL/10.10");
{
testcase("Convert protocol version to string");
BEAST_EXPECT(to_string(makeProtocol(0, 0)) == "XRPL/0.0");
BEAST_EXPECT(to_string(makeProtocol(0, 1)) == "XRPL/0.1");
BEAST_EXPECT(to_string(makeProtocol(1, 3)) == "XRPL/1.3");
BEAST_EXPECT(to_string(makeProtocol(2, 0)) == "XRPL/2.0");
BEAST_EXPECT(to_string(makeProtocol(2, 1)) == "XRPL/2.1");
BEAST_EXPECT(to_string(makeProtocol(10, 10)) == "XRPL/10.10");
BEAST_EXPECT(to_string(makeProtocol(65535, 65535)) == "XRPL/65535.65535");
}
{
testcase("Convert strings to protocol versions");
// Empty string
// Invalid versions, either they do not parse as XRPL/N.M or are unsupported.
check("", "");
check("RTXP/1.1,RTXP/1.2,RTXP/1.3", "");
check("XRPL/-2.1,XRPL/0.3,XRPL/2,XRPL/2.01,websocket", "");
check("RTXP/1.1,RTXP/1.2,RTXP/1.3,XRPL/2.1,XRPL/2.0,/XRPL/3.0", "XRPL/2.0,XRPL/2.1");
check("RTXP/0.9,RTXP/1.01,XRPL/0.3,XRPL/2.01,websocket", "");
// Mixture of valid, duplicate, and invalid versions.
check("RTXP/1.3,XRPL/2.1,XRPL/2.0,/XRPL/3.0", "XRPL/2.0,XRPL/2.1");
check(
"XRPL/2.0,XRPL/2.0,XRPL/19.4,XRPL/7.89,XRPL/XRPL/3.0,XRPL/2.01",
"XRPL/2.0,XRPL/2.0,XRPL/19.4,XRPL/7.89,XRPL/XRPL/3.0,XRPL/2.01,XRPL/-65535.65535",
"XRPL/2.0,XRPL/7.89,XRPL/19.4");
check(
"XRPL/2.0,XRPL/3.0,XRPL/4,XRPL/,XRPL,OPT XRPL/2.2,XRPL/5.67",
@@ -58,15 +66,17 @@ public:
{
testcase("Protocol version negotiation");
BEAST_EXPECT(negotiateProtocolVersion("RTXP/1.2") == std::nullopt);
// Only the highest supported protocol version, if any, is returned.
BEAST_EXPECT(negotiateProtocolVersion("") == std::nullopt);
BEAST_EXPECT(negotiateProtocolVersion("XRPL/0.0") == std::nullopt);
BEAST_EXPECT(negotiateProtocolVersion("RTXP/1.2,XRPL/0.1") == std::nullopt);
BEAST_EXPECT(
negotiateProtocolVersion("RTXP/1.2, XRPL/2.0, XRPL/2.1") == makeProtocol(2, 1));
negotiateProtocolVersion("XRPL/999.999, XRPL/-2.2,WebSocket/1.0") == std::nullopt);
BEAST_EXPECT(negotiateProtocolVersion("XRPL/2.2") == makeProtocol(2, 2));
BEAST_EXPECT(
negotiateProtocolVersion("RTXP/1.2, XRPL/2.3, XRPL/2.4, XRPL/999.999") ==
negotiateProtocolVersion(
"RTXP/1.2, XRPL/2.1, XRPL/2.2, XRPL/2.3, XRPL/2.4, XRPL/999.999") ==
makeProtocol(2, 3));
BEAST_EXPECT(negotiateProtocolVersion("XRPL/999.999, WebSocket/1.0") == std::nullopt);
BEAST_EXPECT(negotiateProtocolVersion("") == std::nullopt);
}
}
};

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,