xrpld
Loading...
Searching...
No Matches
AccountInfo_test.cpp
1
2#include <test/jtx/Account.h>
3#include <test/jtx/Env.h>
4#include <test/jtx/TestHelpers.h>
5#include <test/jtx/amount.h>
6#include <test/jtx/flags.h>
7#include <test/jtx/multisign.h>
8
9#include <xrpl/beast/unit_test/suite.h>
10#include <xrpl/json/json_value.h>
11#include <xrpl/json/to_string.h>
12#include <xrpl/protocol/ErrorCodes.h>
13#include <xrpl/protocol/Feature.h>
14#include <xrpl/protocol/SField.h>
15#include <xrpl/protocol/TxFlags.h>
16#include <xrpl/protocol/jss.h>
17
18#include <array>
19#include <cstdint>
20#include <format>
21#include <optional>
22#include <string_view>
23#include <utility>
24
25namespace xrpl::test {
26
28{
29public:
30 void
32 {
33 testcase("Errors");
34 using namespace jtx;
35 Env env(*this);
36 {
37 // account_info with no account.
38 auto const info = env.rpc("json", "account_info", "{ }");
39 BEAST_EXPECT(info[jss::result][jss::error] == "invalidParams");
40 BEAST_EXPECT(info[jss::result][jss::error_code] == RpcInvalidParams);
41 BEAST_EXPECT(info[jss::result][jss::error_message] == "Missing field 'account'.");
42 }
43 {
44 // account_info with a malformed account string.
45 auto const info = env.rpc(
46 "json",
47 "account_info",
48 "{\"account\": "
49 "\"n94JNrQYkDrpt62bbSR7nVEhdyAvcJXRAsjEkFYyqRkh9SUTYEqV\"}");
50 BEAST_EXPECT(info[jss::result][jss::error] == "actMalformed");
51 BEAST_EXPECT(info[jss::result][jss::error_code] == RpcActMalformed);
52 BEAST_EXPECT(info[jss::result][jss::error_message] == "Account malformed.");
53 BEAST_EXPECT(info[jss::result].isMember(jss::ledger_current_index));
54 BEAST_EXPECT(info[jss::result][jss::validated] == false);
55 }
56 {
57 // account_info with an account that's not in the ledger.
58 Account const bogie{"bogie"};
59 json::Value params;
60 params[jss::account] = bogie.human();
61 auto const info = env.rpc("json", "account_info", to_string(params));
62 BEAST_EXPECT(info[jss::result][jss::error] == "actNotFound");
63 BEAST_EXPECT(info[jss::result][jss::error_code] == RpcActNotFound);
64 BEAST_EXPECT(info[jss::result][jss::error_message] == "Account not found.");
65 BEAST_EXPECT(info[jss::result][jss::account] == bogie.human());
66 BEAST_EXPECT(info[jss::result].isMember(jss::ledger_current_index));
67 BEAST_EXPECT(info[jss::result][jss::validated] == false);
68 }
69 {
70 // Cannot use a seed as account
71 auto const info = env.rpc("json", "account_info", R"JSON({"account": "foo"})JSON");
72 BEAST_EXPECT(info[jss::result][jss::error] == "actMalformed");
73 BEAST_EXPECT(info[jss::result][jss::error_code] == RpcActMalformed);
74 BEAST_EXPECT(info[jss::result][jss::error_message] == "Account malformed.");
75 }
76 {
77 // Cannot pass a non-string into the `account` param
78
79 auto const testInvalidAccountParam = [&](auto const& param) {
80 json::Value params;
81 params[jss::account] = param;
82 auto jrr = env.rpc("json", "account_info", to_string(params))[jss::result];
83 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
84 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
85 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'account'.");
86 };
87
88 testInvalidAccountParam(1);
89 testInvalidAccountParam(1.1);
90 testInvalidAccountParam(true);
91 testInvalidAccountParam(json::Value(json::ValueType::Null));
92 testInvalidAccountParam(json::Value(json::ValueType::Object));
93 testInvalidAccountParam(json::Value(json::ValueType::Array));
94 }
95 {
96 // Cannot pass a non-string into the `ident` param
97
98 auto const testInvalidIdentParam = [&](auto const& param) {
99 json::Value params;
100 params[jss::ident] = param;
101 auto jrr = env.rpc("json", "account_info", to_string(params))[jss::result];
102 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
103 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
104 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'ident'.");
105 };
106
107 testInvalidIdentParam(1);
108 testInvalidIdentParam(1.1);
109 testInvalidIdentParam(true);
110 testInvalidIdentParam(json::Value(json::ValueType::Null));
111 testInvalidIdentParam(json::Value(json::ValueType::Object));
112 testInvalidIdentParam(json::Value(json::ValueType::Array));
113 }
114 {
115 // `ident` is ignored when `account` is present
116 json::Value params;
117 params[jss::account] = env.master.human();
118 params[jss::ident] = 1;
119 auto const info = env.rpc("json", "account_info", to_string(params))[jss::result];
120 BEAST_EXPECT(!info.isMember(jss::error));
121 BEAST_EXPECT(info.isMember(jss::account_data));
122 BEAST_EXPECT(info[jss::account_data][sfAccount.jsonName] == env.master.human());
123 }
124 {
125 // an invalid ledger is reported before a missing account
126 json::Value params;
127 params[jss::ledger_hash] = 1;
128 auto const info = env.rpc("json", "account_info", to_string(params))[jss::result];
129 BEAST_EXPECT(info[jss::error] == "invalidParams");
130 BEAST_EXPECT(info[jss::error_code] == RpcInvalidParams);
131 BEAST_EXPECT(
132 info[jss::error_message] == "Invalid field 'ledger_hash', not hex string.");
133 }
134 {
135 // `queue` is read as a bool, so any non-empty string requests it, and the queue
136 // can't be requested from a closed ledger
137 env.close();
138 json::Value params;
139 params[jss::account] = env.master.human();
140 params[jss::ledger_index] = "closed";
141 params[jss::queue] = "false";
142 auto const info = env.rpc("json", "account_info", to_string(params))[jss::result];
143 BEAST_EXPECT(info[jss::error] == "invalidParams");
144 BEAST_EXPECT(info[jss::error_code] == RpcInvalidParams);
145 BEAST_EXPECT(info[jss::error_message] == "Invalid parameters.");
146 BEAST_EXPECT(info.isMember(jss::ledger_index));
147 BEAST_EXPECT(!info.isMember(jss::account_data));
148 }
149 }
150
151 // Test the "signer_lists" argument in account_info.
152 void
154 {
155 testcase("Signer lists");
156 using namespace jtx;
157 Env env(*this);
158 Account const alice{"alice"};
159 env.fund(XRP(1000), alice);
160
161 json::Value withoutSigners;
162 withoutSigners[jss::account] = alice.human();
163
164 json::Value withSigners;
165 withSigners[jss::account] = alice.human();
166 withSigners[jss::signer_lists] = true;
167
168 // Alice has no SignerList yet.
169 {
170 // account_info without the "signer_lists" argument.
171 auto const info = env.rpc("json", "account_info", to_string(withoutSigners));
172 BEAST_EXPECT(
173 info.isMember(jss::result) && info[jss::result].isMember(jss::account_data));
174 BEAST_EXPECT(!info[jss::result][jss::account_data].isMember(jss::signer_lists));
175 }
176 {
177 // account_info with the "signer_lists" argument.
178 auto const info = env.rpc("json", "account_info", to_string(withSigners));
179 BEAST_EXPECT(
180 info.isMember(jss::result) && info[jss::result].isMember(jss::account_data));
181 auto const& data = info[jss::result][jss::account_data];
182 BEAST_EXPECT(data.isMember(jss::signer_lists));
183 auto const& signerLists = data[jss::signer_lists];
184 BEAST_EXPECT(signerLists.isArray());
185 BEAST_EXPECT(signerLists.size() == 0);
186 }
187
188 // Give alice a SignerList.
189 Account const bogie{"bogie"};
190
191 json::Value const smallSigners = signers(alice, 2, {{bogie, 3}});
192 env(smallSigners);
193 {
194 // account_info without the "signer_lists" argument.
195 auto const info = env.rpc("json", "account_info", to_string(withoutSigners));
196 BEAST_EXPECT(
197 info.isMember(jss::result) && info[jss::result].isMember(jss::account_data));
198 BEAST_EXPECT(!info[jss::result][jss::account_data].isMember(jss::signer_lists));
199 }
200 {
201 // account_info with the "signer_lists" argument.
202 auto const info = env.rpc("json", "account_info", to_string(withSigners));
203 BEAST_EXPECT(
204 info.isMember(jss::result) && info[jss::result].isMember(jss::account_data));
205 auto const& data = info[jss::result][jss::account_data];
206 BEAST_EXPECT(data.isMember(jss::signer_lists));
207 auto const& signerLists = data[jss::signer_lists];
208 BEAST_EXPECT(signerLists.isArray());
209 BEAST_EXPECT(signerLists.size() == 1);
210 auto const& signers = signerLists[0u];
211 BEAST_EXPECT(signers.isObject());
212 BEAST_EXPECT(signers[sfSignerQuorum.jsonName] == 2);
213 auto const& signerEntries = signers[sfSignerEntries.jsonName];
214 BEAST_EXPECT(signerEntries.size() == 1);
215 auto const& entry0 = signerEntries[0u][sfSignerEntry.jsonName];
216 BEAST_EXPECT(entry0[sfSignerWeight.jsonName] == 3);
217 }
218
219 // Give alice a big signer list
220 Account const demon{"demon"};
221 Account const ghost{"ghost"};
222 Account const haunt{"haunt"};
223 Account const jinni{"jinni"};
224 Account const phase{"phase"};
225 Account const shade{"shade"};
226 Account const spook{"spook"};
227
228 json::Value const bigSigners = signers(
229 alice,
230 4,
231 {
232 {bogie, 1},
233 {demon, 1},
234 {ghost, 1},
235 {haunt, 1},
236 {jinni, 1},
237 {phase, 1},
238 {shade, 1},
239 {spook, 1},
240 });
241 env(bigSigners);
242 {
243 // account_info with the "signer_lists" argument.
244 auto const info = env.rpc("json", "account_info", to_string(withSigners));
245 BEAST_EXPECT(
246 info.isMember(jss::result) && info[jss::result].isMember(jss::account_data));
247 auto const& data = info[jss::result][jss::account_data];
248 BEAST_EXPECT(data.isMember(jss::signer_lists));
249 auto const& signerLists = data[jss::signer_lists];
250 BEAST_EXPECT(signerLists.isArray());
251 BEAST_EXPECT(signerLists.size() == 1);
252 auto const& signers = signerLists[0u];
253 BEAST_EXPECT(signers.isObject());
254 BEAST_EXPECT(signers[sfSignerQuorum.jsonName] == 4);
255 auto const& signerEntries = signers[sfSignerEntries.jsonName];
256 BEAST_EXPECT(signerEntries.size() == 8);
257 for (unsigned i = 0u; i < 8; ++i)
258 {
259 auto const& entry = signerEntries[i][sfSignerEntry.jsonName];
260 BEAST_EXPECT(entry.size() == 2);
261 BEAST_EXPECT(entry.isMember(sfAccount.jsonName));
262 BEAST_EXPECT(entry[sfSignerWeight.jsonName] == 1);
263 }
264 }
265 }
266
267 // Test the "signer_lists" argument in account_info, with api_version 2.
268 void
270 {
271 testcase("Signer lists APIv2");
272 using namespace jtx;
273 Env env{*this};
274 Account const alice{"alice"};
275 env.fund(XRP(1000), alice);
276
277 json::Value withoutSigners;
278 withoutSigners[jss::api_version] = 2;
279 withoutSigners[jss::account] = alice.human();
280
281 json::Value withSigners;
282 withSigners[jss::api_version] = 2;
283 withSigners[jss::account] = alice.human();
284 withSigners[jss::signer_lists] = true;
285
286 auto const withSignersAsString = std::format(
287 R"JSON({{"api_version": 2, "account": "{}", "signer_lists": "yes"}})JSON",
288 alice.human());
289
290 // Alice has no SignerList yet.
291 {
292 // account_info without the "signer_lists" argument.
293 auto const info = env.rpc("json", "account_info", to_string(withoutSigners));
294 BEAST_EXPECT(info.isMember(jss::result));
295 BEAST_EXPECT(!info[jss::result].isMember(jss::signer_lists));
296 }
297 {
298 // account_info with the "signer_lists" argument.
299 auto const info = env.rpc("json", "account_info", to_string(withSigners));
300 BEAST_EXPECT(info.isMember(jss::result));
301 auto const& data = info[jss::result];
302 BEAST_EXPECT(data.isMember(jss::signer_lists));
303 auto const& signerLists = data[jss::signer_lists];
304 BEAST_EXPECT(signerLists.isArray());
305 BEAST_EXPECT(signerLists.size() == 0);
306 }
307
308 // Give alice a SignerList.
309 Account const bogie{"bogie"};
310
311 json::Value const smallSigners = signers(alice, 2, {{bogie, 3}});
312 env(smallSigners);
313 {
314 // account_info without the "signer_lists" argument.
315 auto const info = env.rpc("json", "account_info", to_string(withoutSigners));
316 BEAST_EXPECT(info.isMember(jss::result));
317 BEAST_EXPECT(!info[jss::result].isMember(jss::signer_lists));
318 }
319 {
320 // account_info with the "signer_lists" argument.
321 auto const info = env.rpc("json", "account_info", to_string(withSigners));
322 BEAST_EXPECT(info.isMember(jss::result));
323 auto const& data = info[jss::result];
324 BEAST_EXPECT(data.isMember(jss::signer_lists));
325 auto const& signerLists = data[jss::signer_lists];
326 BEAST_EXPECT(signerLists.isArray());
327 BEAST_EXPECT(signerLists.size() == 1);
328 auto const& signers = signerLists[0u];
329 BEAST_EXPECT(signers.isObject());
330 BEAST_EXPECT(signers[sfSignerQuorum.jsonName] == 2);
331 auto const& signerEntries = signers[sfSignerEntries.jsonName];
332 BEAST_EXPECT(signerEntries.size() == 1);
333 auto const& entry0 = signerEntries[0u][sfSignerEntry.jsonName];
334 BEAST_EXPECT(entry0[sfSignerWeight.jsonName] == 3);
335 }
336 {
337 // account_info with "signer_lists" as not bool should error out
338 auto const info = env.rpc("json", "account_info", withSignersAsString)[jss::result];
339 BEAST_EXPECT(info[jss::status] == "error");
340 BEAST_EXPECT(info[jss::error] == "invalidParams");
341 BEAST_EXPECT(info[jss::error_code] == RpcInvalidParams);
342 BEAST_EXPECT(info[jss::error_message] == "Invalid parameters.");
343 BEAST_EXPECT(info.isMember(jss::account_data));
344 BEAST_EXPECT(info[jss::account_data][sfAccount.jsonName] == alice.human());
345 BEAST_EXPECT(info.isMember(jss::ledger_current_index));
346 BEAST_EXPECT(!info.isMember(jss::signer_lists));
347 }
348
349 // Give alice a big signer list
350 Account const demon{"demon"};
351 Account const ghost{"ghost"};
352 Account const haunt{"haunt"};
353 Account const jinni{"jinni"};
354 Account const phase{"phase"};
355 Account const shade{"shade"};
356 Account const spook{"spook"};
357
358 json::Value const bigSigners = signers(
359 alice,
360 4,
361 {
362 {bogie, 1},
363 {demon, 1},
364 {ghost, 1},
365 {haunt, 1},
366 {jinni, 1},
367 {phase, 1},
368 {shade, 1},
369 {spook, 1},
370 });
371 env(bigSigners);
372 {
373 // account_info with the "signer_lists" argument.
374 auto const info = env.rpc("json", "account_info", to_string(withSigners));
375 BEAST_EXPECT(info.isMember(jss::result));
376 auto const& data = info[jss::result];
377 BEAST_EXPECT(data.isMember(jss::signer_lists));
378 auto const& signerLists = data[jss::signer_lists];
379 BEAST_EXPECT(signerLists.isArray());
380 BEAST_EXPECT(signerLists.size() == 1);
381 auto const& signers = signerLists[0u];
382 BEAST_EXPECT(signers.isObject());
383 BEAST_EXPECT(signers[sfSignerQuorum.jsonName] == 4);
384 auto const& signerEntries = signers[sfSignerEntries.jsonName];
385 BEAST_EXPECT(signerEntries.size() == 8);
386 for (unsigned i = 0u; i < 8; ++i)
387 {
388 auto const& entry = signerEntries[i][sfSignerEntry.jsonName];
389 BEAST_EXPECT(entry.size() == 2);
390 BEAST_EXPECT(entry.isMember(sfAccount.jsonName));
391 BEAST_EXPECT(entry[sfSignerWeight.jsonName] == 1);
392 }
393 }
394 }
395
396 // Test the "signer_lists" argument in account_info, version 2 API.
397 void
399 {
400 testcase("Signer lists v2");
401 using namespace jtx;
402 Env env(*this);
403 Account const alice{"alice"};
404 env.fund(XRP(1000), alice);
405
406 auto const withoutSigners = std::string("{ ") +
407 "\"jsonrpc\": \"2.0\", "
408 "\"ripplerpc\": \"2.0\", "
409 "\"id\": 5, "
410 "\"method\": \"account_info\", "
411 "\"params\": { "
412 "\"account\": \"" +
413 alice.human() + "\"}}";
414
415 auto const withSigners = std::string("{ ") +
416 "\"jsonrpc\": \"2.0\", "
417 "\"ripplerpc\": \"2.0\", "
418 "\"id\": 6, "
419 "\"method\": \"account_info\", "
420 "\"params\": { "
421 "\"account\": \"" +
422 alice.human() + "\", " + "\"signer_lists\": true }}";
423 // Alice has no SignerList yet.
424 {
425 // account_info without the "signer_lists" argument.
426 auto const info = env.rpc("json2", withoutSigners);
427 BEAST_EXPECT(
428 info.isMember(jss::result) && info[jss::result].isMember(jss::account_data));
429 BEAST_EXPECT(!info[jss::result][jss::account_data].isMember(jss::signer_lists));
430 BEAST_EXPECT(hasEnvelope2(info));
431 BEAST_EXPECT(info.isMember(jss::id) && info[jss::id] == 5);
432 }
433 {
434 // account_info with the "signer_lists" argument.
435 auto const info = env.rpc("json2", withSigners);
436 BEAST_EXPECT(
437 info.isMember(jss::result) && info[jss::result].isMember(jss::account_data));
438 auto const& data = info[jss::result][jss::account_data];
439 BEAST_EXPECT(data.isMember(jss::signer_lists));
440 auto const& signerLists = data[jss::signer_lists];
441 BEAST_EXPECT(signerLists.isArray());
442 BEAST_EXPECT(signerLists.size() == 0);
443 BEAST_EXPECT(hasEnvelope2(info));
444 BEAST_EXPECT(info.isMember(jss::id) && info[jss::id] == 6);
445 }
446 {
447 // Do both of the above as a batch job
448 auto const info = env.rpc("json2", '[' + withoutSigners + ", " + withSigners + ']');
449 BEAST_EXPECT(
450 info[0u].isMember(jss::result) &&
451 info[0u][jss::result].isMember(jss::account_data));
452 BEAST_EXPECT(!info[0u][jss::result][jss::account_data].isMember(jss::signer_lists));
453 BEAST_EXPECT(hasEnvelope2(info[0u]));
454 BEAST_EXPECT(info[0u].isMember(jss::id) && info[0u][jss::id] == 5);
455
456 BEAST_EXPECT(
457 info[1u].isMember(jss::result) &&
458 info[1u][jss::result].isMember(jss::account_data));
459 auto const& data = info[1u][jss::result][jss::account_data];
460 BEAST_EXPECT(data.isMember(jss::signer_lists));
461 auto const& signerLists = data[jss::signer_lists];
462 BEAST_EXPECT(signerLists.isArray());
463 BEAST_EXPECT(signerLists.size() == 0);
464 BEAST_EXPECT(hasEnvelope2(info[1u]));
465 BEAST_EXPECT(info[1u].isMember(jss::id) && info[1u][jss::id] == 6);
466 }
467
468 // Give alice a SignerList.
469 Account const bogie{"bogie"};
470
471 json::Value const smallSigners = signers(alice, 2, {{bogie, 3}});
472 env(smallSigners);
473 {
474 // account_info without the "signer_lists" argument.
475 auto const info = env.rpc("json2", withoutSigners);
476 BEAST_EXPECT(
477 info.isMember(jss::result) && info[jss::result].isMember(jss::account_data));
478 BEAST_EXPECT(!info[jss::result][jss::account_data].isMember(jss::signer_lists));
479 BEAST_EXPECT(hasEnvelope2(info));
480 BEAST_EXPECT(info.isMember(jss::id) && info[jss::id] == 5);
481 }
482 {
483 // account_info with the "signer_lists" argument.
484 auto const info = env.rpc("json2", withSigners);
485 BEAST_EXPECT(
486 info.isMember(jss::result) && info[jss::result].isMember(jss::account_data));
487 auto const& data = info[jss::result][jss::account_data];
488 BEAST_EXPECT(data.isMember(jss::signer_lists));
489 auto const& signerLists = data[jss::signer_lists];
490 BEAST_EXPECT(signerLists.isArray());
491 BEAST_EXPECT(signerLists.size() == 1);
492 auto const& signers = signerLists[0u];
493 BEAST_EXPECT(signers.isObject());
494 BEAST_EXPECT(signers[sfSignerQuorum.jsonName] == 2);
495 auto const& signerEntries = signers[sfSignerEntries.jsonName];
496 BEAST_EXPECT(signerEntries.size() == 1);
497 auto const& entry0 = signerEntries[0u][sfSignerEntry.jsonName];
498 BEAST_EXPECT(entry0[sfSignerWeight.jsonName] == 3);
499 BEAST_EXPECT(hasEnvelope2(info));
500 BEAST_EXPECT(info.isMember(jss::id) && info[jss::id] == 6);
501 }
502
503 // Give alice a big signer list
504 Account const demon{"demon"};
505 Account const ghost{"ghost"};
506 Account const haunt{"haunt"};
507 Account const jinni{"jinni"};
508 Account const phase{"phase"};
509 Account const shade{"shade"};
510 Account const spook{"spook"};
511
512 json::Value const bigSigners = signers(
513 alice,
514 4,
515 {
516 {bogie, 1},
517 {demon, 1},
518 {ghost, 1},
519 {haunt, 1},
520 {jinni, 1},
521 {phase, 1},
522 {shade, 1},
523 {spook, 1},
524 });
525 env(bigSigners);
526 {
527 // account_info with the "signer_lists" argument.
528 auto const info = env.rpc("json2", withSigners);
529 BEAST_EXPECT(
530 info.isMember(jss::result) && info[jss::result].isMember(jss::account_data));
531 auto const& data = info[jss::result][jss::account_data];
532 BEAST_EXPECT(data.isMember(jss::signer_lists));
533 auto const& signerLists = data[jss::signer_lists];
534 BEAST_EXPECT(signerLists.isArray());
535 BEAST_EXPECT(signerLists.size() == 1);
536 auto const& signers = signerLists[0u];
537 BEAST_EXPECT(signers.isObject());
538 BEAST_EXPECT(signers[sfSignerQuorum.jsonName] == 4);
539 auto const& signerEntries = signers[sfSignerEntries.jsonName];
540 BEAST_EXPECT(signerEntries.size() == 8);
541 for (unsigned i = 0u; i < 8; ++i)
542 {
543 auto const& entry = signerEntries[i][sfSignerEntry.jsonName];
544 BEAST_EXPECT(entry.size() == 2);
545 BEAST_EXPECT(entry.isMember(sfAccount.jsonName));
546 BEAST_EXPECT(entry[sfSignerWeight.jsonName] == 1);
547 }
548 BEAST_EXPECT(hasEnvelope2(info));
549 BEAST_EXPECT(info.isMember(jss::id) && info[jss::id] == 6);
550 }
551 }
552
553 void
555 {
556 testcase("Account flags");
557 using namespace jtx;
558
559 Env env(*this, features);
560 Account const alice{"alice"};
561 Account const bob{"bob"};
562 env.fund(XRP(1000), alice, bob);
563
564 auto const getAccountFlag = [&env](std::string_view fName, Account const& account) {
565 json::Value params;
566 params[jss::account] = account.human();
567 auto const info = env.rpc("json", "account_info", to_string(params));
568 auto const name = std::string(fName);
569
571 if (info[jss::result][jss::status] == "success" &&
572 info[jss::result][jss::account_flags].isMember(name))
573 res.emplace(info[jss::result][jss::account_flags][name].asBool());
574
575 return res;
576 };
577
578 static constexpr std::array<std::pair<std::string_view, std::uint32_t>, 7> kAsFlags{
579 {
580 {"defaultRipple", asfDefaultRipple},
581 {"depositAuth", asfDepositAuth},
582 {"disallowIncomingXRP", asfDisallowXRP},
583 {"globalFreeze", asfGlobalFreeze},
584 {"noFreeze", asfNoFreeze},
585 {"requireAuthorization", asfRequireAuth},
586 {"requireDestinationTag", asfRequireDest},
587 },
588 };
589
590 for (auto& asf : kAsFlags)
591 {
592 // Clear a flag and check that account_info returns results
593 // as expected
594 env(fclear(alice, asf.second));
595 env.close();
596 auto const f1 = getAccountFlag(asf.first, alice);
597 BEAST_EXPECT(f1.has_value());
598 BEAST_EXPECT(!f1.value()); // NOLINT(bugprone-unchecked-optional-access)
599
600 // Set a flag and check that account_info returns results
601 // as expected
602 env(fset(alice, asf.second));
603 env.close();
604 auto const f2 = getAccountFlag(asf.first, alice);
605 BEAST_EXPECT(f2.has_value());
606 BEAST_EXPECT(f2.value()); // NOLINT(bugprone-unchecked-optional-access)
607 }
608
610 kDisallowIncomingFlags{
611 {
612 {"disallowIncomingCheck", asfDisallowIncomingCheck},
613 {"disallowIncomingNFTokenOffer", asfDisallowIncomingNFTokenOffer},
614 {"disallowIncomingPayChan", asfDisallowIncomingPayChan},
615 {"disallowIncomingTrustline", asfDisallowIncomingTrustline},
616 },
617 };
618
619 for (auto& asf : kDisallowIncomingFlags)
620 {
621 // Clear a flag and check that account_info returns results
622 // as expected
623 env(fclear(alice, asf.second));
624 env.close();
625 auto const f1 = getAccountFlag(asf.first, alice);
626 BEAST_EXPECT(f1.has_value());
627 BEAST_EXPECT(!f1.value()); // NOLINT(bugprone-unchecked-optional-access)
628
629 // Set a flag and check that account_info returns results
630 // as expected
631 env(fset(alice, asf.second));
632 env.close();
633 auto const f2 = getAccountFlag(asf.first, alice);
634 BEAST_EXPECT(f2.has_value());
635 BEAST_EXPECT(f2.value()); // NOLINT(bugprone-unchecked-optional-access)
636 }
637
638 static constexpr std::pair<std::string_view, std::uint32_t> kAllowTrustLineClawbackFlag{
639 "allowTrustLineClawback", asfAllowTrustLineClawback};
640
641 // must use bob's account because alice has noFreeze set
642 auto const f1 = getAccountFlag(kAllowTrustLineClawbackFlag.first, bob);
643 BEAST_EXPECT(f1.has_value());
644 BEAST_EXPECT(!f1.value()); // NOLINT(bugprone-unchecked-optional-access)
645
646 // Set allowTrustLineClawback
647 env(fset(bob, kAllowTrustLineClawbackFlag.second));
648 env.close();
649 auto const f2 = getAccountFlag(kAllowTrustLineClawbackFlag.first, bob);
650 BEAST_EXPECT(f2.has_value());
651 BEAST_EXPECT(f2.value()); // NOLINT(bugprone-unchecked-optional-access)
652
653 static constexpr std::pair<std::string_view, std::uint32_t> kAllowTrustLineLockingFlag{
654 "allowTrustLineLocking", asfAllowTrustLineLocking};
655
656 if (features[featureTokenEscrow])
657 {
658 auto const f1 = getAccountFlag(kAllowTrustLineLockingFlag.first, bob);
659 BEAST_EXPECT(f1.has_value());
660 BEAST_EXPECT(!f1.value()); // NOLINT(bugprone-unchecked-optional-access)
661
662 // Set allowTrustLineLocking
663 env(fset(bob, kAllowTrustLineLockingFlag.second));
664 env.close();
665 auto const f2 = getAccountFlag(kAllowTrustLineLockingFlag.first, bob);
666 BEAST_EXPECT(f2.has_value());
667 BEAST_EXPECT(f2.value()); // NOLINT(bugprone-unchecked-optional-access)
668 }
669 else
670 {
671 BEAST_EXPECT(!getAccountFlag(kAllowTrustLineLockingFlag.first, bob));
672 }
673 }
674
675 void
687};
688
690
691} // namespace xrpl::test
A testsuite class.
Definition suite.h:52
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
Represents a JSON value.
Definition json_value.h:121
UInt size() const
Number of values in array or object.
bool isMember(char const *key) const
Return true if the object has a member named key.
void testAccountFlags(FeatureBitset const &features)
void run() override
Runs the suite.
Immutable cryptographic account descriptor.
Definition jtx/Account.h:21
std::string const & human() const
Returns the human readable public key.
A transaction testing environment.
Definition Env.h:161
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
Definition Env.cpp:133
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
Definition Env.cpp:323
Account const & master
Definition Env.h:165
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 emplace(T... args)
T format(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
The api_version numbers this server serves.
Definition ApiVersion.h:26
XrpT const XRP
Converts to XRP Issue or STAmount.
Definition amount.cpp:92
bool hasEnvelope2(json::Value const &reply)
Reports whether reply carries the version 2 envelope: jsonrpc equal to rpc::kJsonRpcVersion and rippl...
json::Value fclear(Account const &account, std::uint32_t off)
Remove account flag.
Definition flags.h:110
FeatureBitset testableAmendments()
Definition Env.h:92
json::Value signers(Account const &account, std::uint32_t quorum, std::vector< Signer > const &v)
Definition multisign.cpp:31
json::Value fset(Account const &account, std::uint32_t on, std::uint32_t off=0)
Add and/or remove flag.
Definition flags.cpp:15
FeatureBitset allFeatures()
Returns all testable amendments.
Definition TxTest.cpp:41
BEAST_DEFINE_TESTSUITE(AMMClawback, app, xrpl)
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
@ RpcActNotFound
Definition ErrorCodes.h:53
@ RpcActMalformed
Definition ErrorCodes.h:73
@ RpcInvalidParams
Definition ErrorCodes.h:67
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658