rippled
Loading...
Searching...
No Matches
Feature_test.cpp
1#include <test/jtx.h>
2
3#include <xrpld/app/misc/AmendmentTable.h>
4
5#include <xrpl/protocol/Feature.h>
6#include <xrpl/protocol/jss.h>
7
8namespace ripple {
9
10class Feature_test : public beast::unit_test::suite
11{
12 void
13 testInternals()
14 {
15 testcase("internals");
16
17 auto const& supportedAmendments = ripple::detail::supportedAmendments();
18 auto const& allAmendments = ripple::allAmendments();
19
20 BEAST_EXPECT(
21 supportedAmendments.size() ==
22 ripple::detail::numDownVotedAmendments() +
23 ripple::detail::numUpVotedAmendments());
24 {
25 std::size_t up = 0, down = 0, obsolete = 0;
26 for (auto const& [name, vote] : supportedAmendments)
27 {
28 switch (vote)
29 {
30 case VoteBehavior::DefaultYes:
31 ++up;
32 break;
33 case VoteBehavior::DefaultNo:
34 ++down;
35 break;
36 case VoteBehavior::Obsolete:
37 ++obsolete;
38 break;
39 default:
40 fail("Unknown VoteBehavior", __FILE__, __LINE__);
41 }
42
43 if (vote == VoteBehavior::Obsolete)
44 {
45 BEAST_EXPECT(
46 allAmendments.contains(name) &&
47 allAmendments.at(name) == AmendmentSupport::Retired);
48 }
49 else
50 {
51 BEAST_EXPECT(
52 allAmendments.contains(name) &&
53 allAmendments.at(name) == AmendmentSupport::Supported);
54 }
55 }
56 BEAST_EXPECT(
57 down + obsolete == ripple::detail::numDownVotedAmendments());
58 BEAST_EXPECT(up == ripple::detail::numUpVotedAmendments());
59 }
60 {
61 std::size_t supported = 0, unsupported = 0, retired = 0;
62 for (auto const& [name, support] : allAmendments)
63 {
64 switch (support)
65 {
66 case AmendmentSupport::Supported:
67 ++supported;
68 BEAST_EXPECT(supportedAmendments.contains(name));
69 break;
70 case AmendmentSupport::Unsupported:
71 ++unsupported;
72 break;
73 case AmendmentSupport::Retired:
74 ++retired;
75 break;
76 default:
77 fail("Unknown AmendmentSupport", __FILE__, __LINE__);
78 }
79 }
80
81 BEAST_EXPECT(supported + retired == supportedAmendments.size());
82 BEAST_EXPECT(
83 allAmendments.size() - unsupported ==
84 supportedAmendments.size());
85 }
86 }
87
88 void
89 testFeatureLookups()
90 {
91 testcase("featureToName");
92
93 // Test all the supported features. In a perfect world, this would test
94 // FeatureCollections::featureNames, but that's private. Leave it that
95 // way.
96 auto const supported = ripple::detail::supportedAmendments();
97
98 for (auto const& [feature, vote] : supported)
99 {
100 (void)vote;
101 auto const registered = getRegisteredFeature(feature);
102 if (BEAST_EXPECT(registered))
103 {
104 BEAST_EXPECT(featureToName(*registered) == feature);
105 BEAST_EXPECT(
106 bitsetIndexToFeature(featureToBitsetIndex(*registered)) ==
107 *registered);
108 }
109 }
110
111 // Test an arbitrary unknown feature
112 uint256 zero{0};
113 BEAST_EXPECT(featureToName(zero) == to_string(zero));
114 BEAST_EXPECT(
115 featureToName(zero) ==
116 "0000000000000000000000000000000000000000000000000000000000000000");
117
118 // Test looking up an unknown feature
119 BEAST_EXPECT(!getRegisteredFeature("unknown"));
120
121 // Test a random sampling of the variables. If any of these get retired
122 // or removed, swap out for any other feature.
123 BEAST_EXPECT(
124 featureToName(fixRemoveNFTokenAutoTrustLine) ==
125 "fixRemoveNFTokenAutoTrustLine");
126 BEAST_EXPECT(featureToName(featureFlow) == "Flow");
127 BEAST_EXPECT(featureToName(featureNegativeUNL) == "NegativeUNL");
128 BEAST_EXPECT(
129 featureToName(fixIncludeKeyletFields) == "fixIncludeKeyletFields");
130 BEAST_EXPECT(featureToName(featureTokenEscrow) == "TokenEscrow");
131 }
132
133 void
134 testNoParams()
135 {
136 testcase("No Params, None Enabled");
137
138 using namespace test::jtx;
139 Env env{*this};
140
141 std::map<std::string, VoteBehavior> const& votes =
142 ripple::detail::supportedAmendments();
143
144 auto jrr = env.rpc("feature")[jss::result];
145 if (!BEAST_EXPECT(jrr.isMember(jss::features)))
146 return;
147 for (auto const& feature : jrr[jss::features])
148 {
149 if (!BEAST_EXPECT(feature.isMember(jss::name)))
150 return;
151 // default config - so all should be disabled, and
152 // supported. Some may be vetoed.
153 bool expectVeto =
154 (votes.at(feature[jss::name].asString()) ==
155 VoteBehavior::DefaultNo);
156 bool expectObsolete =
157 (votes.at(feature[jss::name].asString()) ==
158 VoteBehavior::Obsolete);
159 BEAST_EXPECTS(
160 feature.isMember(jss::enabled) &&
161 !feature[jss::enabled].asBool(),
162 feature[jss::name].asString() + " enabled");
163 BEAST_EXPECTS(
164 feature.isMember(jss::vetoed) &&
165 feature[jss::vetoed].isBool() == !expectObsolete &&
166 (!feature[jss::vetoed].isBool() ||
167 feature[jss::vetoed].asBool() == expectVeto) &&
168 (feature[jss::vetoed].isBool() ||
169 feature[jss::vetoed].asString() == "Obsolete"),
170 feature[jss::name].asString() + " vetoed");
171 BEAST_EXPECTS(
172 feature.isMember(jss::supported) &&
173 feature[jss::supported].asBool(),
174 feature[jss::name].asString() + " supported");
175 }
176 }
177
178 void
179 testSingleFeature()
180 {
181 testcase("Feature Param");
182
183 using namespace test::jtx;
184 Env env{*this};
185
186 auto jrr = env.rpc("feature", "MultiSignReserve")[jss::result];
187 BEAST_EXPECTS(jrr[jss::status] == jss::success, "status");
188 jrr.removeMember(jss::status);
189 BEAST_EXPECT(jrr.size() == 1);
190 BEAST_EXPECT(
191 jrr.isMember("586480873651E106F1D6339B0C4A8945BA705A777F3F4524626FF"
192 "1FC07EFE41D"));
193 auto feature = *(jrr.begin());
194
195 BEAST_EXPECTS(feature[jss::name] == "MultiSignReserve", "name");
196 BEAST_EXPECTS(!feature[jss::enabled].asBool(), "enabled");
197 BEAST_EXPECTS(
198 feature[jss::vetoed].isBool() && !feature[jss::vetoed].asBool(),
199 "vetoed");
200 BEAST_EXPECTS(feature[jss::supported].asBool(), "supported");
201
202 // feature names are case-sensitive - expect error here
203 jrr = env.rpc("feature", "multiSignReserve")[jss::result];
204 BEAST_EXPECT(jrr[jss::error] == "badFeature");
205 BEAST_EXPECT(jrr[jss::error_message] == "Feature unknown or invalid.");
206 }
207
208 void
209 testInvalidFeature()
210 {
211 testcase("Invalid Feature");
212
213 using namespace test::jtx;
214 Env env{*this};
215
216 auto testInvalidParam = [&](auto const& param) {
217 Json::Value params;
218 params[jss::feature] = param;
219 auto jrr =
220 env.rpc("json", "feature", to_string(params))[jss::result];
221 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
222 BEAST_EXPECT(jrr[jss::error_message] == "Invalid parameters.");
223 };
224
225 testInvalidParam(1);
226 testInvalidParam(1.1);
227 testInvalidParam(true);
228 testInvalidParam(Json::Value(Json::nullValue));
229 testInvalidParam(Json::Value(Json::objectValue));
230 testInvalidParam(Json::Value(Json::arrayValue));
231
232 {
233 auto jrr = env.rpc("feature", "AllTheThings")[jss::result];
234 BEAST_EXPECT(jrr[jss::error] == "badFeature");
235 BEAST_EXPECT(
236 jrr[jss::error_message] == "Feature unknown or invalid.");
237 }
238 }
239
240 void
241 testNonAdmin()
242 {
243 testcase("Feature Without Admin");
244
245 using namespace test::jtx;
246 Env env{*this, envconfig([](std::unique_ptr<Config> cfg) {
247 (*cfg)["port_rpc"].set("admin", "");
248 (*cfg)["port_ws"].set("admin", "");
249 return cfg;
250 })};
251
252 {
253 auto result = env.rpc("feature")[jss::result];
254 BEAST_EXPECT(result.isMember(jss::features));
255 // There should be at least 50 amendments. Don't do exact
256 // comparison to avoid maintenance as more amendments are added in
257 // the future.
258 BEAST_EXPECT(result[jss::features].size() >= 50);
259 for (auto it = result[jss::features].begin();
260 it != result[jss::features].end();
261 ++it)
262 {
263 uint256 id;
264 (void)id.parseHex(it.key().asString().c_str());
265 if (!BEAST_EXPECT((*it).isMember(jss::name)))
266 return;
267 bool expectEnabled =
268 env.app().getAmendmentTable().isEnabled(id);
269 bool expectSupported =
270 env.app().getAmendmentTable().isSupported(id);
271 BEAST_EXPECTS(
272 (*it).isMember(jss::enabled) &&
273 (*it)[jss::enabled].asBool() == expectEnabled,
274 (*it)[jss::name].asString() + " enabled");
275 BEAST_EXPECTS(
276 (*it).isMember(jss::supported) &&
277 (*it)[jss::supported].asBool() == expectSupported,
278 (*it)[jss::name].asString() + " supported");
279 BEAST_EXPECT(!(*it).isMember(jss::vetoed));
280 BEAST_EXPECT(!(*it).isMember(jss::majority));
281 BEAST_EXPECT(!(*it).isMember(jss::count));
282 BEAST_EXPECT(!(*it).isMember(jss::validations));
283 BEAST_EXPECT(!(*it).isMember(jss::threshold));
284 }
285 }
286
287 {
288 Json::Value params;
289 // invalid feature
290 params[jss::feature] =
291 "1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCD"
292 "EF";
293 auto const result =
294 env.rpc("json", "feature", to_string(params))[jss::result];
295 BEAST_EXPECTS(
296 result[jss::error] == "badFeature", result.toStyledString());
297 BEAST_EXPECT(
298 result[jss::error_message] == "Feature unknown or invalid.");
299 }
300
301 {
302 Json::Value params;
303 params[jss::feature] =
304 "93E516234E35E08CA689FA33A6D38E103881F8DCB53023F728C307AA89D515"
305 "A7";
306 // invalid param
307 params[jss::vetoed] = true;
308 auto const result =
309 env.rpc("json", "feature", to_string(params))[jss::result];
310 BEAST_EXPECTS(
311 result[jss::error] == "noPermission",
312 result[jss::error].asString());
313 BEAST_EXPECT(
314 result[jss::error_message] ==
315 "You don't have permission for this command.");
316 }
317 }
318
319 void
320 testSomeEnabled()
321 {
322 testcase("No Params, Some Enabled");
323
324 using namespace test::jtx;
325 Env env{
326 *this, FeatureBitset(featureDepositAuth, featureDepositPreauth)};
327
328 std::map<std::string, VoteBehavior> const& votes =
329 ripple::detail::supportedAmendments();
330
331 auto jrr = env.rpc("feature")[jss::result];
332 if (!BEAST_EXPECT(jrr.isMember(jss::features)))
333 return;
334 for (auto it = jrr[jss::features].begin();
335 it != jrr[jss::features].end();
336 ++it)
337 {
338 uint256 id;
339 (void)id.parseHex(it.key().asString().c_str());
340 if (!BEAST_EXPECT((*it).isMember(jss::name)))
341 return;
342 bool expectEnabled = env.app().getAmendmentTable().isEnabled(id);
343 bool expectSupported =
344 env.app().getAmendmentTable().isSupported(id);
345 bool expectVeto =
346 (votes.at((*it)[jss::name].asString()) ==
347 VoteBehavior::DefaultNo);
348 bool expectObsolete =
349 (votes.at((*it)[jss::name].asString()) ==
350 VoteBehavior::Obsolete);
351 BEAST_EXPECTS(
352 (*it).isMember(jss::enabled) &&
353 (*it)[jss::enabled].asBool() == expectEnabled,
354 (*it)[jss::name].asString() + " enabled");
355 if (expectEnabled)
356 BEAST_EXPECTS(
357 !(*it).isMember(jss::vetoed),
358 (*it)[jss::name].asString() + " vetoed");
359 else
360 BEAST_EXPECTS(
361 (*it).isMember(jss::vetoed) &&
362 (*it)[jss::vetoed].isBool() == !expectObsolete &&
363 (!(*it)[jss::vetoed].isBool() ||
364 (*it)[jss::vetoed].asBool() == expectVeto) &&
365 ((*it)[jss::vetoed].isBool() ||
366 (*it)[jss::vetoed].asString() == "Obsolete"),
367 (*it)[jss::name].asString() + " vetoed");
368 BEAST_EXPECTS(
369 (*it).isMember(jss::supported) &&
370 (*it)[jss::supported].asBool() == expectSupported,
371 (*it)[jss::name].asString() + " supported");
372 }
373 }
374
375 void
376 testWithMajorities()
377 {
378 testcase("With Majorities");
379
380 using namespace test::jtx;
381 Env env{*this, envconfig(validator, "")};
382
383 auto jrr = env.rpc("feature")[jss::result];
384 if (!BEAST_EXPECT(jrr.isMember(jss::features)))
385 return;
386
387 // at this point, there are no majorities so no fields related to
388 // amendment voting
389 for (auto const& feature : jrr[jss::features])
390 {
391 if (!BEAST_EXPECT(feature.isMember(jss::name)))
392 return;
393 BEAST_EXPECTS(
394 !feature.isMember(jss::majority),
395 feature[jss::name].asString() + " majority");
396 BEAST_EXPECTS(
397 !feature.isMember(jss::count),
398 feature[jss::name].asString() + " count");
399 BEAST_EXPECTS(
400 !feature.isMember(jss::threshold),
401 feature[jss::name].asString() + " threshold");
402 BEAST_EXPECTS(
403 !feature.isMember(jss::validations),
404 feature[jss::name].asString() + " validations");
405 BEAST_EXPECTS(
406 !feature.isMember(jss::vote),
407 feature[jss::name].asString() + " vote");
408 }
409
410 auto majorities = getMajorityAmendments(*env.closed());
411 if (!BEAST_EXPECT(majorities.empty()))
412 return;
413
414 // close ledgers until the amendments show up.
415 for (auto i = 0; i <= 256; ++i)
416 {
417 env.close();
418 majorities = getMajorityAmendments(*env.closed());
419 if (!majorities.empty())
420 break;
421 }
422
423 // There should be at least 5 amendments. Don't do exact comparison
424 // to avoid maintenance as more amendments are added in the future.
425 BEAST_EXPECT(majorities.size() >= 5);
426 std::map<std::string, VoteBehavior> const& votes =
427 ripple::detail::supportedAmendments();
428
429 jrr = env.rpc("feature")[jss::result];
430 if (!BEAST_EXPECT(jrr.isMember(jss::features)))
431 return;
432 for (auto const& feature : jrr[jss::features])
433 {
434 if (!BEAST_EXPECT(feature.isMember(jss::name)))
435 return;
436 bool expectVeto =
437 (votes.at(feature[jss::name].asString()) ==
438 VoteBehavior::DefaultNo);
439 bool expectObsolete =
440 (votes.at(feature[jss::name].asString()) ==
441 VoteBehavior::Obsolete);
442 BEAST_EXPECTS(
443 (expectVeto || expectObsolete) ^
444 feature.isMember(jss::majority),
445 feature[jss::name].asString() + " majority");
446 BEAST_EXPECTS(
447 feature.isMember(jss::vetoed) &&
448 feature[jss::vetoed].isBool() == !expectObsolete &&
449 (!feature[jss::vetoed].isBool() ||
450 feature[jss::vetoed].asBool() == expectVeto) &&
451 (feature[jss::vetoed].isBool() ||
452 feature[jss::vetoed].asString() == "Obsolete"),
453 feature[jss::name].asString() + " vetoed");
454 BEAST_EXPECTS(
455 feature.isMember(jss::count),
456 feature[jss::name].asString() + " count");
457 BEAST_EXPECTS(
458 feature.isMember(jss::threshold),
459 feature[jss::name].asString() + " threshold");
460 BEAST_EXPECTS(
461 feature.isMember(jss::validations),
462 feature[jss::name].asString() + " validations");
463 BEAST_EXPECT(
464 feature[jss::count] ==
465 ((expectVeto || expectObsolete) ? 0 : 1));
466 BEAST_EXPECT(feature[jss::threshold] == 1);
467 BEAST_EXPECT(feature[jss::validations] == 1);
468 BEAST_EXPECTS(
469 expectVeto || expectObsolete || feature[jss::majority] == 2540,
470 "Majority: " + feature[jss::majority].asString());
471 }
472 }
473
474 void
475 testVeto()
476 {
477 testcase("Veto");
478
479 using namespace test::jtx;
480 Env env{*this, FeatureBitset(featureMultiSignReserve)};
481 constexpr char const* featureName = "MultiSignReserve";
482
483 auto jrr = env.rpc("feature", featureName)[jss::result];
484 if (!BEAST_EXPECTS(jrr[jss::status] == jss::success, "status"))
485 return;
486 jrr.removeMember(jss::status);
487 if (!BEAST_EXPECT(jrr.size() == 1))
488 return;
489 auto feature = *(jrr.begin());
490 BEAST_EXPECTS(feature[jss::name] == featureName, "name");
491 BEAST_EXPECTS(
492 feature[jss::vetoed].isBool() && !feature[jss::vetoed].asBool(),
493 "vetoed");
494
495 jrr = env.rpc("feature", featureName, "reject")[jss::result];
496 if (!BEAST_EXPECTS(jrr[jss::status] == jss::success, "status"))
497 return;
498 jrr.removeMember(jss::status);
499 if (!BEAST_EXPECT(jrr.size() == 1))
500 return;
501 feature = *(jrr.begin());
502 BEAST_EXPECTS(feature[jss::name] == featureName, "name");
503 BEAST_EXPECTS(
504 feature[jss::vetoed].isBool() && feature[jss::vetoed].asBool(),
505 "vetoed");
506
507 jrr = env.rpc("feature", featureName, "accept")[jss::result];
508 if (!BEAST_EXPECTS(jrr[jss::status] == jss::success, "status"))
509 return;
510 jrr.removeMember(jss::status);
511 if (!BEAST_EXPECT(jrr.size() == 1))
512 return;
513 feature = *(jrr.begin());
514 BEAST_EXPECTS(feature[jss::name] == featureName, "name");
515 BEAST_EXPECTS(
516 feature[jss::vetoed].isBool() && !feature[jss::vetoed].asBool(),
517 "vetoed");
518
519 // anything other than accept or reject is an error
520 jrr = env.rpc("feature", featureName, "maybe");
521 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
522 BEAST_EXPECT(jrr[jss::error_message] == "Invalid parameters.");
523 }
524
525 void
526 testObsolete()
527 {
528 testcase("Obsolete");
529
530 using namespace test::jtx;
531 Env env{*this};
532 constexpr char const* featureName = "CryptoConditionsSuite";
533
534 auto jrr = env.rpc("feature", featureName)[jss::result];
535 if (!BEAST_EXPECTS(jrr[jss::status] == jss::success, "status"))
536 return;
537 jrr.removeMember(jss::status);
538 if (!BEAST_EXPECT(jrr.size() == 1))
539 return;
540 auto feature = *(jrr.begin());
541 BEAST_EXPECTS(feature[jss::name] == featureName, "name");
542 BEAST_EXPECTS(
543 feature[jss::vetoed].isString() &&
544 feature[jss::vetoed].asString() == "Obsolete",
545 "vetoed");
546
547 jrr = env.rpc("feature", featureName, "reject")[jss::result];
548 if (!BEAST_EXPECTS(jrr[jss::status] == jss::success, "status"))
549 return;
550 jrr.removeMember(jss::status);
551 if (!BEAST_EXPECT(jrr.size() == 1))
552 return;
553 feature = *(jrr.begin());
554 BEAST_EXPECTS(feature[jss::name] == featureName, "name");
555 BEAST_EXPECTS(
556 feature[jss::vetoed].isString() &&
557 feature[jss::vetoed].asString() == "Obsolete",
558 "vetoed");
559
560 jrr = env.rpc("feature", featureName, "accept")[jss::result];
561 if (!BEAST_EXPECTS(jrr[jss::status] == jss::success, "status"))
562 return;
563 jrr.removeMember(jss::status);
564 if (!BEAST_EXPECT(jrr.size() == 1))
565 return;
566 feature = *(jrr.begin());
567 BEAST_EXPECTS(feature[jss::name] == featureName, "name");
568 BEAST_EXPECTS(
569 feature[jss::vetoed].isString() &&
570 feature[jss::vetoed].asString() == "Obsolete",
571 "vetoed");
572
573 // anything other than accept or reject is an error
574 jrr = env.rpc("feature", featureName, "maybe");
575 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
576 BEAST_EXPECT(jrr[jss::error_message] == "Invalid parameters.");
577 }
578
579public:
580 void
581 run() override
582 {
583 testInternals();
584 testFeatureLookups();
585 testNoParams();
586 testSingleFeature();
587 testInvalidFeature();
588 testNonAdmin();
589 testSomeEnabled();
590 testWithMajorities();
591 testVeto();
592 testObsolete();
593 }
594};
595
596BEAST_DEFINE_TESTSUITE(Feature, rpc, ripple);
597
598} // namespace ripple
std::map::at
T at(T... args)
Json::Value
Represents a JSON value.
Definition json_value.h:130
beast::unit_test::suite
A testsuite class.
Definition suite.h:52
beast::unit_test::suite::testcase
testcase_t testcase
Memberspace for declaring test cases.
Definition suite.h:152
beast::unit_test::suite::fail
void fail(String const &reason, char const *file, int line)
Record a failure.
Definition suite.h:530
ripple::Feature_test
Definition Feature_test.cpp:11
ripple::Feature_test::testInvalidFeature
void testInvalidFeature()
Definition Feature_test.cpp:209
ripple::Feature_test::testObsolete
void testObsolete()
Definition Feature_test.cpp:526
ripple::Feature_test::testFeatureLookups
void testFeatureLookups()
Definition Feature_test.cpp:89
ripple::Feature_test::testNoParams
void testNoParams()
Definition Feature_test.cpp:134
ripple::Feature_test::testNonAdmin
void testNonAdmin()
Definition Feature_test.cpp:241
ripple::Feature_test::testSomeEnabled
void testSomeEnabled()
Definition Feature_test.cpp:320
ripple::Feature_test::testInternals
void testInternals()
Definition Feature_test.cpp:13
ripple::Feature_test::testVeto
void testVeto()
Definition Feature_test.cpp:475
ripple::Feature_test::testSingleFeature
void testSingleFeature()
Definition Feature_test.cpp:179
ripple::Feature_test::testWithMajorities
void testWithMajorities()
Definition Feature_test.cpp:376
ripple::Feature_test::run
void run() override
Runs the suite.
Definition Feature_test.cpp:581
ripple::base_uint< 256 >
Json::nullValue
@ nullValue
'null' value
Definition json_value.h:19
Json::arrayValue
@ arrayValue
array value (ordered list)
Definition json_value.h:25
Json::objectValue
@ objectValue
object value (collection of name/value pairs).
Definition json_value.h:26
ripple::detail::numUpVotedAmendments
std::size_t numUpVotedAmendments()
Amendments that this server will vote for by default.
Definition Feature.cpp:355
ripple::detail::numDownVotedAmendments
std::size_t numDownVotedAmendments()
Amendments that this server won't vote for by default.
Definition Feature.cpp:348
ripple::detail::supportedAmendments
std::map< std::string, VoteBehavior > const & supportedAmendments()
Amendments that this server supports and the default voting behavior.
Definition Feature.cpp:341
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:6
ripple::bitsetIndexToFeature
uint256 bitsetIndexToFeature(size_t i)
Definition Feature.cpp:396
ripple::featureToBitsetIndex
size_t featureToBitsetIndex(uint256 const &f)
Definition Feature.cpp:390
ripple::allAmendments
std::map< std::string, AmendmentSupport > const & allAmendments()
All amendments libxrpl knows about.
Definition Feature.cpp:332
ripple::featureToName
std::string featureToName(uint256 const &f)
Definition Feature.cpp:402
ripple::getRegisteredFeature
std::optional< uint256 > getRegisteredFeature(std::string const &name)
Definition Feature.cpp:363
ripple::getMajorityAmendments
majorityAmendments_t getMajorityAmendments(ReadView const &view)
Definition View.cpp:919
ripple::to_string
std::string to_string(base_uint< Bits, Tag > const &a)
Definition base_uint.h:611
Generated by doxygen 1.9.8