474 using namespace loan_broker;
475 using namespace loan;
483 enum class Line { Holding, InDebt };
485 auto const runScenario = [
this](
FeatureBitset features, Line line,
TER expected) {
489 Account const issuer{
"issuer"};
494 env.fund(XRP(100'000), issuer, alice, carol, bob);
496 env(fset(issuer, asfDefaultRipple));
508 env(trust(alice, trustLimit));
509 env(trust(carol, trustLimit));
510 env(trust(bob, trustLimit));
513 env(pay(issuer, alice, usd(1'000)));
514 env(pay(issuer, carol, usd(1'000)));
515 if (line == Line::Holding)
517 env(pay(issuer, bob, bobEdge));
523 env(trust(issuer, oppositeLimit));
525 env(pay(bob, issuer, bobDebt));
529 Vault const vault{env};
530 auto [vaultTx, vaultKeylet] = vault.create({.owner = alice, .asset = usd});
531 vaultTx[sfScale] = 0;
536 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = usd(1'000)}));
541 auto const brokerKeylet =
543 env(
set(alice, vaultKeylet.key));
547 env(
set(carol, brokerKeylet.key, usd(1'000).value()),
550 kPaymentInterval(365 * 24 * 60 * 60),
552 Sig(sfCounterpartySignature, alice),
553 Fee(env.current()->fees().base * 2),
563 env(pay(carol, loanKeylet.key, usd(2'000).value()), Ter(
tesSUCCESS));
568 auto const sleVault = env.le(vaultKeylet);
569 BEAST_EXPECT(sleVault && sleVault->at(sfAssetsTotal) ==
Number{1'240});
571 BEAST_EXPECT(sleIssuance && sleIssuance->at(sfOutstandingAmount) == 1'000);
578 env(vault.deposit({.depositor = bob, .id = vaultKeylet.key, .amount = usd(6)}),
589 auto const legacy =
cashBasisAll_ - featureLendingProtocolV1_1;
592 "bug: VaultDeposit share truncation lets depositor debit "
593 "round away to zero (pre-fixCleanup3_4_0)");
598 "bug: VaultDeposit share truncation lets depositor debit "
599 "round away to zero (pre-fixCleanup3_2_0 and pre-fixCleanup3_4_0)");
605 "bug: VaultDeposit share truncation rejected with "
606 "tecPRECISION_LOSS (post-fixCleanup3_4_0)");
611 "bug: VaultDeposit share truncation rejected with "
612 "tecPRECISION_LOSS (post-fixCleanup3_4_0, pre-fixCleanup3_2_0)");
617 "bug: VaultDeposit share truncation against a debt balance "
618 "round away to zero (pre-fixCleanup3_4_0)");
623 "bug: VaultDeposit share truncation against a debt balance rejected with "
624 "tecPRECISION_LOSS (post-fixCleanup3_4_0)");
647 enum class DestKind :
bool { ThirdParty =
false, Self =
true };
649 auto const runScenario = [
this](
FeatureBitset features, DestKind destKind,
TER expected) {
653 Account const issuer{
"issuer"};
657 env.fund(XRP(100'000), issuer, alice, bob);
659 env(fset(issuer, asfDefaultRipple));
667 env(trust(alice, aliceLimit));
668 if (destKind == DestKind::ThirdParty)
669 env(trust(bob, bobLimit));
672 env(pay(issuer, alice, usd(1'000)));
673 if (destKind == DestKind::ThirdParty)
674 env(pay(issuer, bob, atEdge));
677 Vault const vault{env};
678 auto [vaultTx, vaultKeylet] = vault.create({.owner = alice, .asset = usd});
679 vaultTx[sfScale] = 0;
683 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = usd(1'000)}));
688 if (destKind == DestKind::Self)
690 env(pay(issuer, alice, atEdge));
694 auto tx = vault.withdraw({.depositor = alice, .id = vaultKeylet.key, .amount = usd(2)});
695 if (destKind == DestKind::ThirdParty)
696 tx[sfDestination] = bob.human();
697 env(tx, Ter(expected));
703 "bug: VaultWithdraw to third-party at IOU edge fires invariant "
704 "(pre-fixCleanup3_2_0)");
709 "bug: VaultWithdraw to third-party at IOU edge succeeds "
710 "(post-fixCleanup3_2_0)");
715 "bug: VaultWithdraw to self at IOU edge fires invariant "
716 "(pre-fixCleanup3_2_0)");
721 "bug: VaultWithdraw to self at IOU edge succeeds "
722 "(post-fixCleanup3_2_0)");
1032 testcase(
"Bug6 - limit bypass with share-denominated withdrawal");
1038 bool const withFix = features[fixCleanup3_1_3];
1040 Env env{*
this, features};
1042 Account const issuer{
"issuer"};
1043 Account const depositor{
"depositor"};
1044 Account const charlie{
"charlie"};
1045 Vault const vault{env};
1047 env.fund(XRP(1000), issuer, owner, depositor, charlie);
1048 env(fset(issuer, asfAllowTrustLineClawback));
1052 env.trust(asset(1000), owner);
1053 env.trust(asset(1000), depositor);
1054 env(pay(issuer, owner, asset(200)));
1055 env(pay(issuer, depositor, asset(200)));
1059 env.trust(asset(5), charlie);
1062 auto const [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
1066 auto const depositTx =
1067 vault.deposit({.depositor = depositor, .id =
keylet.key, .amount = asset(100)});
1072 auto const vaultSle = env.le(
keylet);
1073 if (!BEAST_EXPECT(vaultSle))
1075 auto const mptIssuanceID = vaultSle->at(sfShareMPTID);
1076 MPTIssue const shares(mptIssuanceID);
1084 vault.withdraw({.depositor = depositor, .id =
keylet.key, .amount = asset(10)});
1085 withdrawTx[sfDestination] = charlie.human();
1089 auto const charlieBalanceBefore = env.balance(charlie, asset.
raw().
get<
Issue>());
1097 auto withdrawTx = vault.withdraw({
1098 .depositor = depositor,
1100 .amount =
STAmount(share, 10'000'000),
1102 withdrawTx[sfDestination] = charlie.human();
1106 auto const charlieBalanceAfter = env.balance(charlie, asset.
raw().
get<
Issue>());
1111 BEAST_EXPECT(charlieBalanceAfter == charlieBalanceBefore);
1117 BEAST_EXPECT(charlieBalanceAfter > charlieBalanceBefore);
1151 using namespace loan_broker;
1152 using namespace loan;
1154 Account const issuer{
"issuer"};
1156 Account const holder{
"holder"};
1157 Account const borrower{
"borrower"};
1159 env.
fund(XRP(10'000), issuer, owner, holder, borrower);
1162 env(fset(issuer, asfAllowTrustLineClawback));
1166 env.
trust(usd(1'000), owner);
1167 env.
trust(usd(1'000), holder);
1168 env.
trust(usd(1'000), borrower);
1171 env(pay(issuer, holder, usd(100)));
1172 env(pay(issuer, borrower, usd(100)));
1175 Vault const vault{env};
1176 auto [vaultTx, vaultKeylet] = vault.create({.owner = owner, .asset = usd});
1177 vaultTx[sfScale] = 0;
1182 env(vault.deposit({.depositor = holder, .id = vaultKeylet.key, .amount = usd(5)}));
1187 auto const brokerKeylet =
1189 env(
set(owner, vaultKeylet.key));
1193 env(
set(borrower, brokerKeylet.key, usd(5).value()),
1196 kPaymentInterval(365 * 24 * 60 * 60),
1198 Sig(sfCounterpartySignature, owner),
1199 Fee(env.
current()->fees().base * 2),
1207 env(pay(borrower, loanKeylet.key, usd(10).value()), Ter(
tesSUCCESS));
1210 auto const vaultSle = env.
le(vaultKeylet);
1211 if (!BEAST_EXPECT(vaultSle))
1212 return std::nullopt;
1213 auto const mptIssuanceID = vaultSle->at(sfShareMPTID);
1215 Number const initialAssetsTotal = vaultSle->at(sfAssetsTotal);
1216 Number const initialAssetsAvailable = vaultSle->at(sfAssetsAvailable);
1217 BEAST_EXPECT(initialAssetsTotal == usd(7).number());
1218 BEAST_EXPECT(initialAssetsAvailable == usd(7).number());
1221 if (!BEAST_EXPECT(sleIssuance))
1222 return std::nullopt;
1223 BEAST_EXPECT(sleIssuance->getFieldU64(sfOutstandingAmount) == 5);
1231 .vaultKeylet = vaultKeylet,
1232 .initialAssetsTotal = initialAssetsTotal,
1233 .initialAssetsAvailable = initialAssetsAvailable,
1385 using namespace loan_broker;
1386 using namespace loan;
1388 Account const issuer{
"issuer"};
1390 Account const holder{
"holder"};
1392 Account const borrower{
"borrower"};
1394 env.
fund(XRP(100'000), issuer, owner, holder, other, borrower);
1397 env(fset(issuer, asfAllowTrustLineClawback));
1398 env(fset(issuer, asfDefaultRipple));
1402 env.
trust(usd(100'000), owner);
1403 env.
trust(usd(100'000), holder);
1404 env.
trust(usd(100'000), other);
1405 env.
trust(usd(100'000), borrower);
1408 int const holderDeposit = 10'000 - otherDeposit;
1409 env(pay(issuer, holder, usd(holderDeposit)));
1410 if (otherDeposit != 0)
1412 env(pay(issuer, other, usd(otherDeposit)));
1416 Vault const vault{env};
1417 auto const [createTx, vaultKeylet, subscriptionDate] = vault.createClosedEnded(
1422 auto const vaultSle = env.
le(vaultKeylet);
1423 if (!BEAST_EXPECT(vaultSle))
1424 return std::nullopt;
1425 MPTID const shareId = vaultSle->at(sfShareMPTID);
1428 {.depositor = holder, .id = vaultKeylet.key, .amount = usd(holderDeposit)}));
1429 if (otherDeposit != 0)
1432 {.depositor = other, .id = vaultKeylet.key, .amount = usd(otherDeposit)}));
1436 vault.closePastSubscription(subscriptionDate);
1438 auto const brokerKeylet =
1440 env(
set(owner, vaultKeylet.key));
1443 auto const sleBroker = env.
le(brokerKeylet);
1444 if (!BEAST_EXPECT(sleBroker))
1445 return std::nullopt;
1446 auto const loanKeylet =
1449 env(
set(borrower, brokerKeylet.key, usd(1'000).value()),
1452 kPaymentInterval(120),
1454 Sig(sfCounterpartySignature, owner),
1455 Fee(env.
current()->fees().base * 2),
1462 if (env.
current()->rules().enabled(fixCleanup3_4_0))
1464 auto const loanBefore = env.
le(loanKeylet);
1465 if (!BEAST_EXPECT(loanBefore))
1466 return std::nullopt;
1467 std::uint32_t const dueDate = loanBefore->at(sfNextPaymentDueDate);
1471 env(manage(owner, loanKeylet.key, tfLoanImpair), Ter(
tesSUCCESS));
1474 auto const vaultAfter = env.
le(vaultKeylet);
1475 if (!BEAST_EXPECT(vaultAfter))
1476 return std::nullopt;
1477 BEAST_EXPECT(vaultAfter->at(sfAssetsAvailable) == usd(9'000).value());
1478 BEAST_EXPECT(vaultAfter->at(sfLossUnrealized) == usd(1'000).value());
1485 .vaultKeylet = vaultKeylet,
1613 using namespace loan_broker;
1614 using namespace loan;
1615 using namespace std::chrono_literals;
1617 auto const runScenario = [
this](
1619 bool removeAssetToken,
1620 bool withdrawAllAliceShares,
1623 std::string{
"bug: MPT vault zero-value withdraw "} +
1624 (removeAssetToken ?
"without asset MPToken" :
"with asset MPToken") +
1625 (withdrawAllAliceShares ?
", Alice's last share" :
", Alice has leftover shares") +
1626 (features[fixCleanup3_4_0] ?
" (post-fixCleanup3_4_0)" :
" (pre-fixCleanup3_4_0)"));
1628 Env env(*
this, features);
1630 Account const issuer{
"issuer"};
1634 Account const borrower{
"borrower"};
1636 env.fund(XRP(100'000), issuer, owner, alice, bob, borrower);
1639 MPTTester mptt{env, issuer, kMptInitNoFund};
1640 mptt.create({.flags = tfMPTCanTransfer});
1642 mptt.authorize({.account = owner});
1643 mptt.authorize({.account = alice});
1644 mptt.authorize({.account = bob});
1645 mptt.authorize({.account = borrower});
1648 env(pay(issuer, alice, asset(2)));
1649 env(pay(issuer, bob, asset(8)));
1652 Vault const vault{env};
1653 auto const [createTx, vaultKeylet, subscriptionDate] = vault.createClosedEnded(
1654 {.owner = owner, .asset = asset, .subscriptionOffset = 60s});
1658 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(2)}));
1659 env(vault.deposit({.depositor = bob, .id = vaultKeylet.key, .amount = asset(8)}));
1662 vault.closePastSubscription(subscriptionDate);
1664 auto const brokerKeylet =
1666 env(
set(owner, vaultKeylet.key));
1669 auto const sleBroker = env.le(brokerKeylet);
1670 if (!BEAST_EXPECT(sleBroker))
1675 env(
set(borrower, brokerKeylet.key, asset(10).value()),
1678 kPaymentInterval(120),
1680 Sig(sfCounterpartySignature, owner),
1681 Fee(env.current()->fees().base * 2),
1685 auto const loanBefore = env.le(loanKeylet);
1686 if (!BEAST_EXPECT(loanBefore))
1688 std::uint32_t const dueDate = loanBefore->at(sfNextPaymentDueDate);
1691 env(manage(owner, loanKeylet.key, tfLoanImpair), Ter(
tesSUCCESS));
1694 auto const vaultImpaired = env.le(vaultKeylet);
1695 if (!BEAST_EXPECT(vaultImpaired))
1697 BEAST_EXPECT(vaultImpaired->at(sfAssetsAvailable) == asset(0).value());
1698 BEAST_EXPECT(vaultImpaired->at(sfAssetsTotal) == vaultImpaired->at(sfLossUnrealized));
1699 Number const totalBefore = vaultImpaired->at(sfAssetsTotal);
1700 Number const lossBefore = vaultImpaired->at(sfLossUnrealized);
1702 MPTID const shareId = vaultImpaired->at(sfShareMPTID);
1704 if (!BEAST_EXPECT(issuanceBefore))
1707 issuanceBefore->getFieldU64(sfOutstandingAmount);
1710 if (!BEAST_EXPECT(tokenAlice))
1712 std::uint64_t const sharesBefore = tokenAlice->getFieldU64(sfMPTAmount);
1713 BEAST_EXPECT(sharesBefore == 2);
1714 std::uint64_t const sharesToRedeem = withdrawAllAliceShares ? sharesBefore : 1;
1717 auto const assetTokenKeylet =
keylet::mptoken(mptt.issuanceID(), alice.id());
1718 if (removeAssetToken)
1720 mptt.authorize({.account = alice, .flags = tfMPTUnauthorize});
1722 BEAST_EXPECT(!env.le(assetTokenKeylet));
1726 auto const existing = env.le(assetTokenKeylet);
1727 if (!BEAST_EXPECT(existing))
1729 BEAST_EXPECT(existing->getFieldU64(sfMPTAmount) == 0);
1732 std::uint32_t const redemptionDate = vaultImpaired->at(sfRedemptionDate);
1735 env(vault.withdraw({.depositor = alice, .id = vaultKeylet.key, .amount = redeemShares}),
1741 if (removeAssetToken)
1743 BEAST_EXPECT(!env.le(assetTokenKeylet));
1747 auto const assetAfter = env.le(assetTokenKeylet);
1748 if (!BEAST_EXPECT(assetAfter))
1750 BEAST_EXPECT(assetAfter->getFieldU64(sfMPTAmount) == 0);
1754 if (withdrawAllAliceShares)
1756 BEAST_EXPECT(!shareAfter);
1758 else if (BEAST_EXPECT(shareAfter))
1760 BEAST_EXPECT(shareAfter->getFieldU64(sfMPTAmount) == sharesBefore - sharesToRedeem);
1763 auto const vaultAfter = env.le(vaultKeylet);
1764 if (!BEAST_EXPECT(vaultAfter))
1766 BEAST_EXPECT(vaultAfter->at(sfAssetsTotal) == totalBefore);
1767 BEAST_EXPECT(vaultAfter->at(sfLossUnrealized) == lossBefore);
1768 BEAST_EXPECT(vaultAfter->at(sfAssetsAvailable) == asset(0).value());
1771 if (!BEAST_EXPECT(issuanceAfter))
1774 issuanceAfter->getFieldU64(sfOutstandingAmount) ==
1775 outstandingBefore - sharesToRedeem);
1830 using namespace loan_broker;
1831 using namespace loan;
1832 using namespace std::chrono_literals;
1836 Account const issuer{
"issuer"};
1840 Account const borrower{
"borrower"};
1842 env.fund(XRP(100'000), issuer, owner, alice, bob, borrower);
1844 env(fset(issuer, asfDefaultRipple));
1848 env.trust(asset(100), owner);
1849 env.trust(asset(100), alice);
1850 env.trust(asset(100), bob);
1851 env.trust(asset(100), borrower);
1854 env(pay(issuer, alice, asset(2)));
1855 env(pay(issuer, bob, asset(8)));
1858 Vault const vault{env};
1859 auto const [createTx, vaultKeylet, subscriptionDate] =
1860 vault.createClosedEnded({.owner = owner, .asset = asset, .subscriptionOffset = 60s});
1864 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(2)}));
1865 env(vault.deposit({.depositor = bob, .id = vaultKeylet.key, .amount = asset(8)}));
1869 if (!BEAST_EXPECT(env.le(assetLine)))
1871 env.trust(asset(0), alice);
1873 BEAST_EXPECT(!env.le(assetLine));
1875 vault.closePastSubscription(subscriptionDate);
1877 auto const brokerKeylet =
1879 env(
set(owner, vaultKeylet.key));
1882 auto const sleBroker = env.le(brokerKeylet);
1883 if (!BEAST_EXPECT(sleBroker))
1885 auto const loanKeylet =
1888 env(
set(borrower, brokerKeylet.key, asset(10).value()),
1891 kPaymentInterval(120),
1893 Sig(sfCounterpartySignature, owner),
1894 Fee(env.current()->fees().base * 2),
1898 auto const loanBefore = env.le(loanKeylet);
1899 if (!BEAST_EXPECT(loanBefore))
1901 std::uint32_t const dueDate = loanBefore->at(sfNextPaymentDueDate);
1904 env(manage(owner, loanKeylet.key, tfLoanImpair), Ter(
tesSUCCESS));
1907 auto const vaultImpaired = env.le(vaultKeylet);
1908 if (!BEAST_EXPECT(vaultImpaired))
1910 BEAST_EXPECT(vaultImpaired->at(sfAssetsAvailable) == asset(0).value());
1911 BEAST_EXPECT(vaultImpaired->at(sfAssetsTotal) == vaultImpaired->at(sfLossUnrealized));
1912 Number const totalBefore = vaultImpaired->at(sfAssetsTotal);
1913 Number const lossBefore = vaultImpaired->at(sfLossUnrealized);
1915 MPTID const shareId = vaultImpaired->at(sfShareMPTID);
1917 if (!BEAST_EXPECT(tokenAlice))
1919 std::uint64_t const sharesBefore = tokenAlice->getFieldU64(sfMPTAmount);
1922 BEAST_EXPECT(sharesBefore > 1);
1925 std::uint32_t const redemptionDate = vaultImpaired->at(sfRedemptionDate);
1928 env(vault.withdraw({.depositor = alice, .id = vaultKeylet.key, .amount = redeemShares}),
1934 BEAST_EXPECT(!env.le(assetLine));
1937 if (!BEAST_EXPECT(shareAfter))
1939 BEAST_EXPECT(shareAfter->getFieldU64(sfMPTAmount) == sharesBefore - 1);
1941 auto const vaultAfter = env.le(vaultKeylet);
1942 if (!BEAST_EXPECT(vaultAfter))
1944 BEAST_EXPECT(vaultAfter->at(sfAssetsTotal) == totalBefore);
1945 BEAST_EXPECT(vaultAfter->at(sfLossUnrealized) == lossBefore);
1946 BEAST_EXPECT(vaultAfter->at(sfAssetsAvailable) == asset(0).value());
1962 using namespace loan_broker;
1963 using namespace loan;
1964 using namespace std::chrono_literals;
1968 std::string{
"bug: XRP vault zero-value withdraw with sponsored fee"} +
1969 (features[fixCleanup3_4_0] ?
" (post-fixCleanup3_4_0)" :
" (pre-fixCleanup3_4_0)"));
1971 Env env(*
this, features);
1976 Account const borrower{
"borrower"};
1977 Account const sponsor{
"sponsor"};
1979 env.fund(XRP(100'000), owner, alice, bob, borrower, sponsor);
1983 Vault const vault{env};
1984 auto const [createTx, vaultKeylet, subscriptionDate] = vault.createClosedEnded(
1985 {.owner = owner, .asset = asset, .subscriptionOffset = 60s});
1989 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(2)}));
1990 env(vault.deposit({.depositor = bob, .id = vaultKeylet.key, .amount = asset(8)}));
1993 vault.closePastSubscription(subscriptionDate);
1995 auto const brokerKeylet =
1997 env(
set(owner, vaultKeylet.key));
2000 auto const sleBroker = env.le(brokerKeylet);
2001 if (!BEAST_EXPECT(sleBroker))
2006 env(
set(borrower, brokerKeylet.key, asset(10).value()),
2009 kPaymentInterval(120),
2011 Sig(sfCounterpartySignature, owner),
2012 Fee(env.current()->fees().base * 2),
2016 auto const loanBefore = env.le(loanKeylet);
2017 if (!BEAST_EXPECT(loanBefore))
2019 std::uint32_t const dueDate = loanBefore->at(sfNextPaymentDueDate);
2022 env(manage(owner, loanKeylet.key, tfLoanImpair), Ter(
tesSUCCESS));
2025 auto const vaultImpaired = env.le(vaultKeylet);
2026 if (!BEAST_EXPECT(vaultImpaired))
2028 BEAST_EXPECT(vaultImpaired->at(sfAssetsAvailable) == asset(0).value());
2029 BEAST_EXPECT(vaultImpaired->at(sfAssetsTotal) == vaultImpaired->at(sfLossUnrealized));
2030 Number const totalBefore = vaultImpaired->at(sfAssetsTotal);
2031 Number const lossBefore = vaultImpaired->at(sfLossUnrealized);
2033 MPTID const shareId = vaultImpaired->at(sfShareMPTID);
2035 if (!BEAST_EXPECT(tokenAlice))
2037 std::uint64_t const sharesBefore = tokenAlice->getFieldU64(sfMPTAmount);
2038 BEAST_EXPECT(sharesBefore == 2);
2041 std::uint32_t const redemptionDate = vaultImpaired->at(sfRedemptionDate);
2044 auto const aliceBalanceBefore = env.balance(alice);
2045 auto const sponsorBalanceBefore = env.balance(sponsor);
2046 auto const fee = env.current()->fees().base;
2048 env(vault.withdraw({.depositor = alice, .id = vaultKeylet.key, .amount = redeemShares}),
2051 Sig(sfSponsorSignature, sponsor),
2055 BEAST_EXPECT(env.balance(sponsor) == sponsorBalanceBefore - fee);
2056 BEAST_EXPECT(env.balance(alice) == aliceBalanceBefore);
2062 if (!BEAST_EXPECT(shareAfter))
2064 BEAST_EXPECT(shareAfter->getFieldU64(sfMPTAmount) == sharesBefore - 1);
2066 auto const vaultAfter = env.le(vaultKeylet);
2067 if (!BEAST_EXPECT(vaultAfter))
2069 BEAST_EXPECT(vaultAfter->at(sfAssetsTotal) == totalBefore);
2070 BEAST_EXPECT(vaultAfter->at(sfLossUnrealized) == lossBefore);
2071 BEAST_EXPECT(vaultAfter->at(sfAssetsAvailable) == asset(0).value());
2091 auto const runExistingLine = [
this](
2094 bool issuerGlobalFreeze =
false) {
2095 Env env(*
this, features);
2096 Account const issuer{
"issuer"};
2100 env.fund(XRP(10'000), issuer, alice, bob);
2102 env(fset(issuer, asfDefaultRipple));
2107 env(trust(alice, usd(10'000)));
2108 env(trust(bob, usd(10'000)));
2110 env(pay(issuer, alice, usd(1'000)));
2113 Vault const vault{env};
2114 auto [vaultTx, vaultKeylet] = vault.create({.owner = alice, .asset = usd});
2118 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = usd(500)}));
2121 env(vault.withdraw({.depositor = alice, .id = vaultKeylet.key, .amount = usd(50)}));
2124 env(fclear(issuer, asfDefaultRipple));
2126 if (issuerGlobalFreeze)
2128 env(fset(issuer, asfGlobalFreeze));
2136 if (!issuerGlobalFreeze)
2138 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = usd(10)}));
2142 Number const destBefore = env.balance(alice, usd.
raw()).number();
2143 Number const vaultBefore = env.le(vaultKeylet)->at(sfAssetsTotal);
2144 Number const withdrawAmt{50};
2146 env(vault.withdraw({.depositor = alice, .id = vaultKeylet.key, .amount = usd(50)}),
2150 Number const destAfter = env.balance(alice, usd.
raw()).number();
2151 Number const vaultAfter = env.le(vaultKeylet)->at(sfAssetsTotal);
2154 BEAST_EXPECT(destAfter == destBefore + withdrawAmt);
2155 BEAST_EXPECT(vaultAfter == vaultBefore - withdrawAmt);
2159 BEAST_EXPECT(destAfter == destBefore);
2160 BEAST_EXPECT(vaultAfter == vaultBefore);
2163 if (!issuerGlobalFreeze)
2166 vault.withdraw({.depositor = alice, .id = vaultKeylet.key, .amount = usd(50)});
2167 destTx[sfDestination] = bob.human();
2173 auto const runDeletedLine = [
this](
FeatureBitset features,
TER selfExpected) {
2174 Env env(*
this, features);
2175 Account const issuer{
"issuer"};
2178 env.fund(XRP(10'000), issuer, alice);
2180 env(fset(issuer, asfDefaultRipple));
2185 env(trust(alice, usd(10'000)));
2187 env(pay(issuer, alice, usd(500)));
2190 Vault const vault{env};
2191 auto [vaultTx, vaultKeylet] = vault.create({.owner = alice, .asset = usd});
2195 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = usd(500)}));
2198 env(trust(alice, usd(0)));
2201 env(fclear(issuer, asfDefaultRipple));
2204 env(vault.withdraw({.depositor = alice, .id = vaultKeylet.key, .amount = usd(50)}),
2209 auto const runCoverWithdraw = [
this](
FeatureBitset features,
TER selfExpected) {
2210 using namespace loan_broker;
2212 Env env(*
this, features);
2213 Account const issuer{
"issuer"};
2216 env.fund(XRP(10'000), issuer, alice);
2218 env(fset(issuer, asfDefaultRipple));
2223 env(trust(alice, usd(10'000)));
2225 env(pay(issuer, alice, usd(1'000)));
2228 Vault const vault{env};
2229 auto const [createTx, vaultKeylet, subscriptionDate] = vault.createClosedEnded(
2231 (void)subscriptionDate;
2235 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = usd(500)}));
2238 auto const brokerKeylet =
2240 env(
set(alice, vaultKeylet.key));
2242 env(coverDeposit(alice, brokerKeylet.key, usd(100).value()));
2245 env(fclear(issuer, asfDefaultRipple));
2249 Number const destBefore = env.balance(alice, usd.
raw()).number();
2250 Number const coverBefore = env.le(brokerKeylet)->at(sfCoverAvailable);
2251 Number const withdrawAmt{50};
2253 env(coverWithdraw(alice, brokerKeylet.key, usd(50).value()), Ter(selfExpected));
2256 Number const destAfter = env.balance(alice, usd.
raw()).number();
2257 Number const coverAfter = env.le(brokerKeylet)->at(sfCoverAvailable);
2260 BEAST_EXPECT(destAfter == destBefore + withdrawAmt);
2261 BEAST_EXPECT(coverAfter == coverBefore - withdrawAmt);
2265 BEAST_EXPECT(destAfter == destBefore);
2266 BEAST_EXPECT(coverAfter == coverBefore);
2270 auto const runDeletedCoverWithdraw = [
this](
FeatureBitset features,
TER selfExpected) {
2271 using namespace loan_broker;
2273 Env env(*
this, features);
2274 Account const issuer{
"issuer"};
2277 env.fund(XRP(10'000), issuer, alice);
2279 env(fset(issuer, asfDefaultRipple));
2284 env(trust(alice, usd(10'000)));
2286 env(pay(issuer, alice, usd(600)));
2289 Vault const vault{env};
2290 auto const [createTx, vaultKeylet, subscriptionDate] = vault.createClosedEnded(
2292 (void)subscriptionDate;
2296 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = usd(500)}));
2299 auto const brokerKeylet =
2301 env(
set(alice, vaultKeylet.key));
2303 env(coverDeposit(alice, brokerKeylet.key, usd(100).value()));
2306 env(trust(alice, usd(0)));
2309 env(fclear(issuer, asfDefaultRipple));
2312 env(coverWithdraw(alice, brokerKeylet.key, usd(50).value()), Ter(selfExpected));
2316 auto const runPrivateVault = [
this](
FeatureBitset features,
TER selfExpected) {
2317 Env env(*
this, features);
2318 Account const issuer{
"issuer"};
2320 Account const pdOwner{
"pdOwner"};
2321 Account const credIssuer{
"credIssuer"};
2324 env.fund(XRP(10'000), issuer, alice, pdOwner, credIssuer);
2326 env(fset(issuer, asfDefaultRipple));
2330 env(trust(alice, usd(10'000)));
2332 env(pay(issuer, alice, usd(1'000)));
2335 Vault const vault{env};
2336 auto [vaultTx, vaultKeylet] =
2337 vault.create({.owner = alice, .asset = usd, .flags = tfVaultPrivate});
2341 pdomain::Credentials
const credentials{{.issuer = credIssuer, .credType = credType}};
2343 auto const domainId = pdomain::getNewDomain(env.meta());
2345 auto domainTx = vault.set({.owner = alice, .id = vaultKeylet.key});
2346 domainTx[sfDomainID] =
to_string(domainId);
2351 env(credentials::create(alice, credIssuer, credType));
2352 env(credentials::accept(alice, credIssuer, credType));
2355 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = usd(500)}));
2358 env(fclear(issuer, asfDefaultRipple));
2361 env(vault.withdraw({.depositor = alice, .id = vaultKeylet.key, .amount = usd(50)}),
2367 "bug: VaultWithdraw to self fails with tecINTERNAL after issuer "
2368 "clears asfDefaultRipple even though the trust line exists "
2369 "(pre-fixCleanup3_4_0)");
2373 "bug: VaultWithdraw to self succeeds after issuer clears "
2374 "asfDefaultRipple when the trust line exists (post-fixCleanup3_4_0)");
2378 "bug: VaultWithdraw to self with an existing line still gets "
2379 "tecFROZEN under asfGlobalFreeze (post-fixCleanup3_4_0)");
2383 "bug: VaultWithdraw to self fails with tecINTERNAL after issuer "
2384 "clears asfDefaultRipple and the trust line was deleted "
2385 "(pre-fixCleanup3_4_0)");
2389 "bug: VaultWithdraw to self fails with terNO_RIPPLE after issuer "
2390 "clears asfDefaultRipple and the trust line was deleted "
2391 "(post-fixCleanup3_4_0)");
2395 "bug: LoanBrokerCoverWithdraw to self fails with tecINTERNAL after "
2396 "issuer clears asfDefaultRipple even though the trust line exists "
2397 "(pre-fixCleanup3_4_0)");
2401 "bug: LoanBrokerCoverWithdraw to self succeeds after issuer clears "
2402 "asfDefaultRipple when the trust line exists (post-fixCleanup3_4_0)");
2406 "bug: LoanBrokerCoverWithdraw to self fails with tecINTERNAL after "
2407 "issuer clears asfDefaultRipple and the trust line was deleted "
2408 "(pre-fixCleanup3_4_0)");
2412 "bug: LoanBrokerCoverWithdraw to self fails with terNO_RIPPLE after "
2413 "issuer clears asfDefaultRipple and the trust line was deleted "
2414 "(post-fixCleanup3_4_0)");
2418 "bug: private VaultWithdraw to self fails with tecINTERNAL after "
2419 "issuer clears asfDefaultRipple even though the trust line exists "
2420 "(pre-fixCleanup3_4_0)");
2424 "bug: private VaultWithdraw to self succeeds after issuer clears "
2425 "asfDefaultRipple when the trust line exists (post-fixCleanup3_4_0)");
2447 Env env{*
this, features};
2449 Account const holder{
"holder"};
2450 Account const destination{
"destination"};
2451 Account const sponsor{
"sponsor"};
2452 env.fund(XRP(10'000), owner, holder, destination, sponsor);
2455 constexpr std::uint32_t investmentPeriod = 14u * 24u * 60u * 60u;
2456 auto const [vault, vaultKeylet, subscriptionDate, redemptionDate] =
2458 BEAST_EXPECT(redemptionDate - subscriptionDate == investmentPeriod);
2461 {.depositor = holder, .id = vaultKeylet.key, .amount = XRP(100).value()}));
2468 auto const vaultBefore = env.le(vaultKeylet);
2469 if (!BEAST_EXPECT(vaultBefore))
2471 auto const assetsTotalBefore = vaultBefore->at(sfAssetsTotal);
2472 auto const holderBalanceBefore = env.balance(holder);
2473 auto const destinationBalanceBefore = env.balance(destination);
2474 auto const sponsorBalanceBefore = env.balance(sponsor);
2475 auto const fee = env.current()->fees().base;
2477 auto withdraw = vault.withdraw(
2478 {.depositor = holder, .id = vaultKeylet.key, .amount = XRP(100).value()});
2479 withdraw[sfDestination] = destination.human();
2483 Sig(sfSponsorSignature, sponsor),
2487 auto const vaultAfter = env.le(vaultKeylet);
2488 if (!BEAST_EXPECT(vaultAfter))
2490 BEAST_EXPECT(env.balance(sponsor) == sponsorBalanceBefore - fee);
2494 BEAST_EXPECT(vaultAfter->at(sfAssetsTotal) == assetsTotalBefore - XRP(100).value());
2495 BEAST_EXPECT(env.balance(holder) == holderBalanceBefore);
2496 BEAST_EXPECT(env.balance(destination) == destinationBalanceBefore + XRP(100));
2502 BEAST_EXPECT(vaultAfter->at(sfAssetsTotal) == assetsTotalBefore);
2503 BEAST_EXPECT(env.balance(holder) == holderBalanceBefore);
2504 BEAST_EXPECT(env.balance(destination) == destinationBalanceBefore);
2508 auto retry = vault.withdraw(
2509 {.depositor = holder, .id = vaultKeylet.key, .amount = XRP(100).value()});
2510 retry[sfDestination] = destination.human();
2515 "bug: sponsored XRP withdrawal to a distinct destination misreads a "
2516 "touched-but-zero sender delta as a second recipient "
2517 "(pre-fixCleanup3_4_0)");
2521 "bug: sponsored XRP withdrawal to a distinct destination succeeds "
2522 "(post-fixCleanup3_4_0)");
2541 Env env{*
this, features};
2543 Account const holder{
"holder"};
2544 Account const sponsor{
"sponsor"};
2545 env.fund(XRP(10'000), owner, holder, sponsor);
2548 Vault const vault{env};
2549 auto [vaultTx, vaultKeylet] = vault.create({.owner = owner, .asset =
xrpIssue()});
2554 {.depositor = holder, .id = vaultKeylet.key, .amount = XRP(100).value()}));
2557 auto const vaultBefore = env.le(vaultKeylet);
2558 if (!BEAST_EXPECT(vaultBefore))
2560 auto const assetsTotalBefore = vaultBefore->at(sfAssetsTotal);
2561 auto const sponsorBalanceBefore = env.balance(sponsor);
2562 auto const fee = env.current()->fees().base;
2566 auto withdraw = vault.withdraw(
2567 {.depositor = holder, .id = vaultKeylet.key, .amount = XRP(100).value()});
2568 withdraw[sfDestination] = sponsor.human();
2572 Sig(sfSponsorSignature, sponsor),
2576 auto const vaultAfter = env.le(vaultKeylet);
2577 if (!BEAST_EXPECT(vaultAfter))
2582 BEAST_EXPECT(vaultAfter->at(sfAssetsTotal) == assetsTotalBefore - XRP(100).value());
2585 BEAST_EXPECT(env.balance(sponsor) == sponsorBalanceBefore + XRP(100) - fee);
2589 BEAST_EXPECT(vaultAfter->at(sfAssetsTotal) == assetsTotalBefore);
2590 BEAST_EXPECT(env.balance(sponsor) == sponsorBalanceBefore - fee);
2594 "bug: co-signed sponsor named as withdrawal destination has its "
2595 "own fee debit misread as breaking the payout equality "
2596 "(pre-fixCleanup3_4_0)");
2600 "bug: co-signed sponsor named as withdrawal destination succeeds "
2601 "(post-fixCleanup3_4_0)");
2621 auto const runScenario = [
this](
2624 bool const sponsorIsDestination) {
2625 Env env{*
this, features};
2627 Account const holder{
"holder"};
2628 Account const destination{
"destination"};
2629 Account const sponsor{
"sponsor"};
2630 env.fund(XRP(10'000), owner, holder, destination, sponsor);
2633 Vault const vault{env};
2634 auto [vaultTx, vaultKeylet] = vault.create({.owner = owner, .asset =
xrpIssue()});
2639 {.depositor = holder, .id = vaultKeylet.key, .amount = XRP(100).value()}));
2642 auto const fee = env.current()->fees().base;
2643 env(sponsor::set_fee(sponsor, 0, fee), sponsor::SponseeAcc(holder));
2646 auto const vaultBefore = env.le(vaultKeylet);
2647 if (!BEAST_EXPECT(vaultBefore))
2649 auto const assetsTotalBefore = vaultBefore->at(sfAssetsTotal);
2650 auto const holderBalanceBefore = env.balance(holder);
2651 auto const destinationBalanceBefore = env.balance(destination);
2652 auto const sponsorBalanceBefore = env.balance(sponsor);
2654 Account const& recipient = sponsorIsDestination ? sponsor : destination;
2655 auto withdraw = vault.withdraw(
2656 {.depositor = holder, .id = vaultKeylet.key, .amount = XRP(100).value()});
2657 withdraw[sfDestination] = recipient.human();
2658 env(withdraw, Fee(fee), sponsor::As(sponsor,
spfSponsorFee), Ter(expected));
2661 auto const vaultAfter = env.le(vaultKeylet);
2662 if (!BEAST_EXPECT(vaultAfter))
2666 BEAST_EXPECT(env.balance(holder) == holderBalanceBefore);
2670 BEAST_EXPECT(vaultAfter->at(sfAssetsTotal) == assetsTotalBefore - XRP(100).value());
2671 if (sponsorIsDestination)
2676 BEAST_EXPECT(env.balance(sponsor) == sponsorBalanceBefore + XRP(100));
2680 BEAST_EXPECT(env.balance(destination) == destinationBalanceBefore + XRP(100));
2681 BEAST_EXPECT(env.balance(sponsor) == sponsorBalanceBefore);
2684 if (!BEAST_EXPECT(sponsorship))
2686 BEAST_EXPECT(!sponsorship->isFieldPresent(sfFeeAmount));
2690 BEAST_EXPECT(vaultAfter->at(sfAssetsTotal) == assetsTotalBefore);
2691 BEAST_EXPECT(env.balance(sponsor) == sponsorBalanceBefore);
2692 if (!sponsorIsDestination)
2693 BEAST_EXPECT(env.balance(destination) == destinationBalanceBefore);
2697 "pre-funded fee XRP withdrawal to a distinct destination succeeds "
2698 "(post-fixCleanup3_4_0)");
2702 "bug: pre-funded sponsor named as withdrawal destination misreads "
2703 "the sender's touched-but-zero delta as a second recipient "
2704 "(pre-fixCleanup3_4_0)");
2708 "bug: pre-funded sponsor named as withdrawal destination receives "
2709 "the full payout (post-fixCleanup3_4_0)");
2722 "unsponsored XRP withdrawal to a distinct destination succeeds "
2723 "(pre-fixCleanup3_4_0)");
2727 Account const holder{
"holder"};
2728 Account const destination{
"destination"};
2729 env.fund(XRP(10'000), owner, holder, destination);
2732 Vault const vault{env};
2733 auto [vaultTx, vaultKeylet] = vault.create({.owner = owner, .asset =
xrpIssue()});
2738 {.depositor = holder, .id = vaultKeylet.key, .amount = XRP(100).value()}));
2741 auto const vaultBefore = env.le(vaultKeylet);
2742 if (!BEAST_EXPECT(vaultBefore))
2744 auto const assetsTotalBefore = vaultBefore->at(sfAssetsTotal);
2745 auto const holderBalanceBefore = env.balance(holder);
2746 auto const destinationBalanceBefore = env.balance(destination);
2747 auto const fee = env.current()->fees().base;
2749 auto withdraw = vault.withdraw(
2750 {.depositor = holder, .id = vaultKeylet.key, .amount = XRP(100).value()});
2751 withdraw[sfDestination] = destination.human();
2755 auto const vaultAfter = env.le(vaultKeylet);
2756 if (!BEAST_EXPECT(vaultAfter))
2758 BEAST_EXPECT(vaultAfter->at(sfAssetsTotal) == assetsTotalBefore - XRP(100).value());
2759 BEAST_EXPECT(env.balance(holder) == holderBalanceBefore - fee);
2760 BEAST_EXPECT(env.balance(destination) == destinationBalanceBefore + XRP(100));