xrpld
Loading...
Searching...
No Matches
Credentials_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/acctdelete.h>
6#include <test/jtx/amount.h>
7#include <test/jtx/credentials.h>
8#include <test/jtx/deposit.h>
9#include <test/jtx/directory.h>
10#include <test/jtx/fee.h>
11#include <test/jtx/noop.h>
12#include <test/jtx/pay.h>
13#include <test/jtx/permissioned_domains.h>
14#include <test/jtx/ter.h>
15#include <test/jtx/ticket.h>
16#include <test/jtx/txflags.h>
17#include <test/jtx/vault.h>
18
19#include <xrpl/basics/strHex.h>
20#include <xrpl/beast/unit_test/suite.h>
21#include <xrpl/json/to_string.h>
22#include <xrpl/ledger/ApplyView.h>
23#include <xrpl/ledger/ApplyViewImpl.h>
24#include <xrpl/ledger/helpers/CredentialHelpers.h>
25#include <xrpl/protocol/AccountID.h>
26#include <xrpl/protocol/ErrorCodes.h>
27#include <xrpl/protocol/Feature.h>
28#include <xrpl/protocol/Indexes.h>
29#include <xrpl/protocol/Issue.h>
30#include <xrpl/protocol/LedgerFormats.h>
31#include <xrpl/protocol/Protocol.h>
32#include <xrpl/protocol/SField.h>
33#include <xrpl/protocol/STTx.h>
34#include <xrpl/protocol/TER.h>
35#include <xrpl/protocol/TxFlags.h>
36#include <xrpl/protocol/jss.h>
37
38#include <cstdint>
39#include <cstring>
40#include <memory>
41#include <string_view>
42
43namespace xrpl::test {
44
46{
47 void
49 {
50 using namespace test::jtx;
51
52 char const credType[] = "abcde";
53 char const uri[] = "uri";
54
55 Account const issuer{"issuer"};
56 Account const subject{"subject"};
57 Account const other{"other"};
58
59 Env env{*this, features};
60
61 {
62 testcase("Create for subject.");
63
64 auto const credKey = credentials::keylet(subject, issuer, credType);
65
66 env.fund(XRP(5000), subject, issuer, other);
67 env.close();
68
69 // Test Create credentials
70 env(credentials::create(subject, issuer, credType), credentials::Uri(uri));
71 env.close();
72 {
73 auto const sleCred = env.le(credKey);
74 BEAST_EXPECT(static_cast<bool>(sleCred));
75 if (!sleCred)
76 return;
77
78 BEAST_EXPECT(sleCred->getAccountID(sfSubject) == subject.id());
79 BEAST_EXPECT(sleCred->getAccountID(sfIssuer) == issuer.id());
80 BEAST_EXPECT(!sleCred->getFieldU32(sfFlags));
81 BEAST_EXPECT(ownerCount(env, issuer) == 1);
82 BEAST_EXPECT(!ownerCount(env, subject));
83 BEAST_EXPECT(checkVL(sleCred, sfCredentialType, credType));
84 BEAST_EXPECT(checkVL(sleCred, sfURI, uri));
85 auto const jle = credentials::ledgerEntry(env, subject, issuer, credType);
86 BEAST_EXPECT(
87 jle.isObject() && jle.isMember(jss::result) &&
88 !jle[jss::result].isMember(jss::error) &&
89 jle[jss::result].isMember(jss::node) &&
90 jle[jss::result][jss::node].isMember("LedgerEntryType") &&
91 jle[jss::result][jss::node]["LedgerEntryType"] == jss::Credential &&
92 jle[jss::result][jss::node][jss::Issuer] == issuer.human() &&
93 jle[jss::result][jss::node][jss::Subject] == subject.human() &&
94 jle[jss::result][jss::node]["CredentialType"] ==
95 strHex(std::string_view(credType)));
96 }
97
98 env(credentials::accept(subject, issuer, credType));
99 env.close();
100 {
101 // check switching owner of the credentials from issuer to
102 // subject
103 auto const sleCred = env.le(credKey);
104 BEAST_EXPECT(static_cast<bool>(sleCred));
105 if (!sleCred)
106 return;
107
108 BEAST_EXPECT(sleCred->getAccountID(sfSubject) == subject.id());
109 BEAST_EXPECT(sleCred->getAccountID(sfIssuer) == issuer.id());
110 BEAST_EXPECT(!ownerCount(env, issuer));
111 BEAST_EXPECT(ownerCount(env, subject) == 1);
112 BEAST_EXPECT(checkVL(sleCred, sfCredentialType, credType));
113 BEAST_EXPECT(checkVL(sleCred, sfURI, uri));
114 BEAST_EXPECT(sleCred->getFieldU32(sfFlags) == lsfAccepted);
115 }
116
117 env(credentials::deleteCred(subject, subject, issuer, credType));
118 env.close();
119 {
120 BEAST_EXPECT(!env.le(credKey));
121 BEAST_EXPECT(!ownerCount(env, issuer));
122 BEAST_EXPECT(!ownerCount(env, subject));
123
124 // check no credential exists anymore
125 auto const jle = credentials::ledgerEntry(env, subject, issuer, credType);
126 BEAST_EXPECT(
127 jle.isObject() && jle.isMember(jss::result) &&
128 jle[jss::result][jss::error] == "entryNotFound" &&
129 jle[jss::result][jss::error_code] == RpcEntryNotFound &&
130 jle[jss::result][jss::error_message] == "Entry not found.");
131 }
132 }
133
134 {
135 testcase("Create for themself.");
136
137 auto const credKey = credentials::keylet(issuer, issuer, credType);
138
139 env(credentials::create(issuer, issuer, credType), credentials::Uri(uri));
140 env.close();
141 {
142 auto const sleCred = env.le(credKey);
143 BEAST_EXPECT(static_cast<bool>(sleCred));
144 if (!sleCred)
145 return;
146
147 BEAST_EXPECT(sleCred->getAccountID(sfSubject) == issuer.id());
148 BEAST_EXPECT(sleCred->getAccountID(sfIssuer) == issuer.id());
149 BEAST_EXPECT(sleCred->isFlag(lsfAccepted));
150 BEAST_EXPECT(
151 sleCred->getFieldU64(sfIssuerNode) == sleCred->getFieldU64(sfSubjectNode));
152 BEAST_EXPECT(ownerCount(env, issuer) == 1);
153 BEAST_EXPECT(checkVL(sleCred, sfCredentialType, credType));
154 BEAST_EXPECT(checkVL(sleCred, sfURI, uri));
155 auto const jle = credentials::ledgerEntry(env, issuer, issuer, credType);
156 BEAST_EXPECT(
157 jle.isObject() && jle.isMember(jss::result) &&
158 !jle[jss::result].isMember(jss::error) &&
159 jle[jss::result].isMember(jss::node) &&
160 jle[jss::result][jss::node].isMember("LedgerEntryType") &&
161 jle[jss::result][jss::node]["LedgerEntryType"] == jss::Credential &&
162 jle[jss::result][jss::node][jss::Issuer] == issuer.human() &&
163 jle[jss::result][jss::node][jss::Subject] == issuer.human() &&
164 jle[jss::result][jss::node]["CredentialType"] ==
165 strHex(std::string_view(credType)));
166 }
167
168 env(credentials::deleteCred(issuer, issuer, issuer, credType));
169 env.close();
170 {
171 BEAST_EXPECT(!env.le(credKey));
172 BEAST_EXPECT(!ownerCount(env, issuer));
173
174 // check no credential exists anymore
175 auto const jle = credentials::ledgerEntry(env, issuer, issuer, credType);
176 BEAST_EXPECT(
177 jle.isObject() && jle.isMember(jss::result) &&
178 jle[jss::result][jss::error] == "entryNotFound" &&
179 jle[jss::result][jss::error_code] == RpcEntryNotFound &&
180 jle[jss::result][jss::error_message] == "Entry not found.");
181 }
182 }
183 }
184
185 void
187 {
188 using namespace test::jtx;
189
190 char const credType[] = "abcde";
191
192 Account const issuer{"issuer"};
193 Account const subject{"subject"};
194 Account const other{"other"};
195
196 Env env{*this, features};
197
198 // fund subject and issuer
199 env.fund(XRP(5000), issuer, subject, other);
200 env.close();
201
202 {
203 testcase("Delete issuer before accept");
204
205 auto const credKey = credentials::keylet(subject, issuer, credType);
206 env(credentials::create(subject, issuer, credType));
207 env.close();
208
209 // delete issuer
210 {
211 int const delta = env.seq(issuer) + 255;
212 for (int i = 0; i < delta; ++i)
213 env.close();
214 auto const acctDelFee{drops(env.current()->fees().increment)};
215 env(acctdelete(issuer, other), Fee(acctDelFee));
216 env.close();
217 }
218
219 // check credentials deleted too
220 {
221 BEAST_EXPECT(!env.le(credKey));
222 BEAST_EXPECT(!ownerCount(env, subject));
223
224 // check no credential exists anymore
225 auto const jle = credentials::ledgerEntry(env, subject, issuer, credType);
226 BEAST_EXPECT(
227 jle.isObject() && jle.isMember(jss::result) &&
228 jle[jss::result][jss::error] == "entryNotFound" &&
229 jle[jss::result][jss::error_code] == RpcEntryNotFound &&
230 jle[jss::result][jss::error_message] == "Entry not found.");
231 }
232
233 // resurrection
234 env.fund(XRP(5000), issuer);
235 env.close();
236 }
237
238 {
239 testcase("Delete issuer after accept");
240
241 auto const credKey = credentials::keylet(subject, issuer, credType);
242 env(credentials::create(subject, issuer, credType));
243 env.close();
244 env(credentials::accept(subject, issuer, credType));
245 env.close();
246
247 // delete issuer
248 {
249 int const delta = env.seq(issuer) + 255;
250 for (int i = 0; i < delta; ++i)
251 env.close();
252 auto const acctDelFee{drops(env.current()->fees().increment)};
253 env(acctdelete(issuer, other), Fee(acctDelFee));
254 env.close();
255 }
256
257 // check credentials deleted too
258 {
259 BEAST_EXPECT(!env.le(credKey));
260 BEAST_EXPECT(!ownerCount(env, subject));
261
262 // check no credential exists anymore
263 auto const jle = credentials::ledgerEntry(env, subject, issuer, credType);
264 BEAST_EXPECT(
265 jle.isObject() && jle.isMember(jss::result) &&
266 jle[jss::result][jss::error] == "entryNotFound" &&
267 jle[jss::result][jss::error_code] == RpcEntryNotFound &&
268 jle[jss::result][jss::error_message] == "Entry not found.");
269 }
270
271 // resurrection
272 env.fund(XRP(5000), issuer);
273 env.close();
274 }
275
276 {
277 testcase("Delete subject before accept");
278
279 auto const credKey = credentials::keylet(subject, issuer, credType);
280 env(credentials::create(subject, issuer, credType));
281 env.close();
282
283 // delete subject
284 {
285 int const delta = env.seq(subject) + 255;
286 for (int i = 0; i < delta; ++i)
287 env.close();
288 auto const acctDelFee{drops(env.current()->fees().increment)};
289 env(acctdelete(subject, other), Fee(acctDelFee));
290 env.close();
291 }
292
293 // check credentials deleted too
294 {
295 BEAST_EXPECT(!env.le(credKey));
296 BEAST_EXPECT(!ownerCount(env, issuer));
297
298 // check no credential exists anymore
299 auto const jle = credentials::ledgerEntry(env, subject, issuer, credType);
300 BEAST_EXPECT(
301 jle.isObject() && jle.isMember(jss::result) &&
302 jle[jss::result][jss::error] == "entryNotFound" &&
303 jle[jss::result][jss::error_code] == RpcEntryNotFound &&
304 jle[jss::result][jss::error_message] == "Entry not found.");
305 }
306
307 // resurrection
308 env.fund(XRP(5000), subject);
309 env.close();
310 }
311
312 {
313 testcase("Delete subject after accept");
314
315 auto const credKey = credentials::keylet(subject, issuer, credType);
316 env(credentials::create(subject, issuer, credType));
317 env.close();
318 env(credentials::accept(subject, issuer, credType));
319 env.close();
320
321 // delete subject
322 {
323 int const delta = env.seq(subject) + 255;
324 for (int i = 0; i < delta; ++i)
325 env.close();
326 auto const acctDelFee{drops(env.current()->fees().increment)};
327 env(acctdelete(subject, other), Fee(acctDelFee));
328 env.close();
329 }
330
331 // check credentials deleted too
332 {
333 BEAST_EXPECT(!env.le(credKey));
334 BEAST_EXPECT(!ownerCount(env, issuer));
335
336 // check no credential exists anymore
337 auto const jle = credentials::ledgerEntry(env, subject, issuer, credType);
338 BEAST_EXPECT(
339 jle.isObject() && jle.isMember(jss::result) &&
340 jle[jss::result][jss::error] == "entryNotFound" &&
341 jle[jss::result][jss::error_code] == RpcEntryNotFound &&
342 jle[jss::result][jss::error_message] == "Entry not found.");
343 }
344
345 // resurrection
346 env.fund(XRP(5000), subject);
347 env.close();
348 }
349
350 {
351 testcase("Delete by other");
352
353 auto const credKey = credentials::keylet(subject, issuer, credType);
354 auto jv = credentials::create(subject, issuer, credType);
355 uint32_t const t = env.current()->header().parentCloseTime.time_since_epoch().count();
356 jv[sfExpiration.jsonName] = t + 20;
357 env(jv);
358
359 // time advance
360 env.close();
361 env.close();
362 env.close();
363
364 // Other account delete credentials
365 env(credentials::deleteCred(other, subject, issuer, credType));
366 env.close();
367
368 // check credentials object
369 {
370 BEAST_EXPECT(!env.le(credKey));
371 BEAST_EXPECT(!ownerCount(env, issuer));
372 BEAST_EXPECT(!ownerCount(env, subject));
373
374 // check no credential exists anymore
375 auto const jle = credentials::ledgerEntry(env, subject, issuer, credType);
376 BEAST_EXPECT(
377 jle.isObject() && jle.isMember(jss::result) &&
378 jle[jss::result][jss::error] == "entryNotFound" &&
379 jle[jss::result][jss::error_code] == RpcEntryNotFound &&
380 jle[jss::result][jss::error_message] == "Entry not found.");
381 }
382 }
383
384 {
385 testcase("Delete by subject");
386
387 env(credentials::create(subject, issuer, credType));
388 env.close();
389
390 // Subject can delete
391 env(credentials::deleteCred(subject, subject, issuer, credType));
392 env.close();
393 {
394 auto const credKey = credentials::keylet(subject, issuer, credType);
395 BEAST_EXPECT(!env.le(credKey));
396 BEAST_EXPECT(!ownerCount(env, subject));
397 BEAST_EXPECT(!ownerCount(env, issuer));
398 auto const jle = credentials::ledgerEntry(env, subject, issuer, credType);
399 BEAST_EXPECT(
400 jle.isObject() && jle.isMember(jss::result) &&
401 jle[jss::result][jss::error] == "entryNotFound" &&
402 jle[jss::result][jss::error_code] == RpcEntryNotFound &&
403 jle[jss::result][jss::error_message] == "Entry not found.");
404 }
405 }
406
407 {
408 testcase("Delete by issuer");
409 env(credentials::create(subject, issuer, credType));
410 env.close();
411
412 env(credentials::deleteCred(issuer, subject, issuer, credType));
413 env.close();
414 {
415 auto const credKey = credentials::keylet(subject, issuer, credType);
416 BEAST_EXPECT(!env.le(credKey));
417 BEAST_EXPECT(!ownerCount(env, subject));
418 BEAST_EXPECT(!ownerCount(env, issuer));
419 auto const jle = credentials::ledgerEntry(env, subject, issuer, credType);
420 BEAST_EXPECT(
421 jle.isObject() && jle.isMember(jss::result) &&
422 jle[jss::result][jss::error] == "entryNotFound" &&
423 jle[jss::result][jss::error_code] == RpcEntryNotFound &&
424 jle[jss::result][jss::error_message] == "Entry not found.");
425 }
426 }
427 }
428
429 void
431 {
432 using namespace test::jtx;
433
434 char const credType[] = "abcde";
435
436 Account const issuer{"issuer"};
437 Account const subject{"subject"};
438
439 {
440 Env env{*this, features};
441
442 env.fund(XRP(5000), subject, issuer);
443 env.close();
444
445 {
446 testcase("Credentials fail, no subject param.");
447 auto jv = credentials::create(subject, issuer, credType);
448 jv.removeMember(jss::Subject);
449 env(jv, Ter(temMALFORMED));
450 }
451
452 {
453 auto jv = credentials::create(subject, issuer, credType);
454 jv[jss::Subject] = to_string(xrpAccount());
455 env(jv, Ter(temMALFORMED));
456 }
457
458 {
459 testcase("Credentials fail, no credentialType param.");
460 auto jv = credentials::create(subject, issuer, credType);
461 jv.removeMember(sfCredentialType.jsonName);
462 env(jv, Ter(temMALFORMED));
463 }
464
465 {
466 testcase("Credentials fail, empty credentialType param.");
467 auto const jv = credentials::create(subject, issuer, "");
468 env(jv, Ter(temMALFORMED));
469 }
470
471 {
472 testcase(
473 "Credentials fail, credentialType length > "
474 "maxCredentialTypeLength.");
475 static constexpr std::string_view kLongCredType =
476 "abcdefghijklmnopqrstuvwxyz01234567890qwertyuiop[]"
477 "asdfghjkl;'zxcvbnm8237tr28weufwldebvfv8734t07p";
478 static_assert(kLongCredType.size() > kMaxCredentialTypeLength);
479 auto const jv = credentials::create(subject, issuer, kLongCredType);
480 env(jv, Ter(temMALFORMED));
481 }
482
483 {
484 testcase("Credentials fail, URI length > 256.");
485 static constexpr std::string_view kLongUri =
486 "abcdefghijklmnopqrstuvwxyz01234567890qwertyuiop[]"
487 "asdfghjkl;'zxcvbnm8237tr28weufwldebvfv8734t07p "
488 "9hfup;wDJFBVSD8f72 "
489 "pfhiusdovnbs;"
490 "djvbldafghwpEFHdjfaidfgio84763tfysgdvhjasbd "
491 "vujhgWQIE7F6WEUYFGWUKEYFVQW87FGWOEFWEFUYWVEF8723GFWEFB"
492 "WULE"
493 "fv28o37gfwEFB3872TFO8GSDSDVD";
494 static_assert(kLongUri.size() > kMaxCredentialUriLength);
495 env(credentials::create(subject, issuer, credType),
496 credentials::Uri(kLongUri),
498 }
499
500 {
501 testcase("Credentials fail, URI empty.");
502 env(credentials::create(subject, issuer, credType),
505 }
506
507 {
508 testcase("Credentials fail, expiration in the past.");
509 auto jv = credentials::create(subject, issuer, credType);
510 // current time in XRPL epoch - 1s
511 uint32_t const t =
512 env.current()->header().parentCloseTime.time_since_epoch().count() - 1;
513 jv[sfExpiration.jsonName] = t;
514 env(jv, Ter(tecEXPIRED));
515 }
516
517 {
518 testcase("Credentials fail, invalid fee.");
519
520 auto jv = credentials::create(subject, issuer, credType);
521 jv[jss::Fee] = -1;
522 env(jv, Ter(temBAD_FEE));
523 }
524
525 {
526 testcase("Credentials fail, duplicate.");
527 auto const jv = credentials::create(subject, issuer, credType);
528 env(jv);
529 env.close();
530 env(jv, Ter(tecDUPLICATE));
531 env.close();
532
533 // check credential still present
534 auto const jle = credentials::ledgerEntry(env, subject, issuer, credType);
535 BEAST_EXPECT(
536 jle.isObject() && jle.isMember(jss::result) &&
537 !jle[jss::result].isMember(jss::error) &&
538 jle[jss::result].isMember(jss::node) &&
539 jle[jss::result][jss::node].isMember("LedgerEntryType") &&
540 jle[jss::result][jss::node]["LedgerEntryType"] == jss::Credential &&
541 jle[jss::result][jss::node][jss::Issuer] == issuer.human() &&
542 jle[jss::result][jss::node][jss::Subject] == subject.human() &&
543 jle[jss::result][jss::node]["CredentialType"] ==
544 strHex(std::string_view(credType)));
545 }
546
547 {
548 testcase("Credentials fail, directory full");
549 std::uint32_t const issuerSeq{env.seq(issuer) + 1};
550 env(ticket::create(issuer, 63));
551 env.close();
552
553 // Everything below can only be tested on open ledger.
554 auto const res1 = directory::bumpLastPage(
555 env,
557 keylet::ownerDir(issuer.id()),
559 BEAST_EXPECT(res1);
560
561 // NOLINTNEXTLINE(readability-suspicious-call-argument)
562 auto const jv = credentials::create(issuer, subject, credType);
563 env(jv, Ter(tecDIR_FULL));
564 // Free one directory entry by using a ticket
565 env(noop(issuer), ticket::Use(issuerSeq + 40));
566
567 // Fill subject directory
568 env(ticket::create(subject, 63));
569 auto const res2 = directory::bumpLastPage(
570 env,
572 keylet::ownerDir(subject.id()),
574 BEAST_EXPECT(res2);
575 env(jv, Ter(tecDIR_FULL));
576
577 // End test
578 env.close();
579 }
580
581 {
582 testcase("Credentials fail, subject is a pseudo-account.");
583 Vault const vault{env};
584 auto [tx, keylet] = vault.create({.owner = subject, .asset = xrpIssue()});
585 env(tx);
586 env.close();
587
588 auto const sleVault = env.le(keylet);
589 if (!BEAST_EXPECT(sleVault))
590 return;
591 Account const vaultPseudo{"vault", sleVault->at(sfAccount)};
592 // Without the CredentialCreate guard, the ownership invariant
593 // is the backstop that rejects the pin.
594 auto const expectedResult = [&] -> TER {
595 if (features[fixCleanup3_3_0])
596 return tecPSEUDO_ACCOUNT;
597 if (features[fixCleanup3_5_0])
598 return tecINVARIANT_FAILED;
599 return tesSUCCESS;
600 }();
601
602 env(credentials::create(vaultPseudo, issuer, credType), Ter(expectedResult));
603 env.close();
604 }
605 }
606
607 {
608 Env env{*this, features};
609
610 env.fund(XRP(5000), issuer);
611 env.close();
612
613 {
614 testcase("Credentials fail, subject doesn't exist.");
615 auto const jv = credentials::create(subject, issuer, credType);
616 env(jv, Ter(tecNO_TARGET));
617 }
618 }
619
620 {
621 Env env{*this, features};
622
623 auto const reserve = drops(env.current()->fees().reserve);
624 env.fund(reserve, subject, issuer);
625 env.close();
626
627 testcase("Credentials fail, not enough reserve.");
628 {
629 auto const jv = credentials::create(subject, issuer, credType);
631 env.close();
632 }
633 }
634 }
635
636 void
638 {
639 using namespace jtx;
640
641 char const credType[] = "abcde";
642 Account const issuer{"issuer"};
643 Account const subject{"subject"};
644 Account const other{"other"};
645
646 {
647 Env env{*this, features};
648
649 env.fund(XRP(5000), subject, issuer);
650
651 {
652 testcase("CredentialsAccept fail, Credential doesn't exist.");
653 env(credentials::accept(subject, issuer, credType), Ter(tecNO_ENTRY));
654 env.close();
655 }
656
657 {
658 testcase("CredentialsAccept fail, invalid Issuer account.");
659 auto jv = credentials::accept(subject, issuer, credType);
660 jv[jss::Issuer] = to_string(xrpAccount());
661 env(jv, Ter(temINVALID_ACCOUNT_ID));
662 env.close();
663 }
664
665 {
666 testcase("CredentialsAccept fail, invalid credentialType param.");
667 auto const jv = credentials::accept(subject, issuer, "");
668 env(jv, Ter(temMALFORMED));
669 }
670 }
671
672 {
673 Env env{*this, features};
674
675 env.fund(drops(env.current()->fees().accountReserve(1, 1)), issuer);
676 env.fund(drops(env.current()->fees().accountReserve(0, 1)), subject);
677 env.close();
678
679 {
680 testcase("CredentialsAccept fail, not enough reserve.");
681 env(credentials::create(subject, issuer, credType));
682 env.close();
683
684 env(credentials::accept(subject, issuer, credType), Ter(tecINSUFFICIENT_RESERVE));
685 env.close();
686
687 // check credential still present
688 auto const jle = credentials::ledgerEntry(env, subject, issuer, credType);
689 BEAST_EXPECT(
690 jle.isObject() && jle.isMember(jss::result) &&
691 !jle[jss::result].isMember(jss::error) &&
692 jle[jss::result].isMember(jss::node) &&
693 jle[jss::result][jss::node].isMember("LedgerEntryType") &&
694 jle[jss::result][jss::node]["LedgerEntryType"] == jss::Credential &&
695 jle[jss::result][jss::node][jss::Issuer] == issuer.human() &&
696 jle[jss::result][jss::node][jss::Subject] == subject.human() &&
697 jle[jss::result][jss::node]["CredentialType"] ==
698 strHex(std::string_view(credType)));
699 }
700 }
701
702 {
703 using namespace jtx;
704 Env env{*this, features};
705
706 env.fund(XRP(5000), subject, issuer);
707 env.close();
708
709 {
710 env(credentials::create(subject, issuer, credType));
711 env.close();
712
713 testcase("CredentialsAccept fail, invalid fee.");
714 auto jv = credentials::accept(subject, issuer, credType);
715 jv[jss::Fee] = -1;
716 env(jv, Ter(temBAD_FEE));
717
718 testcase("CredentialsAccept fail, lsfAccepted already set.");
719 env(credentials::accept(subject, issuer, credType));
720 env.close();
721 env(credentials::accept(subject, issuer, credType), Ter(tecDUPLICATE));
722 env.close();
723
724 // check credential still present
725 auto const jle = credentials::ledgerEntry(env, subject, issuer, credType);
726 BEAST_EXPECT(
727 jle.isObject() && jle.isMember(jss::result) &&
728 !jle[jss::result].isMember(jss::error) &&
729 jle[jss::result].isMember(jss::node) &&
730 jle[jss::result][jss::node].isMember("LedgerEntryType") &&
731 jle[jss::result][jss::node]["LedgerEntryType"] == jss::Credential &&
732 jle[jss::result][jss::node][jss::Issuer] == issuer.human() &&
733 jle[jss::result][jss::node][jss::Subject] == subject.human() &&
734 jle[jss::result][jss::node]["CredentialType"] ==
735 strHex(std::string_view(credType)));
736 }
737
738 {
739 char const credType2[] = "efghi";
740
741 testcase("CredentialsAccept fail, expired credentials.");
742 auto jv = credentials::create(subject, issuer, credType2);
743 uint32_t const t =
744 env.current()->header().parentCloseTime.time_since_epoch().count();
745 jv[sfExpiration.jsonName] = t;
746 env(jv);
747 env.close();
748
749 // credentials are expired now
750 env(credentials::accept(subject, issuer, credType2), Ter(tecEXPIRED));
751 env.close();
752
753 // check that expired credentials were deleted
754 auto const jDelCred = credentials::ledgerEntry(env, subject, issuer, credType2);
755 BEAST_EXPECT(
756 jDelCred.isObject() && jDelCred.isMember(jss::result) &&
757 jDelCred[jss::result][jss::error] == "entryNotFound" &&
758 jDelCred[jss::result][jss::error_code] == RpcEntryNotFound &&
759 jDelCred[jss::result][jss::error_message] == "Entry not found.");
760
761 BEAST_EXPECT(ownerCount(env, issuer) == 0);
762 BEAST_EXPECT(ownerCount(env, subject) == 1);
763 }
764 }
765
766 {
767 using namespace jtx;
768 Env env{*this, features};
769
770 env.fund(XRP(5000), issuer, subject, other);
771 env.close();
772
773 {
774 testcase("CredentialsAccept fail, issuer doesn't exist.");
775 auto jv = credentials::create(subject, issuer, credType);
776 env(jv);
777 env.close();
778
779 // delete issuer
780 int const delta = env.seq(issuer) + 255;
781 for (int i = 0; i < delta; ++i)
782 env.close();
783 auto const acctDelFee{drops(env.current()->fees().increment)};
784 env(acctdelete(issuer, other), Fee(acctDelFee));
785
786 // can't accept - no issuer account
787 jv = credentials::accept(subject, issuer, credType);
788 env(jv, Ter(tecNO_ISSUER));
789 env.close();
790
791 // check that expired credentials were deleted
792 auto const jDelCred = credentials::ledgerEntry(env, subject, issuer, credType);
793 BEAST_EXPECT(
794 jDelCred.isObject() && jDelCred.isMember(jss::result) &&
795 jDelCred[jss::result][jss::error] == "entryNotFound" &&
796 jDelCred[jss::result][jss::error_code] == RpcEntryNotFound &&
797 jDelCred[jss::result][jss::error_message] == "Entry not found.");
798 }
799 }
800 }
801
802 void
804 {
805 using namespace test::jtx;
806
807 char const credType[] = "abcde";
808 Account const issuer{"issuer"};
809 Account const subject{"subject"};
810 Account const other{"other"};
811
812 {
813 using namespace jtx;
814 Env env{*this, features};
815
816 env.fund(XRP(5000), subject, issuer, other);
817 env.close();
818
819 {
820 testcase("CredentialsDelete fail, no Credentials.");
821 env(credentials::deleteCred(subject, subject, issuer, credType), Ter(tecNO_ENTRY));
822 env.close();
823 }
824
825 {
826 testcase("CredentialsDelete fail, invalid Subject account.");
827 auto jv = credentials::deleteCred(subject, subject, issuer, credType);
828 jv[jss::Subject] = to_string(xrpAccount());
829 env(jv, Ter(temINVALID_ACCOUNT_ID));
830 env.close();
831 }
832
833 {
834 testcase("CredentialsDelete fail, invalid Issuer account.");
835 auto jv = credentials::deleteCred(subject, subject, issuer, credType);
836 jv[jss::Issuer] = to_string(xrpAccount());
837 env(jv, Ter(temINVALID_ACCOUNT_ID));
838 env.close();
839 }
840
841 {
842 testcase("CredentialsDelete fail, invalid credentialType param.");
843 auto const jv = credentials::deleteCred(subject, subject, issuer, "");
844 env(jv, Ter(temMALFORMED));
845 }
846
847 {
848 char const credType2[] = "fghij";
849
850 env(credentials::create(subject, issuer, credType2));
851 env.close();
852
853 // Other account can't delete credentials without expiration
854 env(credentials::deleteCred(other, subject, issuer, credType2),
856 env.close();
857
858 // check credential still present
859 auto const jle = credentials::ledgerEntry(env, subject, issuer, credType2);
860 BEAST_EXPECT(
861 jle.isObject() && jle.isMember(jss::result) &&
862 !jle[jss::result].isMember(jss::error) &&
863 jle[jss::result].isMember(jss::node) &&
864 jle[jss::result][jss::node].isMember("LedgerEntryType") &&
865 jle[jss::result][jss::node]["LedgerEntryType"] == jss::Credential &&
866 jle[jss::result][jss::node][jss::Issuer] == issuer.human() &&
867 jle[jss::result][jss::node][jss::Subject] == subject.human() &&
868 jle[jss::result][jss::node]["CredentialType"] ==
869 strHex(std::string_view(credType2)));
870 }
871
872 {
873 testcase("CredentialsDelete fail, time not expired yet.");
874
875 auto jv = credentials::create(subject, issuer, credType);
876 // current time in XRPL epoch + 1000s
877 uint32_t const t =
878 env.current()->header().parentCloseTime.time_since_epoch().count() + 1000;
879 jv[sfExpiration.jsonName] = t;
880 env(jv);
881 env.close();
882
883 // Other account can't delete credentials that not expired
884 env(credentials::deleteCred(other, subject, issuer, credType),
886 env.close();
887
888 // check credential still present
889 auto const jle = credentials::ledgerEntry(env, subject, issuer, credType);
890 BEAST_EXPECT(
891 jle.isObject() && jle.isMember(jss::result) &&
892 !jle[jss::result].isMember(jss::error) &&
893 jle[jss::result].isMember(jss::node) &&
894 jle[jss::result][jss::node].isMember("LedgerEntryType") &&
895 jle[jss::result][jss::node]["LedgerEntryType"] == jss::Credential &&
896 jle[jss::result][jss::node][jss::Issuer] == issuer.human() &&
897 jle[jss::result][jss::node][jss::Subject] == subject.human() &&
898 jle[jss::result][jss::node]["CredentialType"] ==
899 strHex(std::string_view(credType)));
900 }
901
902 {
903 testcase("CredentialsDelete fail, no Issuer and Subject.");
904
905 auto jv = credentials::deleteCred(subject, subject, issuer, credType);
906 jv.removeMember(jss::Subject);
907 jv.removeMember(jss::Issuer);
908 env(jv, Ter(temMALFORMED));
909 env.close();
910 }
911
912 {
913 testcase("CredentialsDelete fail, invalid fee.");
914
915 auto jv = credentials::deleteCred(subject, subject, issuer, credType);
916 jv[jss::Fee] = -1;
917 env(jv, Ter(temBAD_FEE));
918 env.close();
919 }
920
921 {
922 testcase("deleteSLE fail, bad SLE.");
923 auto const view =
925 auto const ter = xrpl::credentials::deleteSLE(*view, {}, env.journal);
926 BEAST_EXPECT(ter == tecNO_ENTRY);
927 }
928 }
929 }
930
931 void
933 {
934 using namespace test::jtx;
935
936 char const credType[] = "abcde";
937 Account const issuer{"issuer"};
938 Account const subject{"subject"};
939
940 {
941 using namespace jtx;
942 Env env{*this, features};
943
944 env.fund(XRP(5000), subject, issuer);
945 env.close();
946
947 {
948 testcase("Credentials fail, Feature is not enabled.");
949 env(credentials::create(subject, issuer, credType), Ter(temDISABLED));
950 env(credentials::accept(subject, issuer, credType), Ter(temDISABLED));
951 env(credentials::deleteCred(subject, subject, issuer, credType), Ter(temDISABLED));
952 }
953 }
954 }
955
956 void
958 {
959 using namespace test::jtx;
960
961 char const credType[] = "abcde";
962 Account const issuer{"issuer"};
963 Account const subject{"subject"};
964
965 {
966 using namespace jtx;
967 Env env{*this};
968
969 env.fund(XRP(5000), subject, issuer);
970 env.close();
971
972 env(credentials::create(subject, issuer, credType));
973 env.close();
974
975 env(credentials::accept(subject, issuer, credType));
976 env.close();
977
978 testcase("account_tx");
979
980 std::string txHash0, txHash1;
981 {
982 json::Value params;
983 params[jss::account] = subject.human();
984 auto const jv = env.rpc("json", "account_tx", to_string(params))[jss::result];
985
986 BEAST_EXPECT(jv[jss::transactions].size() == 4);
987 auto const& tx0(jv[jss::transactions][0u][jss::tx]);
988 BEAST_EXPECT(tx0[jss::TransactionType] == jss::CredentialAccept);
989 auto const& tx1(jv[jss::transactions][1u][jss::tx]);
990 BEAST_EXPECT(tx1[jss::TransactionType] == jss::CredentialCreate);
991 txHash0 = tx0[jss::hash].asString();
992 txHash1 = tx1[jss::hash].asString();
993 }
994
995 {
996 json::Value params;
997 params[jss::account] = issuer.human();
998 auto const jv = env.rpc("json", "account_tx", to_string(params))[jss::result];
999
1000 BEAST_EXPECT(jv[jss::transactions].size() == 4);
1001 auto const& tx0(jv[jss::transactions][0u][jss::tx]);
1002 BEAST_EXPECT(tx0[jss::TransactionType] == jss::CredentialAccept);
1003 auto const& tx1(jv[jss::transactions][1u][jss::tx]);
1004 BEAST_EXPECT(tx1[jss::TransactionType] == jss::CredentialCreate);
1005
1006 BEAST_EXPECT(txHash0 == tx0[jss::hash].asString());
1007 BEAST_EXPECT(txHash1 == tx1[jss::hash].asString());
1008 }
1009
1010 testcase("account_objects");
1011 std::string objectIdx;
1012 {
1013 json::Value params;
1014 params[jss::account] = subject.human();
1015 auto jv = env.rpc("json", "account_objects", to_string(params))[jss::result];
1016
1017 BEAST_EXPECT(jv[jss::account_objects].size() == 1);
1018 auto const& object(jv[jss::account_objects][0u]);
1019
1020 BEAST_EXPECT(object["LedgerEntryType"].asString() == jss::Credential);
1021 objectIdx = object[jss::index].asString();
1022 }
1023
1024 {
1025 json::Value params;
1026 params[jss::account] = issuer.human();
1027 auto jv = env.rpc("json", "account_objects", to_string(params))[jss::result];
1028
1029 BEAST_EXPECT(jv[jss::account_objects].size() == 1);
1030 auto const& object(jv[jss::account_objects][0u]);
1031
1032 BEAST_EXPECT(object["LedgerEntryType"].asString() == jss::Credential);
1033 BEAST_EXPECT(objectIdx == object[jss::index].asString());
1034 }
1035 }
1036 }
1037
1038 void
1040 {
1041 using namespace test::jtx;
1042
1043 bool const enabled = features[fixInvalidTxFlags];
1044 testcase(std::string("Test flag, fix ") + (enabled ? "enabled" : "disabled"));
1045
1046 char const credType[] = "abcde";
1047 Account const issuer{"issuer"};
1048 Account const subject{"subject"};
1049
1050 {
1051 using namespace jtx;
1052 Env env{*this, features};
1053
1054 env.fund(XRP(5000), subject, issuer);
1055 env.close();
1056
1057 {
1058 Ter const expected(enabled ? TER(temINVALID_FLAG) : TER(tesSUCCESS));
1059 env(credentials::create(subject, issuer, credType),
1060 Txflags(tfTransferable),
1061 expected);
1062 env(credentials::accept(subject, issuer, credType),
1063 Txflags(tfSellNFToken),
1064 expected);
1065 env(credentials::deleteCred(subject, subject, issuer, credType),
1066 Txflags(tfPassive),
1067 expected);
1068 }
1069 }
1070 }
1071
1072 void
1074 {
1075 bool const fixEnabled = features[fixCleanup3_1_3];
1076 testcase(
1077 "removeExpired ignores deleteSLE failure " +
1078 (fixEnabled ? std::string(" after fix") : std::string(" before fix")));
1079
1080 using namespace test::jtx;
1081
1082 char const credType[] = "abcde";
1083 Account const issuer{"issuer"};
1084 Account const subject{"subject"};
1085 Account const becky{"becky"};
1086
1087 Env env{*this, features};
1088 env.fund(XRP(10000), issuer, subject, becky);
1089 env.close();
1090
1091 // Create credential with short expiration
1092 auto jv = credentials::create(subject, issuer, credType);
1093 uint32_t const expiration =
1094 env.current()->header().parentCloseTime.time_since_epoch().count() + 40;
1095 jv[sfExpiration.jsonName] = expiration;
1096 env(jv);
1097 env.close();
1098
1099 auto const credLE = credentials::ledgerEntry(env, subject, issuer, credType);
1100 std::string const credIdx = credLE[jss::result][jss::index].asString();
1101
1102 // Subject accepts the credential
1103 env(credentials::accept(subject, issuer, credType));
1104 env.close();
1105
1106 // Build the credential keylet
1107 auto const credKeylet =
1108 keylet::credential(subject.id(), issuer.id(), Slice(credType, std::strlen(credType)));
1109
1110 // Verify credential exists and is accepted
1111 {
1112 auto const sleCred = env.current()->read(credKeylet);
1113 BEAST_EXPECT(sleCred && sleCred->isFlag(lsfAccepted));
1114 }
1115
1116 // Create DepositPreauth
1117 env(deposit::authCredentials(becky, {{.issuer = subject, .credType = credType}}));
1118 env.close();
1119 // env();
1120 auto const jtx = env.jt(pay(subject, becky, XRP(100)), credentials::Ids({credIdx}));
1121 if (!BEAST_EXPECT(jtx.stx))
1122 return;
1123 auto const stx = std::make_shared<STTx>(*jtx.stx);
1124
1125 // Create PermissionedDomain
1126 env(pdomain::setTx(becky, {{.issuer = issuer, .credType = credType}}));
1127 env.close();
1128 auto const objects = pdomain::getObjects(becky, env);
1129 if (!BEAST_EXPECT(!objects.empty()))
1130 return;
1131 auto const domain = objects.begin()->first;
1132
1133 using namespace std::chrono_literals;
1134 env.close(50s);
1135
1136 // Verify time has advanced past expiration
1137 {
1138 auto const sleCred = env.current()->read(credKeylet);
1139 BEAST_EXPECT(
1140 sleCred &&
1141 xrpl::credentials::checkExpired(*sleCred, env.current()->header().parentCloseTime));
1142 }
1143
1144 // Create an ApplyViewImpl on top of the current closed ledger
1145 // and corrupt it by erasing the issuer's account SLE
1146 auto const open = env.current();
1147 ApplyViewImpl av(&*open, TapNone);
1148
1149 // Erase the issuer's account to simulate ledger corruption
1150 auto const sleIssuer = av.peek(keylet::account(issuer.id()));
1151 if (!BEAST_EXPECT(sleIssuer))
1152 return;
1153 av.erase(sleIssuer);
1154 BEAST_EXPECT(!av.exists(keylet::account(issuer.id())));
1155
1156 // Credential still exists before removeExpired
1157 BEAST_EXPECT(av.exists(credKeylet));
1158
1159 // Call removeExpired on the corrupted view
1160 STVector256 credHashes;
1161 credHashes.pushBack(credKeylet.key);
1163
1164 auto const dpTer = xrpl::verifyDepositPreauth(*stx, av, subject, becky, {}, j);
1165 auto sleCredAfter = av.read(credKeylet);
1166 BEAST_EXPECT(sleCredAfter && sleCredAfter->isFlag(lsfAccepted));
1167
1168 auto const domTer = xrpl::verifyValidDomain(av, subject.id(), domain, j);
1169 sleCredAfter = av.read(credKeylet);
1170 BEAST_EXPECT(sleCredAfter && sleCredAfter->isFlag(lsfAccepted));
1171
1172 if (fixEnabled)
1173 {
1174 // removeExpired returns error, cred wasn't deleted
1175 BEAST_EXPECT(dpTer == tecINTERNAL);
1176 BEAST_EXPECT(domTer == tecINTERNAL);
1177 }
1178 else
1179 {
1180 // removeExpired returns true (claims it found & deleted expired
1181 // creds)
1182 BEAST_EXPECT(dpTer == tecEXPIRED);
1183 BEAST_EXPECT(isTesSuccess(domTer));
1184 }
1185 }
1186
1187 void
1188 run() override
1189 {
1190 using namespace test::jtx;
1191 FeatureBitset const all{testableAmendments()};
1192 testSuccessful(all);
1194 testCreateFailed(all);
1195 testCreateFailed(all - fixDirectoryLimit);
1196 testCreateFailed(all - fixCleanup3_3_0);
1197 testCreateFailed(all - fixCleanup3_3_0 - fixCleanup3_5_0);
1198 testAcceptFailed(all);
1199 testDeleteFailed(all);
1200 testFeatureFailed(all - featureCredentials);
1201 testFlags(all - fixInvalidTxFlags);
1202 testFlags(all);
1203 testRPC();
1204
1205 testRemoveExpiredCorruption(all - fixCleanup3_1_3);
1206 testRemoveExpiredCorruption(all | fixCleanup3_1_3);
1207 }
1208};
1209
1210BEAST_DEFINE_TESTSUITE(Credentials, app, xrpl);
1211
1212} // namespace xrpl::test
A generic endpoint for log messages.
Definition Journal.h:44
static Sink & getNullSink()
Returns a Sink which does nothing.
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
Editable, discardable view that can build metadata for one tx.
void pushBack(UInt256 const &v)
An immutable linear range of bytes.
Definition Slice.h:28
SLE::pointer peek(Keylet const &k) override
Prepare to modify the SLE associated with key.
SLE::const_pointer read(Keylet const &k) const override
Return the state item associated with a key.
void erase(SLE::Ref sle) override
Remove a peeked SLE.
bool exists(Keylet const &k) const override
Determine if a state item exists.
Immutable cryptographic account descriptor.
Definition jtx/Account.h:21
std::string const & human() const
Returns the human readable public key.
AccountID id() const
Returns the Account ID.
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
SLE::const_pointer le(Account const &account) const
Return an account root.
Definition Env.cpp:311
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
Definition Env.cpp:323
std::uint32_t seq(Account const &account) const
Returns the next sequence number on account.
Definition Env.cpp:302
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
JTx jt(JsonValue &&jv, FN const &... fN)
Create a JTx from parameters.
Definition Env.h:723
beast::Journal const journal
Definition Env.h:204
std::shared_ptr< OpenView const > current() const
Returns the current ledger.
Definition Env.h:377
Set the fee on a JTx.
Definition fee.h:20
Set the expected result code for a JTx The test will fail if the code doesn't match.
Definition ter.h:18
Set the flags on a JTx.
Definition txflags.h:14
Set a ticket sequence on a JTx.
Definition ticket.h:36
T make_shared(T... args)
TER deleteSLE(ApplyView &view, SLE::Ref sleCredential, beast::Journal j)
bool checkExpired(SLE const &sleCredential, NetClock::time_point const &closed)
Keylet computation functions.
Definition Indexes.h:39
Keylet ownerDir(AccountID const &id) noexcept
The root page of an account's directory.
Definition Indexes.cpp:415
Keylet account(AccountID const &id) noexcept
AccountID root.
Definition Indexes.cpp:233
Keylet credential(AccountID const &subject, AccountID const &issuer, Slice const &credType) noexcept
Definition Indexes.cpp:559
json::Value deleteCred(jtx::Account const &acc, jtx::Account const &subject, jtx::Account const &issuer, std::string_view credType)
Definition creds.cpp:40
json::Value accept(jtx::Account const &subject, jtx::Account const &issuer, std::string_view credType)
Definition creds.cpp:29
json::Value create(jtx::Account const &subject, jtx::Account const &issuer, std::string_view credType)
Definition creds.cpp:16
json::Value ledgerEntry(jtx::Env &env, jtx::Account const &subject, jtx::Account const &issuer, std::string_view credType)
Definition creds.cpp:56
Keylet keylet(test::jtx::Account const &subject, test::jtx::Account const &issuer, std::string_view credType)
Definition credentials.h:21
json::Value authCredentials(jtx::Account const &account, std::vector< AuthorizeCredentials > const &auth)
Definition deposit.cpp:38
auto bumpLastPage(Env &env, std::uint64_t newLastPage, Keylet directory, std::function< bool(ApplyView &, UInt256, std::uint64_t)> adjust) -> std::expected< void, Error >
Move the position of the last page in the user's directory on open ledger to newLastPage.
Definition directory.cpp:27
auto maximumPageIndex(Env const &env) -> std::uint64_t
Definition directory.h:57
bool adjustOwnerNode(ApplyView &view, UInt256 key, std::uint64_t page)
Implementation of adjust for the most common ledger entry, i.e.
std::map< UInt256, json::Value > getObjects(Account const &account, Env &env, bool withType)
json::Value setTx(AccountID const &account, Credentials const &credentials, std::optional< UInt256 > domain)
json::Value create(Account const &account, std::uint32_t count)
Create one of more tickets.
Definition ticket.cpp:16
json::Value pay(AccountID const &account, AccountID const &to, AnyAmount amount)
Create a payment.
Definition pay.cpp:14
XrpT const XRP
Converts to XRP Issue or STAmount.
Definition amount.cpp:92
json::Value noop(Account const &account)
The null transaction.
Definition noop.h:14
std::uint32_t ownerCount(Env const &env, Account const &account)
FeatureBitset testableAmendments()
Definition Env.h:92
json::Value acctdelete(Account const &account, Account const &dest)
Delete account.
PrettyAmount drops(Integer i)
Returns an XRP PrettyAmount, which is trivially convertible to STAmount.
bool checkVL(Slice const &result, std::string const &expected)
BEAST_DEFINE_TESTSUITE(AMMClawback, app, xrpl)
static XRPAmount reserve(jtx::Env const &env, std::uint32_t count)
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
Issue const & xrpIssue()
Returns an asset specifier that represents XRP.
Definition Issue.h:108
@ RpcEntryNotFound
Definition ErrorCodes.h:144
constexpr std::size_t kMaxCredentialTypeLength
The maximum length of a CredentialType inside a Credential.
Definition Protocol.h:276
std::string strHex(FwdIt begin, FwdIt end)
Definition strHex.h:13
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
void open(soci::session &s, BasicConfig const &config, std::string const &dbName)
Open a soci session.
Definition SociDB.cpp:91
TER verifyValidDomain(ApplyView &view, AccountID const &account, UInt256 domainID, beast::Journal j)
@ TapNone
Definition ApplyView.h:28
constexpr std::size_t kMaxCredentialUriLength
The maximum length of a URI inside a Credential.
Definition Protocol.h:271
@ temBAD_FEE
Definition TER.h:80
@ temINVALID_FLAG
Definition TER.h:99
@ temMALFORMED
Definition TER.h:75
@ temINVALID_ACCOUNT_ID
Definition TER.h:107
@ temDISABLED
Definition TER.h:102
bool isTesSuccess(TER x) noexcept
Definition TER.h:686
TERSubset< CanCvtToTER > TER
Definition TER.h:657
AccountID const & xrpAccount()
Compute AccountID from public key.
@ tecDIR_FULL
Definition TER.h:298
@ tecPSEUDO_ACCOUNT
Definition TER.h:373
@ tecNO_ENTRY
Definition TER.h:317
@ tecNO_TARGET
Definition TER.h:315
@ tecINTERNAL
Definition TER.h:321
@ tecINVARIANT_FAILED
Definition TER.h:324
@ tecEXPIRED
Definition TER.h:325
@ tecINSUFFICIENT_RESERVE
Definition TER.h:318
@ tecNO_PERMISSION
Definition TER.h:316
@ tecNO_ISSUER
Definition TER.h:310
@ tecDUPLICATE
Definition TER.h:326
TER verifyDepositPreauth(STTx const &tx, ApplyView &view, AccountID const &src, AccountID const &dst, SLE::ConstRef sleDst, beast::Journal j)
@ tesSUCCESS
Definition TER.h:253
T size(T... args)
T strlen(T... args)
void run() override
Runs the suite.
void testDeleteFailed(FeatureBitset features)
void testCredentialsDelete(FeatureBitset features)
void testRemoveExpiredCorruption(FeatureBitset features)
void testCreateFailed(FeatureBitset features)
void testAcceptFailed(FeatureBitset features)
void testFlags(FeatureBitset features)
void testFeatureFailed(FeatureBitset features)
void testSuccessful(FeatureBitset features)