51 using namespace loan_broker;
55 auto const vaultAssetBalance = [&](
Keylet const& vaultKeylet) {
56 auto const sleVault = env.le(vaultKeylet);
57 BEAST_EXPECT(sleVault !=
nullptr);
59 return std::make_pair(sleVault->at(sfAssetsAvailable), sleVault->at(sfAssetsTotal));
62 auto const vaultShareBalance = [&](
Keylet const& vaultKeylet) {
63 auto const sleVault = env.le(vaultKeylet);
64 BEAST_EXPECT(sleVault !=
nullptr);
67 BEAST_EXPECT(sleIssuance !=
nullptr);
69 return sleIssuance->at(sfOutstandingAmount);
79 auto const setupVault = [&](
PrettyAsset const& asset,
82 Vault const vault{env};
84 auto const& [tx, vaultKeylet, subscriptionDate] = vault.createClosedEnded(
89 auto const& vaultSle = env.le(vaultKeylet);
90 BEAST_EXPECT(vaultSle !=
nullptr);
92 Asset const share = vaultSle->at(sfShareMPTID);
95 {.depositor = depositor, .id = vaultKeylet.key, .amount = asset(100)}),
101 vault.closePastSubscription(subscriptionDate);
103 auto const& [availablePreDefault, totalPreDefault] = vaultAssetBalance(vaultKeylet);
104 BEAST_EXPECT(availablePreDefault == totalPreDefault);
105 BEAST_EXPECT(availablePreDefault == asset(100).value());
110 .id = vaultKeylet.key,
112 .amount = share(0).value(),
117 auto const& sharesAvailable = vaultShareBalance(vaultKeylet);
118 auto const& brokerKeylet =
121 env(
set(owner, vaultKeylet.key));
127 env(
set(depositor, brokerKeylet.key, asset(100).value()),
130 kPaymentInterval(120),
132 Sig(sfCounterpartySignature, owner),
133 Fee(env.current()->fees().base * 2),
141 .id = vaultKeylet.key,
143 .amount = share(0).value(),
150 env(manage(owner, loanKeylet.key, tfLoanDefault), Ter(
tesSUCCESS));
152 auto const& [availablePostDefault, totalPostDefault] = vaultAssetBalance(vaultKeylet);
154 BEAST_EXPECT(availablePostDefault == totalPostDefault);
155 BEAST_EXPECT(availablePostDefault == asset(0).value());
156 BEAST_EXPECT(vaultShareBalance(vaultKeylet) == sharesAvailable);
161 auto const testCase = [&](
PrettyAsset const& asset,
166 testcase(
"VaultClawback (share) - " + prefix +
" owner asset clawback fails");
167 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor);
171 auto const expectedTer = [&] {
180 .id = vaultKeylet.key,
182 .amount = asset(100).value(),
190 "VaultClawback (share) - " + prefix +
" owner incomplete share clawback fails");
191 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor);
192 auto const& vaultSle = env.le(vaultKeylet);
193 if (!BEAST_EXPECT(vaultSle))
195 Asset const share = vaultSle->at(sfShareMPTID);
198 .id = vaultKeylet.key,
200 .amount = share(1).value(),
208 "VaultClawback (share) - " + prefix +
209 " owner implicit complete share clawback");
210 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor);
213 .id = vaultKeylet.key,
224 "VaultClawback (share) - " + prefix +
225 " owner explicit complete share clawback succeeds");
226 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor);
227 auto const& vaultSle = env.le(vaultKeylet);
228 if (!BEAST_EXPECT(vaultSle))
230 Asset const share = vaultSle->at(sfShareMPTID);
233 .id = vaultKeylet.key,
235 .amount = share(vaultShareBalance(vaultKeylet)).value(),
241 testcase(
"VaultClawback (share) - " + prefix +
" owner can clawback own shares");
242 auto [vault, vaultKeylet] = setupVault(asset, owner, owner);
243 auto const& vaultSle = env.le(vaultKeylet);
244 if (!BEAST_EXPECT(vaultSle))
246 Asset const share = vaultSle->at(sfShareMPTID);
249 .id = vaultKeylet.key,
251 .amount = share(vaultShareBalance(vaultKeylet)).value(),
258 testcase(
"VaultClawback (share) - " + prefix +
" empty vault share clawback fails");
259 auto [vault, vaultKeylet] = setupVault(asset, owner, owner);
260 auto const& vaultSle = env.le(vaultKeylet);
261 if (!BEAST_EXPECT(vaultSle))
263 Asset const share = vaultSle->at(sfShareMPTID);
266 .id = vaultKeylet.key,
268 .amount = share(vaultShareBalance(vaultKeylet)).value(),
275 .id = vaultKeylet.key,
277 .amount = share(vaultShareBalance(vaultKeylet)).value(),
285 Account const depositor{
"bob"};
286 Account const issuer{
"issuer"};
288 env.fund(XRP(10000), issuer, owner, depositor);
293 testCase(xrp,
"XRP", owner, depositor);
294 testCase(xrp,
"XRP (depositor is owner)", owner, owner);
298 env(fset(issuer, asfAllowTrustLineClawback));
301 env.trust(iou(1000), owner);
302 env.trust(iou(1000), depositor);
303 env(pay(issuer, owner, iou(100)));
304 env(pay(issuer, depositor, iou(100)));
306 testCase(iou,
"IOU", owner, depositor);
307 testCase(iou,
"IOU (owner is issuer)", issuer, depositor);
310 MPTTester mptt{env, issuer, kMptInitNoFund};
311 mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
313 mptt.authorize({.account = owner});
314 mptt.authorize({.account = depositor});
315 env(pay(issuer, owner, mpt(1000)));
316 env(pay(issuer, depositor, mpt(1000)));
318 testCase(mpt,
"MPT", owner, depositor);
319 testCase(mpt,
"MPT (owner is issuer)", issuer, depositor);
326 using namespace loan_broker;
327 using namespace loan;
329 env.enableFeature(fixCleanup3_1_3);
338 auto const setupVault = [&](
PrettyAsset const& asset,
342 Vault const vault{env};
344 auto const& [tx, vaultKeylet, subscriptionDate] = vault.createClosedEnded(
349 auto const& vaultSle = env.le(vaultKeylet);
350 BEAST_EXPECT(vaultSle !=
nullptr);
351 env.memoize(
Account(
"vault", vaultSle->at(sfAccount)));
353 {.depositor = depositor, .id = vaultKeylet.key, .amount = asset(100)}),
357 vault.closePastSubscription(subscriptionDate);
362 auto const testCase = [&](
PrettyAsset const& asset,
369 testcase(
"VaultClawback (asset) - " + prefix +
" issuer XRP clawback fails");
370 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
375 .id = vaultKeylet.key,
377 .amount = asset(1).value(),
383 .id = vaultKeylet.key,
392 "VaultClawback (asset) - " + prefix +
" clawback for different asset fails");
393 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
395 Account const issuer2{
"issuer2"};
399 .id = vaultKeylet.key,
401 .amount = asset2(1).value(),
408 "VaultClawback (asset) - " + prefix +
409 " ambiguous owner/issuer asset clawback fails");
410 auto [vault, vaultKeylet] = setupVault(asset, issuer, depositor, issuer);
413 .id = vaultKeylet.key,
420 testcase(
"VaultClawback (asset) - " + prefix +
" non-issuer asset clawback fails");
421 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
425 .id = vaultKeylet.key,
432 .id = vaultKeylet.key,
434 .amount = asset(1).value(),
440 testcase(
"VaultClawback (asset) - " + prefix +
" issuer clawback from self fails");
441 auto [vault, vaultKeylet] = setupVault(asset, owner, issuer, issuer);
444 .id = vaultKeylet.key,
451 testcase(
"VaultClawback (asset) - " + prefix +
" issuer share clawback fails");
452 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
453 auto const& vaultSle = env.le(vaultKeylet);
454 if (!BEAST_EXPECT(vaultSle))
456 Asset const share = vaultSle->at(sfShareMPTID);
460 .id = vaultKeylet.key,
462 .amount = share(1).value(),
469 "VaultClawback (asset) - " + prefix +
470 " partial issuer asset clawback succeeds");
471 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
475 .id = vaultKeylet.key,
477 .amount = asset(1).value(),
484 "VaultClawback (asset) - " + prefix +
" full issuer asset clawback succeeds");
485 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
489 .id = vaultKeylet.key,
491 .amount = asset(100).value(),
498 "VaultClawback (asset) - " + prefix +
499 " implicit full issuer asset clawback succeeds");
500 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
504 .id = vaultKeylet.key,
512 "VaultClawback (asset) - " + prefix +
513 " zero-amount clawback clamped with outstanding loan");
514 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
516 auto const vaultSle = env.le(vaultKeylet);
517 if (!BEAST_EXPECT(vaultSle))
523 auto const brokerKeylet =
525 env(
set(owner, vaultKeylet.key));
530 env(
set(depositor, brokerKeylet.key, asset(40).value()),
533 kPaymentInterval(120),
535 Sig(sfCounterpartySignature, owner),
536 Fee(env.current()->fees().base * 2),
541 auto const sle = env.le(vaultKeylet);
542 BEAST_EXPECT(sle->at(sfAssetsAvailable) == asset(60).value());
543 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(100).value());
551 .id = vaultKeylet.key,
559 auto const sle = env.le(vaultKeylet);
560 BEAST_EXPECT(sle !=
nullptr);
561 BEAST_EXPECT(sle->at(sfAssetsAvailable) == asset(0).value());
562 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(40).value());
565 auto const sharesAfter = env.balance(depositor, shares);
566 BEAST_EXPECT(sharesAfter == shares(
Number{4, sle->at(sfScale) + 1}));
572 "VaultClawback (asset) - " + prefix +
573 " non-zero clawback clamped with outstanding loan");
574 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
576 auto const vaultSle = env.le(vaultKeylet);
577 if (!BEAST_EXPECT(vaultSle))
582 auto const brokerKeylet =
584 env(
set(owner, vaultKeylet.key));
588 env(
set(depositor, brokerKeylet.key, asset(40).value()),
591 kPaymentInterval(120),
593 Sig(sfCounterpartySignature, owner),
594 Fee(env.current()->fees().base * 2),
599 auto const sle = env.le(vaultKeylet);
600 BEAST_EXPECT(sle->at(sfAssetsAvailable) == asset(60).value());
601 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(100).value());
607 .id = vaultKeylet.key,
609 .amount = asset(100).value(),
615 auto const sle = env.le(vaultKeylet);
616 BEAST_EXPECT(sle !=
nullptr);
617 BEAST_EXPECT(sle->at(sfAssetsAvailable) == asset(0).value());
618 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(40).value());
621 auto const sharesAfter = env.balance(depositor, shares);
622 BEAST_EXPECT(sharesAfter == shares(
Number{4, sle->at(sfScale) + 1}));
628 "VaultClawback (asset) - " + prefix +
629 " partial clawback below available with outstanding loan");
630 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
632 auto const vaultSle = env.le(vaultKeylet);
633 if (!BEAST_EXPECT(vaultSle))
638 auto const brokerKeylet =
640 env(
set(owner, vaultKeylet.key));
644 env(
set(depositor, brokerKeylet.key, asset(40).value()),
647 kPaymentInterval(120),
649 Sig(sfCounterpartySignature, owner),
650 Fee(env.current()->fees().base * 2),
655 auto const sle = env.le(vaultKeylet);
656 BEAST_EXPECT(sle->at(sfAssetsAvailable) == asset(60).value());
657 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(100).value());
663 .id = vaultKeylet.key,
665 .amount = asset(30).value(),
671 auto const sle = env.le(vaultKeylet);
672 BEAST_EXPECT(sle !=
nullptr);
673 BEAST_EXPECT(sle->at(sfAssetsAvailable) == asset(30).value());
674 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(70).value());
677 auto const sharesAfter = env.balance(depositor, shares);
678 BEAST_EXPECT(sharesAfter == shares(
Number{7, sle->at(sfScale) + 1}));
684 "VaultClawback (asset) - " + prefix +
685 " clawback exactly equal to available with outstanding loan");
686 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
688 auto const vaultSle = env.le(vaultKeylet);
689 if (!BEAST_EXPECT(vaultSle))
693 auto const brokerKeylet =
695 env(
set(owner, vaultKeylet.key));
699 env(
set(depositor, brokerKeylet.key, asset(40).value()),
702 kPaymentInterval(120),
704 Sig(sfCounterpartySignature, owner),
705 Fee(env.current()->fees().base * 2),
712 .id = vaultKeylet.key,
714 .amount = asset(60).value(),
720 auto const sle = env.le(vaultKeylet);
721 BEAST_EXPECT(sle !=
nullptr);
722 BEAST_EXPECT(sle->at(sfAssetsAvailable) == asset(0).value());
723 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(40).value());
726 auto const sharesAfter = env.balance(depositor, shares);
727 BEAST_EXPECT(sharesAfter == shares(
Number{4, sle->at(sfScale) + 1}));
733 "VaultClawback (asset) - " + prefix +
734 " clawback with zero available (fully borrowed)");
735 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
737 auto const vaultSle = env.le(vaultKeylet);
738 if (!BEAST_EXPECT(vaultSle))
742 auto const brokerKeylet =
744 env(
set(owner, vaultKeylet.key));
748 env(
set(depositor, brokerKeylet.key, asset(100).value()),
751 kPaymentInterval(120),
753 Sig(sfCounterpartySignature, owner),
754 Fee(env.current()->fees().base * 2),
759 auto const sle = env.le(vaultKeylet);
760 BEAST_EXPECT(sle->at(sfAssetsAvailable) == asset(0).value());
761 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(100).value());
764 auto const sharesBefore = env.balance(depositor, shares);
770 .id = vaultKeylet.key,
779 .id = vaultKeylet.key,
781 .amount = asset(50).value(),
788 auto const sle = env.le(vaultKeylet);
789 BEAST_EXPECT(sle !=
nullptr);
790 BEAST_EXPECT(sle->at(sfAssetsAvailable) == asset(0).value());
791 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(100).value());
792 auto const sharesAfter = env.balance(depositor, shares);
793 BEAST_EXPECT(sharesAfter == sharesBefore);
799 Account const depositor{
"bob"};
800 Account const issuer{
"issuer"};
802 env.fund(XRP(10000), issuer, owner, depositor);
807 testCase(xrp,
"XRP", owner, depositor, issuer);
811 env(fset(issuer, asfAllowTrustLineClawback));
813 env.trust(iou(2000), owner);
814 env.trust(iou(2000), depositor);
815 env(pay(issuer, owner, iou(2000)));
816 env(pay(issuer, depositor, iou(2000)));
818 testCase(iou,
"IOU", owner, depositor, issuer);
821 MPTTester mptt{env, issuer, kMptInitNoFund};
822 mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
825 mptt.authorize({.account = owner});
826 mptt.authorize({.account = depositor});
827 env(pay(issuer, depositor, mpt(2000)));
829 testCase(mpt,
"MPT", owner, depositor, issuer);
839 "VaultClawback (asset) - IOU pre-fixCleanup3_1_3"
840 " zero-amount clawback unclamped with outstanding loan");
842 Env legacyEnv(*
this,
all_);
843 legacyEnv.disableFeature(fixCleanup3_1_3);
844 legacyEnv.disableFeature(featureLendingProtocolV1_2);
845 legacyEnv.fund(XRP(10000), issuer, owner, depositor);
848 legacyEnv(fset(issuer, asfAllowTrustLineClawback));
850 legacyEnv.trust(iou(2000), owner);
851 legacyEnv.trust(iou(2000), depositor);
852 legacyEnv(pay(issuer, owner, iou(2000)));
853 legacyEnv(pay(issuer, depositor, iou(2000)));
856 Vault const vault{legacyEnv};
857 auto const& [tx, vaultKeylet, subscriptionDate] = vault.createClosedEnded(
862 auto const vaultSleCreate = legacyEnv.le(vaultKeylet);
863 BEAST_EXPECT(vaultSleCreate !=
nullptr);
866 legacyEnv.memoize(
Account(
"vault", vaultSleCreate->at(sfAccount)));
868 vault.deposit({.depositor = depositor, .id = vaultKeylet.key, .amount = iou(100)}),
871 vault.closePastSubscription(subscriptionDate);
873 auto const vaultSle = legacyEnv.le(vaultKeylet);
874 BEAST_EXPECT(vaultSle !=
nullptr);
881 auto const brokerKeylet =
883 legacyEnv(
set(owner, vaultKeylet.key));
889 set(depositor, brokerKeylet.key, iou(40).value()),
892 kPaymentInterval(120),
894 Sig(sfCounterpartySignature, owner),
895 Fee(legacyEnv.current()->fees().base * 2),
900 auto const sle = legacyEnv.le(vaultKeylet);
901 BEAST_EXPECT(sle->at(sfAssetsAvailable) == iou(60).value());
902 BEAST_EXPECT(sle->at(sfAssetsTotal) == iou(100).value());
905 auto const sharesBefore = legacyEnv.balance(depositor, shares);
914 .id = vaultKeylet.key,
922 auto const sle = legacyEnv.le(vaultKeylet);
923 BEAST_EXPECT(sle !=
nullptr);
924 BEAST_EXPECT(sle->at(sfAssetsAvailable) == iou(60).value());
925 BEAST_EXPECT(sle->at(sfAssetsTotal) == iou(100).value());
926 auto const sharesAfter = legacyEnv.balance(depositor, shares);
927 BEAST_EXPECT(sharesAfter == sharesBefore);
945 testcase(
"Vault deposit fails when MPT asset is escrowed");
947 Env env{*
this, testableAmendments()};
948 auto const baseFee = env.current()->fees().base;
950 Account const depositor{
"depositor"};
951 Account const issuer{
"issuer"};
954 env.fund(XRP(10000), issuer, owner, depositor, bob);
957 MPTTester mptt{env, issuer, kMptInitNoFund};
959 {.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock | tfMPTCanEscrow});
960 mptt.authorize({.account = owner});
961 mptt.authorize({.account = depositor});
962 mptt.authorize({.account = bob});
964 env(pay(issuer, depositor, asset(100)));
968 auto const escrowSeq = env.seq(depositor);
969 env(escrow::create(depositor, bob, asset(60)),
970 escrow::kCondition(escrow::kCb1),
971 escrow::kFinishTime(env.now() + 1s),
976 Vault const vault{env};
977 auto [tx, vaultKeylet] = vault.create({.owner = owner, .asset = asset});
983 {.depositor = depositor, .id = vaultKeylet.key, .amount = asset(100)}),
988 env(vault.deposit({.depositor = depositor, .id = vaultKeylet.key, .amount = asset(40)}),
993 auto const sle = env.le(vaultKeylet);
994 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(40).value());
998 env(escrow::finish(bob, depositor, escrowSeq),
999 escrow::kCondition(escrow::kCb1),
1000 escrow::kFulfillment(escrow::kFb1),
1007 testcase(
"Vault withdraw respects escrowed shares");
1009 Env env{*
this, testableAmendments()};
1010 auto const baseFee = env.current()->fees().base;
1012 Account const depositor{
"depositor"};
1013 Account const issuer{
"issuer"};
1016 env.fund(XRP(10000), issuer, owner, depositor, bob);
1019 MPTTester mptt{env, issuer, kMptInitNoFund};
1021 {.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock | tfMPTCanEscrow});
1022 mptt.authorize({.account = owner});
1023 mptt.authorize({.account = depositor});
1025 env(pay(issuer, depositor, asset(100)));
1028 Vault const vault{env};
1029 auto [tx, vaultKeylet] = vault.create({.owner = owner, .asset = asset});
1035 {.depositor = depositor, .id = vaultKeylet.key, .amount = asset(100)}),
1039 auto const vaultSle = env.le(vaultKeylet);
1040 if (!BEAST_EXPECT(vaultSle))
1042 env.memoize(
Account(
"vault", vaultSle->at(sfAccount)));
1046 auto const shareMPTID = vaultSle->at(sfShareMPTID);
1049 jv[jss::Account] = bob.human();
1050 jv[sfMPTokenIssuanceID] =
to_string(shareMPTID);
1051 jv[jss::TransactionType] = jss::MPTokenAuthorize;
1057 auto const escrowAmount = shares(
Number{6, vaultSle->at(sfScale) + 1});
1058 env(escrow::create(depositor, bob, escrowAmount),
1059 escrow::kCondition(escrow::kCb1),
1060 escrow::kFinishTime(env.now() + 1s),
1067 {.depositor = depositor, .id = vaultKeylet.key, .amount = asset(100)}),
1073 {.depositor = depositor, .id = vaultKeylet.key, .amount = asset(40)}),
1078 auto const sle = env.le(vaultKeylet);
1079 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(60).value());
1084 testcase(
"Vault clawback only recovers unlocked shares");
1086 Env env{*
this, testableAmendments() | fixCleanup3_1_3};
1087 auto const baseFee = env.current()->fees().base;
1089 Account const depositor{
"depositor"};
1090 Account const issuer{
"issuer"};
1093 env.fund(XRP(10000), issuer, owner, depositor, bob);
1096 MPTTester mptt{env, issuer, kMptInitNoFund};
1098 {.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock | tfMPTCanEscrow});
1099 mptt.authorize({.account = owner});
1100 mptt.authorize({.account = depositor});
1102 env(pay(issuer, depositor, asset(100)));
1105 Vault const vault{env};
1106 auto [tx, vaultKeylet] = vault.create({.owner = owner, .asset = asset});
1112 {.depositor = depositor, .id = vaultKeylet.key, .amount = asset(100)}),
1116 auto const vaultSle = env.le(vaultKeylet);
1117 if (!BEAST_EXPECT(vaultSle))
1119 env.memoize(
Account(
"vault", vaultSle->at(sfAccount)));
1123 auto const shareMPTID = vaultSle->at(sfShareMPTID);
1126 jv[jss::Account] = bob.human();
1127 jv[sfMPTokenIssuanceID] =
to_string(shareMPTID);
1128 jv[jss::TransactionType] = jss::MPTokenAuthorize;
1134 auto const escrowAmount = shares(
Number{6, vaultSle->at(sfScale) + 1});
1135 env(escrow::create(depositor, bob, escrowAmount),
1136 escrow::kCondition(escrow::kCb1),
1137 escrow::kFinishTime(env.now() + 1s),
1144 env(vault.clawback({
1146 .id = vaultKeylet.key,
1147 .holder = depositor,
1153 auto const sle = env.le(vaultKeylet);
1154 BEAST_EXPECT(sle !=
nullptr);
1156 BEAST_EXPECT(sle->at(sfAssetsTotal) == asset(60).value());
1157 BEAST_EXPECT(sle->at(sfAssetsAvailable) == asset(60).value());
1160 auto const sharesAfter = env.balance(depositor, shares);
1161 BEAST_EXPECT(sharesAfter == shares(0));