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