xrpld
Loading...
Searching...
No Matches
ValidatorRPC_test.cpp
1#include <test/jtx/Env.h>
2#include <test/jtx/TrustedPublisherServer.h>
3#include <test/jtx/envconfig.h>
4
5#include <xrpld/app/main/BasicApp.h>
6#include <xrpld/app/misc/ValidatorSite.h>
7#include <xrpld/core/Config.h>
8
9#include <xrpl/basics/UnorderedContainers.h>
10#include <xrpl/basics/chrono.h>
11#include <xrpl/basics/strHex.h>
12#include <xrpl/beast/unit_test/suite.h>
13#include <xrpl/config/Constants.h>
14#include <xrpl/json/json_value.h>
15#include <xrpl/protocol/KeyType.h>
16#include <xrpl/protocol/PublicKey.h>
17#include <xrpl/protocol/SecretKey.h>
18#include <xrpl/protocol/UintTypes.h>
19#include <xrpl/protocol/jss.h>
20#include <xrpl/protocol/tokens.h>
21
22#include <chrono>
23#include <cstdint>
24#include <limits>
25#include <memory>
26#include <set>
27#include <sstream>
28#include <string>
29#include <vector>
30
31namespace xrpl::test {
32
34{
36
37public:
38 void
40 {
41 using namespace test::jtx;
42
43 for (bool const isAdmin : {true, false})
44 {
45 for (std::string const cmd : {"validators", "validator_list_sites"})
46 {
47 Env env{*this, isAdmin ? envconfig() : envconfig(noAdmin)};
48 env.setRetries(isAdmin ? 5 : 0);
49 auto const jrr = env.rpc(cmd)[jss::result];
50 if (isAdmin)
51 {
52 BEAST_EXPECT(!jrr.isMember(jss::error));
53 BEAST_EXPECT(jrr[jss::status] == "success");
54 }
55 else
56 {
57 // The current HTTP/S ServerHandler returns an HTTP 403
58 // error code here rather than a noPermission JSON error.
59 // The JSONRPCClient just eats that error and returns null
60 // result.
61 BEAST_EXPECT(jrr.isNull());
62 }
63 }
64
65 {
66 Env env{*this, isAdmin ? envconfig() : envconfig(noAdmin)};
67 auto const jrr = env.rpc("server_info")[jss::result];
68 BEAST_EXPECT(jrr[jss::status] == "success");
69 BEAST_EXPECT(jrr[jss::info].isMember(jss::validator_list) == isAdmin);
70 }
71
72 {
73 Env env{*this, isAdmin ? envconfig() : envconfig(noAdmin)};
74 auto const jrr = env.rpc("server_state")[jss::result];
75 BEAST_EXPECT(jrr[jss::status] == "success");
76 BEAST_EXPECT(jrr[jss::state].isMember(jss::validator_list_expires) == isAdmin);
77 }
78 }
79 }
80
81 void
83 {
84 using namespace test::jtx;
85
86 std::set<std::string> const keys = {
87 "n949f75evCHwgyP4fPVgaHqNHxUVN15PsJEZ3B3HnXPcPjcZAoy7",
88 "n9MD5h24qrQqiyBC8aeqqCWvpiBiYQ3jxSr91uiDvmrkyHRdYLUj",
89 };
90 Env env{
91 *this,
93 for (auto const& key : keys)
94 cfg->section(Sections::kValidators).append(key);
95 return cfg;
96 }),
97 };
98
99 // Server info reports maximum expiration since not dynamic
100 {
101 auto const jrr = env.rpc("server_info")[jss::result];
102 BEAST_EXPECT(jrr[jss::info][jss::validator_list][jss::expiration] == "never");
103 }
104 {
105 auto const jrr = env.rpc("server_state")[jss::result];
106 BEAST_EXPECT(
107 jrr[jss::state][jss::validator_list_expires].asUInt() ==
108 NetClock::time_point::max().time_since_epoch().count());
109 }
110 // All our keys are in the response
111 {
112 auto const jrr = env.rpc("validators")[jss::result];
113 BEAST_EXPECT(jrr[jss::validator_list][jss::expiration] == "never");
114 BEAST_EXPECT(jrr[jss::validation_quorum].asUInt() == keys.size());
115 BEAST_EXPECT(jrr[jss::trusted_validator_keys].size() == keys.size());
116 BEAST_EXPECT(jrr[jss::publisher_lists].size() == 0);
117 BEAST_EXPECT(jrr[jss::local_static_keys].size() == keys.size());
118 for (auto const& jKey : jrr[jss::local_static_keys])
119 {
120 BEAST_EXPECT(keys.count(jKey.asString()) == 1);
121 }
122 BEAST_EXPECT(jrr[jss::signing_keys].size() == 0);
123 }
124 // No validator sites configured
125 {
126 auto const jrr = env.rpc("validator_list_sites")[jss::result];
127 BEAST_EXPECT(jrr[jss::validator_sites].size() == 0);
128 }
129 // Negative UNL empty
130 {
131 auto const jrr = env.rpc("validators")[jss::result];
132 BEAST_EXPECT(jrr[jss::NegativeUNL].isNull());
133 }
134 // Negative UNL update
135 {
136 HashSet<PublicKey> disabledKeys;
137 auto const k1 = randomKeyPair(KeyType::Ed25519).first;
138 auto const k2 = randomKeyPair(KeyType::Ed25519).first;
139 disabledKeys.insert(k1);
140 disabledKeys.insert(k2);
141 env.app().getValidators().setNegativeUNL(disabledKeys);
142
143 auto const jrr = env.rpc("validators")[jss::result];
144 auto& jrrnUnl = jrr[jss::NegativeUNL];
145 auto const jrrnUnlSize = jrrnUnl.size();
146 BEAST_EXPECT(jrrnUnlSize == 2);
147 for (std::uint32_t x = 0; x < jrrnUnlSize; ++x)
148 {
149 auto parsedKey =
150 parseBase58<PublicKey>(TokenType::NodePublic, jrrnUnl[x].asString());
151 BEAST_EXPECT(parsedKey);
152 if (parsedKey)
153 BEAST_EXPECT(disabledKeys.contains(*parsedKey));
154 }
155
156 disabledKeys.clear();
157 env.app().getValidators().setNegativeUNL(disabledKeys);
158 auto const jrrUpdated = env.rpc("validators")[jss::result];
159 BEAST_EXPECT(jrrUpdated[jss::NegativeUNL].isNull());
160 }
161 }
162
163 void
165 {
166 using namespace test::jtx;
167
168 auto const toStr = [](PublicKey const& publicKey) {
169 return toBase58(TokenType::NodePublic, publicKey);
170 };
171
172 // Validator keys that will be in the published list
173 std::vector<Validator> const validators = {
176 };
177 std::set<std::string> expectedKeys;
178 for (auto const& val : validators)
179 expectedKeys.insert(toStr(val.masterPublic));
180
181 // Manage single-thread io_context for server.
182 BasicApp worker{1};
183 using namespace std::chrono_literals;
184 NetClock::time_point const validUntil{3600s};
185 NetClock::time_point const validFrom2{validUntil - 60s};
186 NetClock::time_point const validUntil2{validFrom2 + 3600s};
187 auto server = makeTrustedPublisherServer(
188 worker.getIoContext(),
189 validators,
190 validUntil,
191 {{validFrom2, validUntil2}},
192 false,
193 1,
194 false);
195
196 //----------------------------------------------------------------------
197 // Publisher list site unavailable v1
198 {
199 // Publisher site information
200 using namespace std::string_literals;
201 std::string siteURI = "http://"s + getEnvLocalhostAddr() + ":1234/validators";
202
203 Env env{
204 *this,
206 cfg->section(Sections::kValidatorListSites).append(siteURI);
207 cfg->section(Sections::kValidatorListKeys)
208 .append(strHex(server->publisherPublic()));
209 return cfg;
210 }),
211 };
212
213 env.app().getValidatorSites().start();
214 env.app().getValidatorSites().join();
215
216 {
217 auto const jrr = env.rpc("server_info")[jss::result];
218 BEAST_EXPECT(jrr[jss::info][jss::validator_list][jss::expiration] == "unknown");
219 }
220 {
221 auto const jrr = env.rpc("server_state")[jss::result];
222 BEAST_EXPECT(jrr[jss::state][jss::validator_list_expires].asInt() == 0);
223 }
224 {
225 auto const jrr = env.rpc("validators")[jss::result];
226 BEAST_EXPECT(
227 jrr[jss::validation_quorum].asUInt() ==
229 BEAST_EXPECT(jrr[jss::local_static_keys].size() == 0);
230 BEAST_EXPECT(jrr[jss::trusted_validator_keys].size() == 0);
231 BEAST_EXPECT(jrr[jss::validator_list][jss::expiration] == "unknown");
232
233 if (BEAST_EXPECT(jrr[jss::publisher_lists].size() == 1))
234 {
235 auto jp = jrr[jss::publisher_lists][0u];
236 BEAST_EXPECT(jp[jss::available] == false);
237 BEAST_EXPECT(jp[jss::list].size() == 0);
238 BEAST_EXPECT(!jp.isMember(jss::seq));
239 BEAST_EXPECT(!jp.isMember(jss::expiration));
240 BEAST_EXPECT(!jp.isMember(jss::version));
241 BEAST_EXPECT(jp[jss::pubkey_publisher] == strHex(server->publisherPublic()));
242 }
243 BEAST_EXPECT(jrr[jss::signing_keys].size() == 0);
244 }
245 {
246 auto const jrr = env.rpc("validator_list_sites")[jss::result];
247 if (BEAST_EXPECT(jrr[jss::validator_sites].size() == 1))
248 {
249 auto js = jrr[jss::validator_sites][0u];
250 BEAST_EXPECT(js[jss::refresh_interval_min].asUInt() == 5);
251 BEAST_EXPECT(js[jss::uri] == siteURI);
252 BEAST_EXPECT(js.isMember(jss::last_refresh_time));
253 BEAST_EXPECT(js[jss::last_refresh_status] == "invalid");
254 }
255 }
256 }
257 // Publisher list site unavailable v2
258 {
259 // Publisher site information
260 using namespace std::string_literals;
261 std::string siteURI = "http://"s + getEnvLocalhostAddr() + ":1234/validators2";
262
263 Env env{
264 *this,
265 envconfig([&](std::unique_ptr<Config> cfg) {
266 cfg->section(Sections::kValidatorListSites).append(siteURI);
267 cfg->section(Sections::kValidatorListKeys)
268 .append(strHex(server->publisherPublic()));
269 return cfg;
270 }),
271 };
272
273 env.app().getValidatorSites().start();
274 env.app().getValidatorSites().join();
275
276 {
277 auto const jrr = env.rpc("server_info")[jss::result];
278 BEAST_EXPECT(jrr[jss::info][jss::validator_list][jss::expiration] == "unknown");
279 }
280 {
281 auto const jrr = env.rpc("server_state")[jss::result];
282 BEAST_EXPECT(jrr[jss::state][jss::validator_list_expires].asInt() == 0);
283 }
284 {
285 auto const jrr = env.rpc("validators")[jss::result];
286 BEAST_EXPECT(
287 jrr[jss::validation_quorum].asUInt() ==
289 BEAST_EXPECT(jrr[jss::local_static_keys].size() == 0);
290 BEAST_EXPECT(jrr[jss::trusted_validator_keys].size() == 0);
291 BEAST_EXPECT(jrr[jss::validator_list][jss::expiration] == "unknown");
292
293 if (BEAST_EXPECT(jrr[jss::publisher_lists].size() == 1))
294 {
295 auto jp = jrr[jss::publisher_lists][0u];
296 BEAST_EXPECT(jp[jss::available] == false);
297 BEAST_EXPECT(jp[jss::list].size() == 0);
298 BEAST_EXPECT(!jp.isMember(jss::seq));
299 BEAST_EXPECT(!jp.isMember(jss::expiration));
300 BEAST_EXPECT(!jp.isMember(jss::version));
301 BEAST_EXPECT(jp[jss::pubkey_publisher] == strHex(server->publisherPublic()));
302 }
303 BEAST_EXPECT(jrr[jss::signing_keys].size() == 0);
304 }
305 {
306 auto const jrr = env.rpc("validator_list_sites")[jss::result];
307 if (BEAST_EXPECT(jrr[jss::validator_sites].size() == 1))
308 {
309 auto js = jrr[jss::validator_sites][0u];
310 BEAST_EXPECT(js[jss::refresh_interval_min].asUInt() == 5);
311 BEAST_EXPECT(js[jss::uri] == siteURI);
312 BEAST_EXPECT(js.isMember(jss::last_refresh_time));
313 BEAST_EXPECT(js[jss::last_refresh_status] == "invalid");
314 }
315 }
316 }
317 //----------------------------------------------------------------------
318 // Publisher list site available
319 server->start();
320 // Publisher list site available v1
321 {
322 std::stringstream uri;
323 uri << "http://" << server->localEndpoint() << "/validators";
324 auto siteURI = uri.str();
325
326 Env env{
327 *this,
328 envconfig([&](std::unique_ptr<Config> cfg) {
329 cfg->section(Sections::kValidatorListSites).append(siteURI);
330 cfg->section(Sections::kValidatorListKeys)
331 .append(strHex(server->publisherPublic()));
332 return cfg;
333 }),
334 };
335
336 env.app().getValidatorSites().start();
337 env.app().getValidatorSites().join();
338 HashSet<NodeID> startKeys;
339 for (auto const& val : validators)
340 startKeys.insert(calcNodeID(val.masterPublic));
341
342 env.app().getValidators().updateTrusted(
343 startKeys,
344 env.timeKeeper().now(),
345 env.app().getOPs(),
346 env.app().getOverlay(),
347 env.app().getHashRouter());
348
349 {
350 auto const jrr = env.rpc("server_info")[jss::result];
351 BEAST_EXPECT(
352 jrr[jss::info][jss::validator_list][jss::expiration] == to_string(validUntil));
353 }
354 {
355 auto const jrr = env.rpc("server_state")[jss::result];
356 BEAST_EXPECT(
357 jrr[jss::state][jss::validator_list_expires].asUInt() ==
358 validUntil.time_since_epoch().count());
359 }
360 {
361 auto const jrr = env.rpc("validators")[jss::result];
362 BEAST_EXPECT(jrr[jss::validation_quorum].asUInt() == 2);
363 BEAST_EXPECT(jrr[jss::validator_list][jss::expiration] == to_string(validUntil));
364 BEAST_EXPECT(jrr[jss::local_static_keys].size() == 0);
365
366 BEAST_EXPECT(jrr[jss::trusted_validator_keys].size() == expectedKeys.size());
367 for (auto const& jKey : jrr[jss::trusted_validator_keys])
368 {
369 BEAST_EXPECT(expectedKeys.count(jKey.asString()) == 1);
370 }
371
372 if (BEAST_EXPECT(jrr[jss::publisher_lists].size() == 1))
373 {
374 auto jp = jrr[jss::publisher_lists][0u];
375 BEAST_EXPECT(jp[jss::available] == true);
376 if (BEAST_EXPECT(jp[jss::list].size() == 2))
377 {
378 // check entries
379 std::set<std::string> foundKeys;
380 for (auto const& k : jp[jss::list])
381 {
382 foundKeys.insert(k.asString());
383 }
384 BEAST_EXPECT(foundKeys == expectedKeys);
385 }
386 BEAST_EXPECT(jp[jss::seq].asUInt() == 1);
387 BEAST_EXPECT(jp[jss::pubkey_publisher] == strHex(server->publisherPublic()));
388 BEAST_EXPECT(jp[jss::expiration] == to_string(validUntil));
389 BEAST_EXPECT(jp[jss::version] == 1);
390 }
391 auto jsk = jrr[jss::signing_keys];
392 BEAST_EXPECT(jsk.size() == 2);
393 for (auto const& val : validators)
394 {
395 BEAST_EXPECT(jsk.isMember(toStr(val.masterPublic)));
396 BEAST_EXPECT(jsk[toStr(val.masterPublic)] == toStr(val.signingPublic));
397 }
398 }
399 {
400 auto const jrr = env.rpc("validator_list_sites")[jss::result];
401 if (BEAST_EXPECT(jrr[jss::validator_sites].size() == 1))
402 {
403 auto js = jrr[jss::validator_sites][0u];
404 BEAST_EXPECT(js[jss::refresh_interval_min].asUInt() == 5);
405 BEAST_EXPECT(js[jss::uri] == siteURI);
406 BEAST_EXPECT(js[jss::last_refresh_status] == "accepted");
407 // The actual time of the update will vary run to run, so
408 // just verify the time is there
409 BEAST_EXPECT(js.isMember(jss::last_refresh_time));
410 }
411 }
412 }
413 // Publisher list site available v2
414 {
415 std::stringstream uri;
416 uri << "http://" << server->localEndpoint() << "/validators2";
417 auto siteURI = uri.str();
418
419 Env env{
420 *this,
421 envconfig([&](std::unique_ptr<Config> cfg) {
422 cfg->section(Sections::kValidatorListSites).append(siteURI);
423 cfg->section(Sections::kValidatorListKeys)
424 .append(strHex(server->publisherPublic()));
425 return cfg;
426 }),
427 };
428
429 env.app().getValidatorSites().start();
430 env.app().getValidatorSites().join();
431 HashSet<NodeID> startKeys;
432 for (auto const& val : validators)
433 startKeys.insert(calcNodeID(val.masterPublic));
434
435 env.app().getValidators().updateTrusted(
436 startKeys,
437 env.timeKeeper().now(),
438 env.app().getOPs(),
439 env.app().getOverlay(),
440 env.app().getHashRouter());
441
442 {
443 auto const jrr = env.rpc("server_info")[jss::result];
444 BEAST_EXPECT(
445 jrr[jss::info][jss::validator_list][jss::expiration] == to_string(validUntil2));
446 }
447 {
448 auto const jrr = env.rpc("server_state")[jss::result];
449 BEAST_EXPECT(
450 jrr[jss::state][jss::validator_list_expires].asUInt() ==
451 validUntil2.time_since_epoch().count());
452 }
453 {
454 auto const jrr = env.rpc("validators")[jss::result];
455 BEAST_EXPECT(jrr[jss::validation_quorum].asUInt() == 2);
456 BEAST_EXPECT(jrr[jss::validator_list][jss::expiration] == to_string(validUntil2));
457 BEAST_EXPECT(jrr[jss::local_static_keys].size() == 0);
458
459 BEAST_EXPECT(jrr[jss::trusted_validator_keys].size() == expectedKeys.size());
460 for (auto const& jKey : jrr[jss::trusted_validator_keys])
461 {
462 BEAST_EXPECT(expectedKeys.count(jKey.asString()) == 1);
463 }
464
465 if (BEAST_EXPECT(jrr[jss::publisher_lists].size() == 1))
466 {
467 auto jp = jrr[jss::publisher_lists][0u];
468 BEAST_EXPECT(jp[jss::available] == true);
469 if (BEAST_EXPECT(jp[jss::list].size() == 2))
470 {
471 // check entries
472 std::set<std::string> foundKeys;
473 for (auto const& k : jp[jss::list])
474 {
475 foundKeys.insert(k.asString());
476 }
477 BEAST_EXPECT(foundKeys == expectedKeys);
478 }
479 BEAST_EXPECT(jp[jss::seq].asUInt() == 1);
480 BEAST_EXPECT(jp[jss::pubkey_publisher] == strHex(server->publisherPublic()));
481 BEAST_EXPECT(jp[jss::expiration] == to_string(validUntil));
482 BEAST_EXPECT(jp[jss::version] == 2);
483 if (BEAST_EXPECT(jp.isMember(jss::remaining)) &&
484 BEAST_EXPECT(jp[jss::remaining].isArray()) &&
485 BEAST_EXPECT(jp[jss::remaining].size() == 1))
486 {
487 auto const& r = jp[jss::remaining][0u];
488 if (BEAST_EXPECT(r[jss::list].size() == 2))
489 {
490 // check entries
491 std::set<std::string> foundKeys;
492 for (auto const& k : r[jss::list])
493 {
494 foundKeys.insert(k.asString());
495 }
496 BEAST_EXPECT(foundKeys == expectedKeys);
497 }
498 BEAST_EXPECT(r[jss::seq].asUInt() == 2);
499 BEAST_EXPECT(r[jss::effective] == to_string(validFrom2));
500 BEAST_EXPECT(r[jss::expiration] == to_string(validUntil2));
501 }
502 }
503 auto jsk = jrr[jss::signing_keys];
504 BEAST_EXPECT(jsk.size() == 2);
505 for (auto const& val : validators)
506 {
507 BEAST_EXPECT(jsk.isMember(toStr(val.masterPublic)));
508 BEAST_EXPECT(jsk[toStr(val.masterPublic)] == toStr(val.signingPublic));
509 }
510 }
511 {
512 auto const jrr = env.rpc("validator_list_sites")[jss::result];
513 if (BEAST_EXPECT(jrr[jss::validator_sites].size() == 1))
514 {
515 auto js = jrr[jss::validator_sites][0u];
516 BEAST_EXPECT(js[jss::refresh_interval_min].asUInt() == 5);
517 BEAST_EXPECT(js[jss::uri] == siteURI);
518 BEAST_EXPECT(js[jss::last_refresh_status] == "accepted");
519 // The actual time of the update will vary run to run, so
520 // just verify the time is there
521 BEAST_EXPECT(js.isMember(jss::last_refresh_time));
522 }
523 }
524 }
525 }
526
527 void
529 {
530 using namespace test::jtx;
531 Env env{*this};
532 auto result = env.rpc("validation_create");
533 BEAST_EXPECT(result.isMember(jss::result) && result[jss::result][jss::status] == "success");
534 result =
535 env.rpc("validation_create", "BAWL MAN JADE MOON DOVE GEM SON NOW HAD ADEN GLOW TIRE");
536 BEAST_EXPECT(result.isMember(jss::result) && result[jss::result][jss::status] == "success");
537 }
538
539 void
540 run() override
541 {
546 }
547};
548
550
551} // namespace xrpl::test
A testsuite class.
Definition suite.h:52
UInt size() const
Number of values in array or object.
std::chrono::time_point< NetClock > time_point
Definition chrono.h:48
A public key.
Definition PublicKey.h:53
virtual ValidatorList & getValidators()=0
virtual ValidatorSite & getValidatorSites()=0
void setNegativeUNL(HashSet< PublicKey > const &negUnl)
set the Negative UNL with validators' master public keys
void join()
Wait for current fetches from sites to complete.
void start()
Start fetching lists from sites.
TrustedPublisherServer::Validator Validator
void run() override
Runs the suite.
A transaction testing environment.
Definition Env.h:161
Application & app()
Definition Env.h:300
void setRetries(unsigned r=5)
Definition Env.h:612
json::Value rpc(unsigned apiVersion, std::unordered_map< std::string, std::string > const &headers, std::string const &cmd, Args &&... args)
Execute an RPC command.
Definition Env.h:1058
T clear(T... args)
T contains(T... args)
T count(T... args)
T insert(T... args)
The api_version numbers this server serves.
Definition ApiVersion.h:26
std::uint32_t asUInt(AnyValue const &v)
Definition Oracle.cpp:400
std::unique_ptr< Config > envconfig()
creates and initializes a default configuration for jtx::Env
Definition envconfig.h:38
std::unique_ptr< Config > noAdmin(std::unique_ptr< Config >)
adjust config so no admin ports are enabled
Definition envconfig.cpp:76
std::shared_ptr< TrustedPublisherServer > makeTrustedPublisherServer(boost::asio::io_context &ioc, std::vector< TrustedPublisherServer::Validator > const &validators, NetClock::time_point validUntil, std::vector< std::pair< NetClock::time_point, NetClock::time_point > > const &futures, bool useSSL=false, int version=1, bool immediateStart=true, int sequence=1)
BEAST_DEFINE_TESTSUITE(AMMClawback, app, xrpl)
char const * getEnvLocalhostAddr()
Definition envconfig.h:16
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
std::pair< PublicKey, SecretKey > randomKeyPair(KeyType type)
Create a key pair using secure random numbers.
std::optional< AccountID > parseBase58(std::string const &s)
Parse AccountID from checked, base58 string.
std::string strHex(FwdIt begin, FwdIt end)
Definition strHex.h:13
std::string toBase58(AccountID const &v)
Convert AccountID to base58 checked string.
Definition AccountID.cpp:95
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
NodeID calcNodeID(PublicKey const &)
Calculate the 160-bit node ID from a node public key.
bool isAdmin(Port const &port, json::Value const &params, beast::ip::Address const &remoteIp)
Definition Role.cpp:81
std::unordered_set< Value, Hash, Pred, Allocator > HashSet
T size(T... args)
T str(T... args)
static constexpr auto kValidators
Definition Constants.h:74
static constexpr auto kValidatorListKeys
Definition Constants.h:70
static constexpr auto kValidatorListSites
Definition Constants.h:71