89 Account const depositor{
"depositor"};
91 env.fund(XRP(1000), issuer, owner, depositor);
92 env(fset(issuer, asfAllowTrustLineClawback));
96 env.trust(asset(1000), owner);
97 env.trust(asset(1000), depositor);
98 env(pay(issuer, owner, asset(200)));
99 env(pay(issuer, depositor, asset(200)));
102 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
106 auto const [vaultAccount, issuanceId] =
108 auto const vault = env.le(
keylet);
109 return {
Account(
"vault", vault->at(sfAccount)), vault->at(sfShareMPTID)};
112 env.memoize(vaultAccount);
115 return env.app().getOpenLedger().modify(
119 if (!BEAST_EXPECT(vault))
123 if (!BEAST_EXPECT(shares))
125 if (fn(*vault, *shares))
141 .depositor = depositor,
142 .vaultAccount = vaultAccount,
153 testCase(18, [&,
this](Env& env, Data d) {
154 testcase(
"Scale deposit overflow on first deposit");
155 auto const tx = d.vault.deposit(
156 {.depositor = d.depositor, .id = d.keylet.key, .amount = d.asset(10)});
161 testCase(18, [&,
this](Env& env, Data d) {
162 testcase(
"Scale deposit overflow on second deposit");
165 auto const tx = d.vault.deposit(
166 {.depositor = d.depositor, .id = d.keylet.key, .amount = d.asset(5)});
172 auto const tx = d.vault.deposit(
173 {.depositor = d.depositor, .id = d.keylet.key, .amount = d.asset(10)});
179 testCase(18, [&,
this](Env& env, Data d) {
180 testcase(
"Scale deposit overflow on total shares");
183 auto const tx = d.vault.deposit(
184 {.depositor = d.depositor, .id = d.keylet.key, .amount = d.asset(5)});
190 auto const tx = d.vault.deposit(
191 {.depositor = d.depositor, .id = d.keylet.key, .amount = d.asset(5)});
197 testCase(1, [&,
this](Env& env, Data d) {
200 auto const start = env.balance(d.depositor, d.assets).number();
201 auto const tx = d.vault.deposit(
202 {.depositor = d.depositor, .id = d.keylet.key, .amount = d.asset(1)});
205 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(10));
206 BEAST_EXPECT(env.balance(d.depositor, d.assets) ==
STAmount(d.asset, start - 1));
209 testCase(1, [&,
this](Env& env, Data d) {
210 testcase(
"Scale deposit insignificant amount");
212 auto const tx = d.vault.deposit({
213 .depositor = d.depositor,
220 testCase(1, [&,
this](Env& env, Data d) {
221 testcase(
"Scale deposit exact, using full precision");
223 auto const start = env.balance(d.depositor, d.assets).number();
224 auto const tx = d.vault.deposit({
225 .depositor = d.depositor,
231 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(15));
233 env.balance(d.depositor, d.assets) ==
STAmount(d.asset, start -
Number(15, -1)));
236 testCase(1, [&,
this](Env& env, Data d) {
237 testcase(
"Scale deposit exact, truncating from .5");
239 auto const start = env.balance(d.depositor, d.assets).number();
243 auto const tx = d.vault.deposit({
244 .depositor = d.depositor,
250 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(12));
252 env.balance(d.depositor, d.assets) ==
257 auto const tx = d.vault.deposit({
258 .depositor = d.depositor,
264 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(24));
266 env.balance(d.depositor, d.assets) ==
271 auto const tx = d.vault.deposit({
272 .depositor = d.depositor,
278 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(36));
280 env.balance(d.depositor, d.assets) ==
285 testCase(1, [&,
this](Env& env, Data d) {
286 testcase(
"Scale deposit exact, truncating from .01");
288 auto const start = env.balance(d.depositor, d.assets).number();
290 auto const tx = d.vault.deposit({
291 .depositor = d.depositor,
297 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(12));
299 env.balance(d.depositor, d.assets) ==
STAmount(d.asset, start -
Number(12, -1)));
303 auto const tx = d.vault.deposit({
304 .depositor = d.depositor,
310 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(18));
312 env.balance(d.depositor, d.assets) ==
317 testCase(1, [&,
this](Env& env, Data d) {
318 testcase(
"Scale deposit exact, truncating from .99");
320 auto const start = env.balance(d.depositor, d.assets).number();
322 auto const tx = d.vault.deposit({
323 .depositor = d.depositor,
329 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(12));
331 env.balance(d.depositor, d.assets) ==
STAmount(d.asset, start -
Number(12, -1)));
335 auto const tx = d.vault.deposit({
336 .depositor = d.depositor,
342 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(18));
344 env.balance(d.depositor, d.assets) ==
349 testCase(1, [&,
this](Env& env, Data d) {
351 auto const start = env.balance(d.depositor, d.assets).number();
352 auto tx = d.vault.deposit({
353 .depositor = d.depositor,
359 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(1000));
361 env.balance(d.depositor, d.assets) ==
STAmount(d.asset, start -
Number(100, 0)));
363 env.balance(d.vaultAccount, d.assets) ==
STAmount(d.asset,
Number(100, 0)));
365 env.balance(d.vaultAccount, d.shares) ==
STAmount(d.share,
Number(-1000, 0)));
373 auto const start = env.balance(d.depositor, d.assets).number();
374 auto const tx = d.vault.withdraw({
375 .depositor = d.depositor,
381 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(900));
383 env.balance(d.depositor, d.assets) ==
STAmount(d.asset, start +
Number(10, 0)));
385 env.balance(d.vaultAccount, d.assets) ==
STAmount(d.asset,
Number(90, 0)));
387 env.balance(d.vaultAccount, d.shares) ==
STAmount(d.share,
Number(-900, 0)));
391 testcase(
"Scale redeem with rounding");
396 auto const start = env.balance(d.depositor, d.assets).number();
397 d.peek([](
SLE& vault,
auto&) ->
bool {
398 vault[sfAssetsAvailable] =
Number(1);
406 auto const tx = d.vault.withdraw({
407 .depositor = d.depositor,
413 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(900 - 25));
415 env.balance(d.depositor, d.assets) ==
418 env.balance(d.vaultAccount, d.assets) ==
421 env.balance(d.vaultAccount, d.shares) ==
431 auto const start = env.balance(d.depositor, d.assets).number();
433 tx = d.vault.withdraw({
434 .depositor = d.depositor,
440 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(875 - 21));
442 env.balance(d.depositor, d.assets) ==
445 env.balance(d.vaultAccount, d.assets) ==
448 env.balance(d.vaultAccount, d.shares) ==
454 auto const rest = env.balance(d.depositor, d.shares).number();
456 tx = d.vault.withdraw({
457 .depositor = d.depositor,
463 BEAST_EXPECT(env.balance(d.depositor, d.shares).number() == 0);
464 BEAST_EXPECT(env.balance(d.vaultAccount, d.assets).number() == 0);
465 BEAST_EXPECT(env.balance(d.vaultAccount, d.shares).number() == 0);
469 testCase(18, [&,
this](Env& env, Data d) {
470 testcase(
"Scale withdraw overflow");
473 auto const tx = d.vault.deposit(
474 {.depositor = d.depositor, .id = d.keylet.key, .amount = d.asset(5)});
480 auto const tx = d.vault.withdraw({
481 .depositor = d.depositor,
490 testCase(1, [&,
this](Env& env, Data d) {
492 auto const start = env.balance(d.depositor, d.assets).number();
493 auto tx = d.vault.deposit({
494 .depositor = d.depositor,
500 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(1000));
502 env.balance(d.depositor, d.assets) ==
STAmount(d.asset, start -
Number(100, 0)));
504 env.balance(d.vaultAccount, d.assets) ==
STAmount(d.asset,
Number(100, 0)));
506 env.balance(d.vaultAccount, d.shares) ==
STAmount(d.share,
Number(-1000, 0)));
517 auto const start = env.balance(d.depositor, d.assets).number();
518 auto const tx = d.vault.withdraw({
519 .depositor = d.depositor,
525 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(900));
527 env.balance(d.depositor, d.assets) ==
STAmount(d.asset, start +
Number(10, 0)));
529 env.balance(d.vaultAccount, d.assets) ==
STAmount(d.asset,
Number(90, 0)));
531 env.balance(d.vaultAccount, d.shares) ==
STAmount(d.share,
Number(-900, 0)));
535 testcase(
"Scale withdraw insignificant amount");
536 auto const tx = d.vault.withdraw({
537 .depositor = d.depositor,
545 testcase(
"Scale withdraw with rounding assets");
553 auto const start = env.balance(d.depositor, d.assets).number();
554 d.peek([](
SLE& vault,
auto&) ->
bool {
555 vault[sfAssetsAvailable] =
Number(1);
563 auto const tx = d.vault.withdraw({
564 .depositor = d.depositor,
570 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(900 - 25));
572 env.balance(d.depositor, d.assets) ==
575 env.balance(d.vaultAccount, d.assets) ==
578 env.balance(d.vaultAccount, d.shares) ==
583 testcase(
"Scale withdraw with rounding shares up (truncated post-fixCleanup3_4_0)");
591 auto const start = env.balance(d.depositor, d.assets).number();
592 auto const tx = d.vault.withdraw({
593 .depositor = d.depositor,
599 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(875 - 37));
601 env.balance(d.depositor, d.assets) ==
604 env.balance(d.vaultAccount, d.assets) ==
607 env.balance(d.vaultAccount, d.shares) ==
612 testcase(
"Scale withdraw with rounding shares down");
617 auto const start = env.balance(d.depositor, d.assets).number();
618 auto const tx = d.vault.withdraw({
619 .depositor = d.depositor,
625 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(838 - 37));
627 env.balance(d.depositor, d.assets) ==
630 env.balance(d.vaultAccount, d.assets) ==
633 env.balance(d.vaultAccount, d.shares) ==
638 testcase(
"Scale withdraw tiny amount rejected post-fixCleanup3_4_0");
643 auto const start = env.balance(d.depositor, d.assets).number();
644 auto const tx = d.vault.withdraw({
645 .depositor = d.depositor,
651 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(801));
652 BEAST_EXPECT(env.balance(d.depositor, d.assets) ==
STAmount(d.asset, start));
654 env.balance(d.vaultAccount, d.assets) ==
STAmount(d.asset,
Number(801, -1)));
656 env.balance(d.vaultAccount, d.shares) ==
STAmount(d.share, -
Number(801, 0)));
661 auto const rest = env.balance(d.vaultAccount, d.assets).number();
663 tx = d.vault.withdraw({
664 .depositor = d.depositor,
670 BEAST_EXPECT(env.balance(d.depositor, d.shares).number() == 0);
671 BEAST_EXPECT(env.balance(d.vaultAccount, d.assets).number() == 0);
672 BEAST_EXPECT(env.balance(d.vaultAccount, d.shares).number() == 0);
676 testCase(18, [&,
this](Env& env, Data d) {
677 testcase(
"Scale clawback overflow");
680 auto const tx = d.vault.deposit(
681 {.depositor = d.depositor, .id = d.keylet.key, .amount = d.asset(5)});
687 auto const tx = d.vault.clawback({
690 .holder = d.depositor,
698 testCase(1, [&,
this](Env& env, Data d) {
700 auto const start = env.balance(d.depositor, d.assets).number();
701 auto tx = d.vault.deposit({
702 .depositor = d.depositor,
708 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(1000));
710 env.balance(d.depositor, d.assets) ==
STAmount(d.asset, start -
Number(100, 0)));
712 env.balance(d.vaultAccount, d.assets) ==
STAmount(d.asset,
Number(100, 0)));
714 env.balance(d.vaultAccount, d.shares) ==
STAmount(d.share, -
Number(1000, 0)));
724 auto const start = env.balance(d.depositor, d.assets).number();
725 auto const tx = d.vault.clawback({
728 .holder = d.depositor,
733 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(900));
734 BEAST_EXPECT(env.balance(d.depositor, d.assets) ==
STAmount(d.asset, start));
736 env.balance(d.vaultAccount, d.assets) ==
STAmount(d.asset,
Number(90, 0)));
738 env.balance(d.vaultAccount, d.shares) ==
STAmount(d.share, -
Number(900, 0)));
742 testcase(
"Scale clawback insignificant amount");
743 auto const tx = d.vault.clawback({
746 .holder = d.depositor,
753 testcase(
"Scale clawback with rounding assets");
761 auto const start = env.balance(d.depositor, d.assets).number();
762 auto const tx = d.vault.clawback({
765 .holder = d.depositor,
770 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(900 - 25));
771 BEAST_EXPECT(env.balance(d.depositor, d.assets) ==
STAmount(d.asset, start));
773 env.balance(d.vaultAccount, d.assets) ==
776 env.balance(d.vaultAccount, d.shares) ==
781 testcase(
"Scale clawback with rounding shares up (truncated post-fixCleanup3_4_0)");
789 auto const start = env.balance(d.depositor, d.assets).number();
790 auto const tx = d.vault.clawback({
793 .holder = d.depositor,
798 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(875 - 37));
799 BEAST_EXPECT(env.balance(d.depositor, d.assets) ==
STAmount(d.asset, start));
801 env.balance(d.vaultAccount, d.assets) ==
804 env.balance(d.vaultAccount, d.shares) ==
809 testcase(
"Scale clawback with rounding shares down");
814 auto const start = env.balance(d.depositor, d.assets).number();
815 auto const tx = d.vault.clawback({
818 .holder = d.depositor,
823 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(838 - 37));
824 BEAST_EXPECT(env.balance(d.depositor, d.assets) ==
STAmount(d.asset, start));
826 env.balance(d.vaultAccount, d.assets) ==
829 env.balance(d.vaultAccount, d.shares) ==
834 testcase(
"Scale clawback tiny amount rejected post-fixCleanup3_4_0");
839 auto const start = env.balance(d.depositor, d.assets).number();
840 auto const tx = d.vault.clawback({
843 .holder = d.depositor,
848 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(801));
849 BEAST_EXPECT(env.balance(d.depositor, d.assets) ==
STAmount(d.asset, start));
851 env.balance(d.vaultAccount, d.assets) ==
STAmount(d.asset,
Number(801, -1)));
853 env.balance(d.vaultAccount, d.shares) ==
STAmount(d.share, -
Number(801, 0)));
858 auto const rest = env.balance(d.vaultAccount, d.assets).number();
859 d.peek([](
SLE& vault,
auto&) ->
bool {
860 vault[sfAssetsAvailable] =
Number(5);
868 tx = d.vault.clawback({
871 .holder = d.depositor,
876 BEAST_EXPECT(env.balance(d.depositor, d.shares).number() == 0);
877 BEAST_EXPECT(env.balance(d.vaultAccount, d.assets).number() == 0);
878 BEAST_EXPECT(env.balance(d.vaultAccount, d.shares).number() == 0);
885 testCase(1, [&,
this](Env& env, Data d) {
886 using namespace loan_broker;
887 using namespace loan;
889 testcase(
"Scale clawback clamped with outstanding loan");
891 auto tx = d.vault.deposit({
892 .depositor = d.depositor,
898 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(1000));
901 auto const brokerKeylet =
903 env(
set(d.owner, d.keylet.key));
910 kPaymentInterval(120),
912 Sig(sfCounterpartySignature, d.owner),
913 Fee(env.current()->fees().base * 2),
918 auto const sle = env.le(d.keylet);
919 BEAST_EXPECT(sle->at(sfAssetsAvailable) ==
STAmount(d.asset,
Number(60, 0)));
920 BEAST_EXPECT(sle->at(sfAssetsTotal) ==
STAmount(d.asset,
Number(100, 0)));
925 tx = d.vault.clawback({
928 .holder = d.depositor,
935 auto const sle = env.le(d.keylet);
936 BEAST_EXPECT(sle !=
nullptr);
937 BEAST_EXPECT(sle->at(sfAssetsAvailable) ==
STAmount(d.asset,
Number(0, 0)));
938 BEAST_EXPECT(sle->at(sfAssetsTotal) ==
STAmount(d.asset,
Number(40, 0)));
941 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(400));
946 auto seedLargeTotal = [](Env& env,
951 auto const tx = d.vault.deposit({
952 .depositor = d.depositor,
958 d.peek([&](
SLE& vault,
SLE& shares) ->
bool {
959 vault[sfAssetsTotal] = total;
960 vault[sfAssetsAvailable] = available;
961 shares[sfOutstandingAmount] = outstanding;
966 auto expectVault = [
this](
972 auto const sle = env.le(d.keylet);
973 BEAST_EXPECT(sle !=
nullptr);
974 BEAST_EXPECT(sle->at(sfAssetsTotal) == total);
975 BEAST_EXPECT(sle->at(sfAssetsAvailable) == available);
976 BEAST_EXPECT(env.balance(d.depositor, d.shares) == shareBalance);
980 testCase(0, [&,
this](Env& env, Data d) {
981 testcase(
"Scale clawback uses posterior scale across decade boundary");
983 Number const midGridTotal{10000000000000005ll};
984 Number const available{6};
985 seedLargeTotal(env, d, midGridTotal, available, 10000000000000005ull);
988 d.vault.clawback({.issuer = d.issuer, .id = d.keylet.key, .holder = d.depositor});
990 expectVault(env, d, midGridTotal - available,
Number(0), d.share(94));
994 testCase(0, [&,
this](Env& env, Data d) {
995 testcase(
"Scale clawback rejects amount below posterior scale");
997 Number const midGridTotal{12345678901234567ll};
998 Number const available{6};
999 seedLargeTotal(env, d, midGridTotal, available, 12345678901234567ull);
1002 d.vault.clawback({.issuer = d.issuer, .id = d.keylet.key, .holder = d.depositor});
1004 expectVault(env, d, midGridTotal, available, d.share(100));
1008 testCase(0, [&,
this](Env& env, Data d) {
1009 testcase(
"Scale clawback preserves exact posterior amount");
1011 Number const midGridTotal{10000000000000005ll};
1012 Number const available{15};
1013 seedLargeTotal(env, d, midGridTotal, available, 10000000000000005ull);
1016 d.vault.clawback({.issuer = d.issuer, .id = d.keylet.key, .holder = d.depositor});
1018 expectVault(env, d, midGridTotal - available,
Number(0), d.share(85));
1021 testCase(0, [&,
this](Env& env, Data d) {
1022 testcase(
"Scale deposit rejects amount below posterior scale");
1024 Number const midGridTotal{10000000000000005ll};
1025 Number const available{100};
1026 seedLargeTotal(env, d, midGridTotal, available, 10000000000000005ull);
1028 auto const assetsBefore = env.balance(d.depositor, d.assets);
1029 auto const tx = d.vault.deposit({
1030 .depositor = d.depositor,
1035 expectVault(env, d, midGridTotal, available, d.share(100));
1036 BEAST_EXPECT(env.balance(d.depositor, d.assets) == assetsBefore);
1039 testCase(0, [&,
this](Env& env, Data d) {
1040 testcase(
"Scale withdraw uses posterior scale across decade boundary");
1042 Number const midGridTotal{10000000000000005ll};
1043 Number const available{100};
1044 seedLargeTotal(env, d, midGridTotal, available, 10000000000000005ull);
1046 auto const assetsBefore = env.balance(d.depositor, d.assets);
1047 auto const tx = d.vault.withdraw({
1048 .depositor = d.depositor,
1053 expectVault(env, d, midGridTotal -
Number(15),
Number(85), d.share(85));
1055 env.balance(d.depositor, d.assets) ==
1063 bool const withFix = features[fixCleanup3_5_0];
1065 std::string(
"Assets Maximum (") + (withFix ?
"post" :
"pre") +
"-fixCleanup3_5_0)");
1069 Env env{*
this, features};
1071 Account const issuer{
"issuer"};
1073 Vault const vault{env};
1074 env.fund(XRP(1'000'000), issuer, owner);
1078 BEAST_EXPECT(maxInt64 ==
"9223372036854775807");
1082 BEAST_EXPECT(maxInt64Plus1 ==
"9223372036854775808");
1087 BEAST_EXPECT(maxInt64Plus2 ==
"9223372036854775809");
1090 BEAST_EXPECT(initialXRP ==
"100000000000000000");
1093 BEAST_EXPECT(initialXRPPlus1 ==
"100000000000000001");
1104 auto [tx,
keylet] = vault.create({.owner = owner, .asset = xrpAsset});
1105 tx[sfData] =
"4D65746144617461";
1107 tx[sfAssetsMaximum] = maxInt64;
1108 env(tx, Ter(outOfRangeErr));
1111 tx[sfAssetsMaximum] = initialXRPPlus1;
1112 env(tx, Ter(outOfRangeErr));
1115 tx[sfAssetsMaximum] = initialXRP;
1120 env.setParseFailureExpected(
true);
1123 tx[sfAssetsMaximum] = maxInt64Plus1;
1133 "invalidParamsField 'tx_json.AssetsMaximum' has invalid data.");
1138 tx[sfAssetsMaximum] = maxInt64Plus2;
1147 "invalidParamsField 'tx_json.AssetsMaximum' has invalid data.");
1153 auto const insertAt = maxInt64Plus2.size() - 3;
1154 auto const decimalTest = maxInt64Plus2.substr(0, insertAt) +
"." +
1155 maxInt64Plus2.substr(insertAt);
1156 BEAST_EXPECT(decimalTest ==
"9223372036854775.809");
1157 tx[sfAssetsMaximum] = decimalTest;
1166 "invalidParamsField 'tx_json.AssetsMaximum' has invalid data.");
1169 auto const vaultSle = env.le(newKeylet);
1170 BEAST_EXPECT(!vaultSle);
1177 MPTTester mptt{env, issuer, kMptInitNoFund};
1178 mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
1181 mptt.authorize({.account = owner});
1186 env(pay(issuer, owner, mptAsset(100'000)));
1189 auto [tx,
keylet] = vault.create({.owner = owner, .asset = mptAsset});
1190 tx[sfData] =
"4D65746144617461";
1192 tx[sfAssetsMaximum] = maxInt64;
1196 tx[sfAssetsMaximum] = initialXRPPlus1;
1200 tx[sfAssetsMaximum] = initialXRP;
1206 tx[sfAssetsMaximum] = maxInt64Plus2;
1215 "invalidParamsField 'tx_json.AssetsMaximum' has invalid data.");
1221 auto const insertAt = maxInt64Plus2.size() - 1;
1222 auto const decimalTest = maxInt64Plus2.substr(0, insertAt) +
"." +
1223 maxInt64Plus2.substr(insertAt);
1224 BEAST_EXPECT(decimalTest ==
"922337203685477580.9");
1225 tx[sfAssetsMaximum] = decimalTest;
1234 "invalidParamsField 'tx_json.AssetsMaximum' has invalid data.");
1237 auto const vaultSle = env.le(newKeylet);
1238 BEAST_EXPECT(!vaultSle);
1246 env.trust(iouAsset(1000), owner);
1247 env(pay(issuer, owner, iouAsset(200)));
1250 auto [tx,
keylet] = vault.create({.owner = owner, .asset = iouAsset});
1251 tx[sfData] =
"4D65746144617461";
1253 tx[sfAssetsMaximum] = maxInt64;
1257 tx[sfAssetsMaximum] = initialXRPPlus1;
1261 tx[sfAssetsMaximum] = initialXRP;
1267 env.setParseFailureExpected(
true);
1270 tx[sfAssetsMaximum] = maxInt64Plus2;
1279 "invalidParamsField 'tx_json.AssetsMaximum' has invalid data.");
1282 tx[sfAssetsMaximum] =
"1000000000000000e80";
1285 tx[sfAssetsMaximum] =
"1000000000000000e-96";
1290 auto const newKeylet =
1294 auto const insertAt = maxInt64Plus2.size() - 1;
1295 auto const decimalTest = maxInt64Plus2.substr(0, insertAt) +
"." +
1296 maxInt64Plus2.substr(insertAt);
1297 BEAST_EXPECT(decimalTest ==
"922337203685477580.9");
1298 tx[sfAssetsMaximum] = decimalTest;
1307 "invalidParamsField 'tx_json.AssetsMaximum' has invalid data.");
1310 auto const vaultSle = env.le(newKeylet);
1311 BEAST_EXPECT(!vaultSle);
1314 tx[sfAssetsMaximum] =
"9223372036854775807e40";
1315 auto const newKeylet =
1320 auto const vaultSle = env.le(newKeylet);
1321 if (!BEAST_EXPECT(vaultSle))
1325 (vaultSle->at(sfAssetsMaximum) ==
1326 Number{9223372036854776, 43, Number::Normalized{}}));
1329 tx[sfAssetsMaximum] =
"9223372036854775807e-40";
1330 auto const newKeylet =
1335 auto const vaultSle = env.le(newKeylet);
1336 if (!BEAST_EXPECT(vaultSle))
1340 (vaultSle->at(sfAssetsMaximum) ==
1341 Number{9223372036854776, -37, Number::Normalized{}}));
1344 tx[sfAssetsMaximum] =
"9223372036854775807e-100";
1345 auto const newKeylet =
1351 auto const vaultSle = env.le(newKeylet);
1352 if (!BEAST_EXPECT(vaultSle))
1355 BEAST_EXPECT(vaultSle->at(sfAssetsMaximum) ==
kNumZero);
1360 tx[sfAssetsMaximum] =
"1000000000000000e81";
1361 env(tx, Ter(outOfRangeErr));
1367 auto const g = env.getParseFailureGuard(
true);
1368 tx[sfAssetsMaximum] =
"18446744073709551617e5";
1370 BEAST_EXPECTS(
false,
"Expected parse_error for mantissa larger than uint64 max");
1372 catch (ParseError
const& e)
1374 using namespace std::string_literals;
1376 e.what() ==
"invalidParamsField 'tx_json.AssetsMaximum' has invalid data."s);