1#include <test/jtx/Account.h>
2#include <test/jtx/CaptureLogs.h>
3#include <test/jtx/Env.h>
4#include <test/jtx/JTx.h>
5#include <test/jtx/TestHelpers.h>
6#include <test/jtx/amount.h>
7#include <test/jtx/balance.h>
8#include <test/jtx/credentials.h>
9#include <test/jtx/deposit.h>
10#include <test/jtx/fee.h>
11#include <test/jtx/flags.h>
12#include <test/jtx/mpt.h>
13#include <test/jtx/noop.h>
14#include <test/jtx/pay.h>
15#include <test/jtx/permissioned_domains.h>
16#include <test/jtx/seq.h>
17#include <test/jtx/sig.h>
18#include <test/jtx/tag.h>
19#include <test/jtx/tags.h>
20#include <test/jtx/ter.h>
21#include <test/jtx/trust.h>
22#include <test/jtx/txflags.h>
23#include <test/jtx/vault.h>
24#include <test/unit_test/SuiteJournal.h>
26#include <xrpl/basics/Number.h>
27#include <xrpl/basics/base_uint.h>
28#include <xrpl/basics/strHex.h>
29#include <xrpl/beast/unit_test/suite.h>
30#include <xrpl/beast/utility/Journal.h>
31#include <xrpl/beast/utility/Zero.h>
32#include <xrpl/core/ServiceRegistry.h>
33#include <xrpl/ledger/ApplyView.h>
34#include <xrpl/ledger/OpenView.h>
35#include <xrpl/ledger/helpers/AccountRootHelpers.h>
36#include <xrpl/ledger/helpers/TokenHelpers.h>
37#include <xrpl/protocol/AccountID.h>
38#include <xrpl/protocol/Feature.h>
39#include <xrpl/protocol/Indexes.h>
40#include <xrpl/protocol/Issue.h>
41#include <xrpl/protocol/LedgerFormats.h>
42#include <xrpl/protocol/MPTIssue.h>
43#include <xrpl/protocol/Protocol.h>
44#include <xrpl/protocol/SField.h>
45#include <xrpl/protocol/STAmount.h>
46#include <xrpl/protocol/STObject.h>
47#include <xrpl/protocol/STTx.h>
48#include <xrpl/protocol/SeqProxy.h>
49#include <xrpl/protocol/Serializer.h>
50#include <xrpl/protocol/TER.h>
51#include <xrpl/protocol/TxFlags.h>
52#include <xrpl/protocol/TxFormats.h>
53#include <xrpl/protocol/Units.h>
54#include <xrpl/protocol/jss.h>
55#include <xrpl/tx/ApplyContext.h>
56#include <xrpl/tx/Transactor.h>
57#include <xrpl/tx/transactors/lending/LoanBrokerCoverDeposit.h>
95 auto const failAll = [
this](
FeatureBitset features,
bool goodVault =
false) {
96 Env env(*
this, features);
103 Vault const vault{env};
104 auto const [tx,
keylet] = vault.create({.owner = alice, .asset = asset});
107 BEAST_EXPECT(
static_cast<bool>(env.
le(
keylet)) == goodVault);
112 auto const brokerKeylet =
116 env(coverDeposit(alice, brokerKeylet.key, asset(1000)),
Ter(
temDISABLED));
118 env(coverWithdraw(alice, brokerKeylet.key, asset(1000)),
Ter(
temDISABLED));
121 env(coverClawback(alice), kLoanBrokerId(brokerKeylet.key),
Ter(
temDISABLED));
123 env(coverClawback(alice),
124 kLoanBrokerId(brokerKeylet.key),
130 failAll(
all_ - featureMPTokensV1);
131 failAll(
all_ - featureSingleAssetVault - featureLendingProtocol);
132 failAll(
all_ - featureSingleAssetVault);
133 failAll(
all_ - featureLendingProtocol,
true);
138 Env env(*
this,
all_ - featureLendingProtocolV1_2);
144 Vault const vault{env};
145 auto const [tx,
keylet] = vault.create({.owner = alice, .asset = asset});
182 auto const& asset = vault.asset.raw();
188 else if (asset.holds<
Issue>())
198 assetLabel =
"Unknown ";
200 testcase <<
"Lifecycle: " << assetLabel << label;
209 badMptt.
create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
211 return badMptt[
"BAD"];
213 static PrettyAsset const kBadIouAsset = evan[
"BAD"];
214 static Account const kNonExistent{
"NonExistent"};
215 static PrettyAsset const kGhostIouAsset = kNonExistent[
"GST"];
216 PrettyAsset const vaultPseudoIouAsset = vault.pseudoAccount[
"PSD"];
218 auto const badKeylet =
222 auto const badBrokerPseudo = [&] {
223 if (
auto const le = env.
le(badKeylet); BEAST_EXPECT(le))
225 return Account{
"Bad Broker pseudo-account", le->at(sfAccount)};
228 return vault.pseudoAccount;
230 PrettyAsset const badBrokerPseudoIouAsset = badBrokerPseudo[
"WAT"];
235 auto jtx = env.
jt(
set(alice, vault.vaultID));
244 if (
auto broker = env.
le(
keylet); BEAST_EXPECT(broker))
248 BEAST_EXPECT(broker->at(sfVaultID) == vault.vaultID);
249 BEAST_EXPECT(broker->at(sfAccount) != alice.
id());
250 BEAST_EXPECT(broker->at(sfOwner) == alice.
id());
251 BEAST_EXPECT(broker->at(sfFlags) == 0);
252 BEAST_EXPECT(broker->at(sfSequence) == env.
seq(alice) - 1);
253 BEAST_EXPECT(broker->at(sfOwnerCount) == 0);
254 BEAST_EXPECT(broker->at(sfLoanSequence) == 1);
255 BEAST_EXPECT(broker->at(sfDebtTotal) == 0);
256 BEAST_EXPECT(broker->at(sfCoverAvailable) == 0);
266 Account const pseudoAccount{
"Broker pseudo-account", broker->at(sfAccount)};
269 if (
auto const pseudo = env.
le(pseudoKeylet); BEAST_EXPECT(pseudo))
275 pseudo->at(sfFlags) == (lsfDisableMaster | lsfDefaultRipple | lsfDepositAuth));
276 BEAST_EXPECT(pseudo->at(sfSequence) == 0);
278 BEAST_EXPECT(pseudo->at(sfOwnerCount) == (vault.asset.raw().native() ? 0 : 1));
279 BEAST_EXPECT(!pseudo->isFieldPresent(sfAccountTxnID));
280 BEAST_EXPECT(!pseudo->isFieldPresent(sfRegularKey));
281 BEAST_EXPECT(!pseudo->isFieldPresent(sfEmailHash));
282 BEAST_EXPECT(!pseudo->isFieldPresent(sfWalletLocator));
283 BEAST_EXPECT(!pseudo->isFieldPresent(sfWalletSize));
284 BEAST_EXPECT(!pseudo->isFieldPresent(sfMessageKey));
285 BEAST_EXPECT(!pseudo->isFieldPresent(sfTransferRate));
286 BEAST_EXPECT(!pseudo->isFieldPresent(sfDomain));
287 BEAST_EXPECT(!pseudo->isFieldPresent(sfTickSize));
288 BEAST_EXPECT(!pseudo->isFieldPresent(sfTicketCount));
289 BEAST_EXPECT(!pseudo->isFieldPresent(sfNFTokenMinter));
290 BEAST_EXPECT(!pseudo->isFieldPresent(sfMintedNFTokens));
291 BEAST_EXPECT(!pseudo->isFieldPresent(sfBurnedNFTokens));
292 BEAST_EXPECT(!pseudo->isFieldPresent(sfFirstNFTokenSequence));
293 BEAST_EXPECT(!pseudo->isFieldPresent(sfAMMID));
294 BEAST_EXPECT(!pseudo->isFieldPresent(sfVaultID));
295 BEAST_EXPECT(pseudo->at(sfLoanBrokerID) ==
keylet.key);
301 auto const accountInfo = env.
rpc(
"account_info", pseudoStr);
302 if (BEAST_EXPECT(accountInfo.isObject()))
304 auto const& accountData = accountInfo[jss::result][jss::account_data];
305 if (BEAST_EXPECT(accountData.isObject()))
307 BEAST_EXPECT(accountData[jss::Account] == pseudoStr);
310 auto const& pseudoInfo = accountInfo[jss::result][jss::pseudo_account];
311 if (BEAST_EXPECT(pseudoInfo.isObject()))
313 BEAST_EXPECT(pseudoInfo[jss::type] ==
"LoanBroker");
318 auto const verifyCoverAmount =
319 [&env, &vault, &pseudoAccount, &broker, &
keylet,
this](
auto n) {
323 if (BEAST_EXPECT(broker))
325 auto const amount = vault.asset(n);
326 BEAST_EXPECT(broker->at(sfCoverAvailable) == amount.number());
336 env(coverDeposit(alice, vault.vaultID, vault.asset(10)),
Ter(
tecNO_ENTRY));
338 verifyCoverAmount(0);
348 env(coverClawback(evan), kLoanBrokerId(vault.vaultID),
Ter(
tecNO_ENTRY));
351 if (vault.asset.raw().native())
358 if (vault.asset.raw().holds<
Issue>())
365 env(coverClawback(alice),
366 kAmount(vaultPseudoIouAsset(1)),
370 env(coverClawback(issuer),
371 kLoanBrokerId(
keylet.key),
372 kAmount(badBrokerPseudoIouAsset(10)),
374 PrettyAsset const brokerWrongCurrencyAsset = pseudoAccount[
"WAT"];
375 env(coverClawback(issuer),
376 kLoanBrokerId(
keylet.key),
377 kAmount(brokerWrongCurrencyAsset(10)),
384 BEAST_EXPECT(vault.asset.raw().holds<
MPTIssue>());
389 env(coverClawback(issuer),
390 kLoanBrokerId(
keylet.key),
397 env(coverDeposit(alice,
keylet.key, vault.asset(10)));
399 verifyCoverAmount(10);
406 env(coverWithdraw(alice, vault.vaultID, vault.asset(10)),
Ter(
tecNO_ENTRY));
410 if (!vault.asset.raw().native())
413 env(coverWithdraw(alice,
keylet.key, vault.asset(1)),
414 kDestination(bystander),
419 env(coverWithdraw(alice,
keylet.key, vault.asset(1)),
424 env(coverWithdraw(alice,
keylet.key, vault.asset(7)));
426 verifyCoverAmount(3);
429 env(coverDeposit(alice,
keylet.key, vault.asset(5)));
431 verifyCoverAmount(8);
435 env(coverWithdraw(alice,
keylet.key, vault.asset(1)), kDestination(evan));
437 verifyCoverAmount(7);
441 env(coverWithdraw(alice,
keylet.key, vault.asset(1)), kDestination(evan),
Dtag(3));
443 verifyCoverAmount(6);
445 if (!vault.asset.raw().native())
448 env(coverClawback(issuer), kLoanBrokerId(
keylet.key),
kAmount(vault.asset(2)));
450 verifyCoverAmount(4);
453 env(coverDeposit(alice,
keylet.key, vault.asset(5)));
455 verifyCoverAmount(9);
458 for (
auto const& tx : {
461 coverClawback(issuer),
462 kLoanBrokerId(
keylet.key),
467 coverClawback(issuer),
468 kLoanBrokerId(
keylet.key),
474 coverClawback(issuer),
475 kLoanBrokerId(
keylet.key),
482 coverClawback(issuer),
483 kLoanBrokerId(
keylet.key),
493 verifyCoverAmount(0);
496 env(coverDeposit(alice,
keylet.key, vault.asset(6)));
498 verifyCoverAmount(6);
503 env(
set(alice, vault.vaultID), kLoanBrokerId(
keylet.key));
508 changeBroker(broker);
514 if (BEAST_EXPECT(broker) && checkChangedBroker)
515 checkChangedBroker(broker);
520 env(
set(alice, vault.vaultID),
521 kLoanBrokerId(broker->key()),
528 if (BEAST_EXPECT(broker))
530 BEAST_EXPECT(!broker->isFieldPresent(sfDebtMaximum));
531 BEAST_EXPECT(!broker->isFieldPresent(sfData));
541 env(del(alice, badKeylet.key));
546 auto const aliceBalance = env.balance(alice, vault.asset);
547 auto const coverFunds = env.balance(pseudoAccount, vault.asset);
548 BEAST_EXPECT(coverFunds.number() == broker->at(sfCoverAvailable));
550 verifyCoverAmount(6);
563 env(del(alice,
keylet.key));
567 BEAST_EXPECT(!broker);
568 auto const pseudo = env.le(pseudoKeylet);
569 BEAST_EXPECT(!pseudo);
571 auto const expectedBalance = aliceBalance + coverFunds -
572 (aliceBalance.value().native() ?
STAmount(env.current()->fees().base.value())
589 Account const issuer{
"issuer"};
596 Account const bystander{
"bystander"};
604 env(
fset(issuer, asfAllowTrustLineClawback));
610 env(
trust(alice, iouAsset(1'000'000)));
611 env(
trust(evan, iouAsset(1'000'000)));
613 env(
pay(issuer, evan, iouAsset(100'000)));
614 env(
pay(issuer, alice, iouAsset(100'000)));
618 mptt.
create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
624 env(
pay(issuer, alice, mptAsset(100'000)));
625 env(
pay(issuer, evan, mptAsset(100'000)));
628 std::array const assets{xrpAsset, iouAsset, mptAsset};
632 for (
auto const& asset : assets)
634 auto [tx,
keylet] = vault.create({.owner = alice, .asset = asset});
642 env(vault.deposit({.depositor = alice, .id = keylet.key, .amount = asset(50)}));
646 auto [tx,
keylet] = vault.create({.owner = alice, .asset = iouAsset});
651 return {iouAsset,
keylet.key, le->at(sfAccount)};
654 return {iouAsset,
keylet.key, evan.
id()};
657 auto const aliceOriginalCount = env.
ownerCount(alice);
660 for (
auto const& vault : vaults)
665 auto const accountInfo = env.
rpc(
"account_info", pseudoStr);
666 if (BEAST_EXPECT(accountInfo.isObject()))
668 auto const& accountData = accountInfo[jss::result][jss::account_data];
669 if (BEAST_EXPECT(accountData.isObject()))
671 BEAST_EXPECT(accountData[jss::Account] == pseudoStr);
672 BEAST_EXPECT(accountData[sfVaultID] ==
to_string(vault.vaultID));
674 auto const& pseudoInfo = accountInfo[jss::result][jss::pseudo_account];
675 if (BEAST_EXPECT(pseudoInfo.isObject()))
677 BEAST_EXPECT(pseudoInfo[jss::type] ==
"Vault");
697 env(
set(evan, vault.vaultID),
701 env(
set(evan, vault.vaultID),
705 env(
set(evan, vault.vaultID),
709 env(
set(evan, vault.vaultID),
714 env(
set(evan, vault.vaultID),
719 env(
set(evan, vault.vaultID),
724 env(
set(evan, vault.vaultID),
731 env(
set(evan, vault.vaultID),
732 kCoverRateMinimum(tenthBipsZero),
738 env(
set(evan, vault.vaultID),
740 kCoverRateLiquidation(tenthBipsZero),
763 BEAST_EXPECT(!broker->isFieldPresent(sfManagementFeeRate));
764 BEAST_EXPECT(!broker->isFieldPresent(sfCoverRateMinimum));
765 BEAST_EXPECT(!broker->isFieldPresent(sfCoverRateLiquidation));
766 BEAST_EXPECT(!broker->isFieldPresent(sfData));
767 BEAST_EXPECT(!broker->isFieldPresent(sfDebtMaximum));
768 BEAST_EXPECT(broker->at(sfDebtMaximum) == 0);
769 BEAST_EXPECT(broker->at(sfCoverRateMinimum) == 0);
770 BEAST_EXPECT(broker->at(sfCoverRateLiquidation) == 0);
772 BEAST_EXPECT(env.
ownerCount(alice) == aliceOriginalCount + 4);
778 auto const nextKeylet =
787 env(
set(evan, vault.vaultID),
788 kLoanBrokerId(broker->key()),
791 env(
set(alice, vault.vaultID),
792 kLoanBrokerId(broker->key()),
796 env(
set(alice, vault.vaultID),
797 kLoanBrokerId(broker->key()),
801 env(
set(alice, vault.vaultID),
802 kLoanBrokerId(broker->key()),
807 testData =
"Test Data 1234";
809 env(
set(alice, vault.vaultID),
810 kLoanBrokerId(broker->key()),
815 env(
set(alice, vault.vaultID),
816 kLoanBrokerId(broker->key()),
817 kDebtMaximum(
Number(-175, -1)),
820 if (vault.asset.integral())
822 env(
set(alice, vault.vaultID),
823 kLoanBrokerId(broker->key()),
825 kDebtMaximum(debtMax),
830 env(
set(alice, vault.vaultID),
831 kLoanBrokerId(broker->key()),
833 kDebtMaximum(debtMax));
837 BEAST_EXPECT(
checkVL(broker->at(sfData), testData));
839 auto const actual = broker->at(sfDebtMaximum);
846 "non-default fields",
855 testData =
"spam spam spam spam";
868 BEAST_EXPECT(broker->at(sfManagementFeeRate) == 123);
869 BEAST_EXPECT(broker->at(sfCoverRateMinimum) == 100);
870 BEAST_EXPECT(broker->at(sfCoverRateLiquidation) == 200);
871 BEAST_EXPECT(broker->at(sfDebtMaximum) ==
Number(9));
872 BEAST_EXPECT(
checkVL(broker->at(sfData), testData));
876 env(
set(alice, vault.vaultID),
877 kLoanBrokerId(broker->key()),
883 BEAST_EXPECT(!broker->isFieldPresent(sfData));
884 BEAST_EXPECT(!broker->isFieldPresent(sfDebtMaximum));
888 BEAST_EXPECT(env.
ownerCount(alice) == aliceOriginalCount);
901 Account const issuer{
"issuer"};
904 Vault const vault{env};
906 env.
fund(
XRP(100'000), issuer, alice);
911 return getAsset(env, issuer, alice);
912 env(
trust(alice, issuer[
"IOU"](1'000'000)));
917 env(
pay(issuer, alice, asset(100'000)));
920 auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
923 auto const le = env.
le(vaultKeylet);
925 if (BEAST_EXPECT(le))
926 return VaultInfo{asset, vaultKeylet.key, le->at(sfAccount)};
932 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(50)}));
935 auto const brokerKeylet =
940 auto const broker = env.
le(brokerKeylet);
941 if (!BEAST_EXPECT(broker))
944 auto const testZeroBrokerID = [&](
auto&& getTxJv) {
947 jv[sfLoanBrokerID] =
"";
955 auto const testZeroVaultID = [&](
auto&& getTxJv) {
970 testZeroBrokerID([&] {
return coverDeposit(alice, brokerKeylet.key, asset(10)); });
973 env(coverDeposit(alice, brokerKeylet.key, issuer[
"BAD"](10)),
Ter(
tecWRONG_ASSET));
976 env(
pay(alice, issuer, asset(100'000 - 50)));
978 env(coverDeposit(alice, brokerKeylet.key, vaultInfo.
asset(10)),
985 env(coverDeposit(alice, brokerKeylet.key, vaultInfo.
asset(10)));
992 testZeroBrokerID([&] {
return coverWithdraw(alice, brokerKeylet.key, asset(10)); });
995 env(coverWithdraw(alice, brokerKeylet.key, issuer[
"BAD"](10)),
Ter(
tecWRONG_ASSET));
999 env(coverWithdraw(alice, brokerKeylet.key, asset(10)),
1000 kDestination(bogus),
1005 env.fund(
XRP(1'000), dest);
1007 env(
fset(dest, asfRequireDest));
1008 env(coverWithdraw(alice, brokerKeylet.key, asset(10)),
1011 env(
fclear(dest, asfRequireDest));
1014 env(
fset(dest, asfDepositAuth));
1015 env(coverWithdraw(alice, brokerKeylet.key, asset(10)),
1018 env(
fclear(dest, asfDepositAuth));
1022 env(coverWithdraw(alice, brokerKeylet.key, asset(10)),
1030 testZeroBrokerID([&] {
1032 coverClawback(alice),
1033 kLoanBrokerId(brokerKeylet.key),
1040 env(coverClawback(issuer),
1041 kLoanBrokerId(brokerKeylet.key),
1046 env(
fset(issuer, asfAllowTrustLineClawback | asfNoFreeze));
1048 env(coverClawback(issuer),
1049 kLoanBrokerId(brokerKeylet.key),
1056 env(coverClawback(issuer),
1057 kLoanBrokerId(brokerKeylet.key),
1066 Account const borrower{
"borrower"};
1067 env.
fund(
XRP(1'000), borrower);
1068 env(
loan::set(borrower, brokerKeylet.key, asset(50).value()),
1069 Sig(sfCounterpartySignature, alice),
1073 testZeroBrokerID([&] {
return del(alice, brokerKeylet.key); });
1080 env(
loan::pay(borrower, loanKeylet.key, asset(50).value()));
1083 env(
trust(issuer, asset(0), alice, tfSetFreeze | tfSetDeepFreeze));
1086 env(
trust(issuer, asset(0), alice, tfClearFreeze | tfClearDeepFreeze));
1093 env(del(alice, brokerKeylet.key));
1099 testZeroBrokerID([&] {
1100 return env.
json(
set(alice, vaultInfo.
vaultID), kLoanBrokerId(brokerKeylet.key));
1103 testZeroVaultID([&] {
1104 return env.
json(
set(alice, vaultInfo.
vaultID), kLoanBrokerId(brokerKeylet.key));
1109 env(
fclear(issuer, asfDefaultRipple));
1114 env(
fset(issuer, asfDefaultRipple));
1120 env(
pay(alice, issuer, amt));
1130 testcase(
"Invalid LoanBrokerCoverClawback");
1131 using namespace jtx;
1137 Account const issuer{
"issuer"};
1138 auto const usd = alice[
"USD"];
1140 env.
fund(
XRP(100'000), alice);
1143 auto jtx = env.
jt(coverClawback(alice),
kAmount(usd(100)));
1150 jtx.jv[sfAmount] = bad.getJson();
1154 auto const jrr = env.
rpc(
"submit",
strHex(s.
slice()))[jss::result];
1156 BEAST_EXPECT(jrr[jss::error] ==
"invalidTransaction");
1157 BEAST_EXPECT(!jrr.isMember(jss::error_code));
1158 BEAST_EXPECT(jrr[jss::error_message].isNull());
1159 BEAST_EXPECT(jrr[jss::error_exception] ==
"invalid native account");
1172 MPTTester const mpt({.env = env, .issuer = issuer, .holders = {alice}});
1181 testcase(
"Invalid LoanBrokerCoverDeposit");
1182 using namespace jtx;
1192 testcase(
"Invalid LoanBrokerCoverWithdraw");
1193 using namespace jtx;
1211 using namespace jtx;
1212 testcase(
"Invalid LoanBrokerDelete");
1225 using namespace jtx;
1243 using namespace jtx;
1252 Vault const vault{env};
1253 auto const [
createTx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
1258 auto const brokerKeylet =
1266 STTx tx{ttLOAN_BROKER_COVER_DEPOSIT, [](
STObject&) {}};
1280 auto const vaultID = (*sleBroker)[sfVaultID];
1296 testcase(
"Require Auth - Implicit Pseudo-account authorization");
1297 using namespace jtx;
1300 Account const issuer{
"issuer"};
1305 env.
fund(
XRP(100'000), issuer, alice);
1312 .flags =
kMptDexFlags | tfMPTRequireAuth | tfMPTCanClawback | tfMPTCanLock,
1316 env(
pay(issuer, alice, asset(100'000)));
1320 asset.authorize({.account = issuer, .holder = alice, .flags = tfMPTUnauthorize});
1321 auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
1325 auto const le = env.
le(vaultKeylet);
1327 if (BEAST_EXPECT(le))
1328 return VaultInfo{asset, vaultKeylet.key, le->at(sfAccount)};
1338 .flags = tfMPTUnauthorize,
1342 auto const forUnauthAuth = [&](
auto&& doTx) {
1343 for (
auto const flag : {tfMPTUnauthorize, 0u})
1345 asset.authorize({.account = issuer, .holder = alice, .flags = flag});
1355 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(51)}),
1362 env(vault.withdraw({.depositor = alice, .id = vaultKeylet.key, .amount = asset(1)}),
1366 auto const brokerKeylet =
1369 forUnauthAuth([&](
auto) { env(
set(alice, vaultInfo.
vaultID)); });
1371 auto const broker = env.
le(brokerKeylet);
1372 if (!BEAST_EXPECT(broker))
1374 Account const brokerPseudo(
"pseudo", broker->at(sfAccount));
1379 .holder = brokerPseudo,
1380 .flags = tfMPTUnauthorize,
1387 env(coverDeposit(alice, brokerKeylet.key, vaultInfo.
asset(10)), err);
1393 env(coverWithdraw(alice, brokerKeylet.key, vaultInfo.
asset(5)), err);
1397 forUnauthAuth([&](
bool) {
1398 env(coverClawback(issuer),
1399 kLoanBrokerId(brokerKeylet.key),
1407 testcase(
"testLoanBrokerSetDebtMaximum");
1408 using namespace jtx;
1410 Account const issuer{
"issuer"};
1413 Vault const vault{env};
1415 env.
fund(
XRP(100'000), issuer, alice);
1420 mptt.
create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
1428 env(
pay(issuer, alice, asset(100'000)));
1431 auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
1434 auto const le = env.
le(vaultKeylet);
1436 if (BEAST_EXPECT(le))
1437 return VaultInfo{asset, vaultKeylet.key, le->at(sfAccount)};
1443 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(50)}));
1446 auto const brokerKeylet =
1451 Account const borrower{
"borrower"};
1452 env.
fund(
XRP(1'000), borrower);
1453 env(
loan::set(borrower, brokerKeylet.key, asset(50).value()),
1454 Sig(sfCounterpartySignature, alice),
1456 auto const broker = env.
le(brokerKeylet);
1457 if (!BEAST_EXPECT(broker))
1460 BEAST_EXPECT(broker->at(sfDebtTotal) == 50);
1461 auto const debtTotal = broker->at(sfDebtTotal);
1464 tx2[sfLoanBrokerID] =
to_string(brokerKeylet.key);
1465 tx2[sfDebtMaximum] = debtTotal - 1;
1468 tx2[sfDebtMaximum] = debtTotal + 1;
1471 tx2[sfDebtMaximum] = 0;
1478 auto const dm =
power(2, 64) - 1;
1480 tx2[sfDebtMaximum] = dm;
1487 tx2[sfDebtMaximum] =
"9223372036854775808";
1496 "invalidParamsField 'tx_json.DebtMaximum' has invalid data.");
1504 auto const dm =
power(2, 63);
1506 tx2[sfDebtMaximum] = dm;
1513 tx2[sfDebtMaximum] = dm;
1518 auto const dm =
power(2, 63) - 1;
1520 tx2[sfDebtMaximum] = dm;
1525 auto const dm =
power(2, 63) - 3;
1527 tx2[sfDebtMaximum] = dm;
1532 auto const dm =
power(2, 63) + 3;
1534 tx2[sfDebtMaximum] = dm;
1543 auto const dm =
power(2, 63) - 1;
1545 tx2[sfDebtMaximum] = dm;
1550 auto const dm =
power(2, 63) - 3;
1552 tx2[sfDebtMaximum] = dm;
1558 auto const dm = 2 * (
power(2, 62) - 1) + 1;
1560 tx2[sfDebtMaximum] = dm;
1564 tx2[sfDebtMaximum] =
Number{9223372036854775807, 0};
1572 using namespace jtx;
1573 Account const issuer(
"issuer");
1574 Account const holder(
"holder");
1575 Account const& broker = issuer;
1577 auto const test = [&](
auto&& getToken) {
1580 env.
fund(
XRP(1'000), issuer, holder);
1585 Vault const vault(env);
1586 auto const [tx,
keylet] = vault.create({.owner = broker, .asset =
token.asset()});
1590 env(vault.deposit({.depositor = broker, .id = keylet.key, .amount = deposit}),
1594 auto const brokerKeylet =
1606 auto const token = issuer[
"IOU"];
1631 for (
auto const& [
pay, max,
deposit, err] : mptTests)
1637 .holders = {holder},
1650 testcase <<
"RIPD-4466 - LoanBrokerSet disallows frozen vaults";
1651 using namespace jtx;
1654 Account const issuer{
"issuer"}, lender{
"lender"}, borrower{
"borrower"};
1655 env.
fund(
XRP(20'000), issuer, lender, borrower);
1656 auto const iou = issuer[
"IOU"];
1658 Vault const vault{env};
1659 auto [tx, vaultKeylet] = vault.create({.owner = lender, .asset = iou.asset()});
1664 auto const vaultSle = env.
le(vaultKeylet);
1665 auto const vaultPseudo = vaultSle->at(sfAccount);
1666 auto const vaultPseudoAcct =
Account(
"VaultPseudo", vaultPseudo);
1667 env(
trust(issuer, vaultPseudoAcct[
"IOU"](0), tfSetFreeze));
1675 testcase <<
"LoanBrokerDelete - locked broker pseudo-account MPT";
1676 using namespace jtx;
1679 Account const issuer(
"issuer");
1682 auto const withFix = features[fixCleanup3_2_0];
1683 Env env(*
this, features);
1684 env.
fund(
XRP(100'000), issuer, alice);
1689 mptt.
create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
1696 env(
pay(issuer, alice, mpt(100'000)));
1700 Vault const vault{env};
1701 auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = mpt});
1706 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = mpt(10'000)}));
1710 auto const brokerKeylet =
1712 env(
set(alice, vaultKeylet.key));
1716 env(coverDeposit(alice, brokerKeylet.key, mpt(5'000).value()));
1720 auto const broker = env.
le(brokerKeylet);
1721 if (!BEAST_EXPECT(broker))
1723 BEAST_EXPECT(broker->at(sfCoverAvailable) > 0);
1726 auto const brokerPseudoID = broker->at(sfAccount);
1730 auto const pseudoMpt = env.
le(pseudoMptKey);
1731 if (!BEAST_EXPECT(pseudoMpt))
1737 jv[jss::Account] = issuer.
human();
1739 jv[jss::Holder] =
toBase58(brokerPseudoID);
1740 jv[jss::TransactionType] = jss::MPTokenIssuanceSet;
1741 jv[jss::Flags] = tfMPTLock;
1748 auto const sle = env.
le(pseudoMptKey);
1749 if (!BEAST_EXPECT(sle))
1751 BEAST_EXPECT(sle->isFlag(lsfMPTLocked));
1755 auto const aliceBalanceBefore = env.
balance(alice, mpt);
1767 BEAST_EXPECT(env.
le(brokerKeylet) !=
nullptr);
1770 auto const aliceBalanceAfter = env.
balance(alice, mpt);
1771 BEAST_EXPECT(aliceBalanceAfter == aliceBalanceBefore);
1774 BEAST_EXPECT(env.
le(pseudoMptKey) !=
nullptr);
1782 BEAST_EXPECT(env.
le(brokerKeylet) ==
nullptr);
1785 auto const aliceBalanceAfter = env.
balance(alice, mpt);
1786 BEAST_EXPECT(aliceBalanceAfter > aliceBalanceBefore);
1789 BEAST_EXPECT(env.
le(pseudoMptKey) ==
nullptr);
1800 testcase <<
"LoanBrokerDelete - unrelated confidential holder";
1801 using namespace jtx;
1804 auto const withFix = features[fixCleanup3_5_0];
1806 Account const issuer(
"issuer");
1812 for (
bool const carolConverts : {
false,
true})
1814 Env env(*
this, features);
1815 env.
fund(
XRP(100'000), issuer, alice, carol);
1819 mptt.
create({.flags = tfMPTCanTransfer | tfMPTCanHoldConfidentialBalance});
1825 env(
pay(issuer, alice, mpt(100'000)));
1826 env(
pay(issuer, carol, mpt(100)));
1832 mptt.
set({.account = issuer, .issuerPubKey = mptt.
getPubKey(issuer)});
1834 Vault const vault{env};
1835 auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = mpt});
1839 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = mpt(10'000)}));
1842 auto const brokerKeylet =
1844 env(
set(alice, vaultKeylet.key));
1847 env(coverDeposit(alice, brokerKeylet.key, mpt(5'000).value()));
1850 auto const broker = env.
le(brokerKeylet);
1851 if (!BEAST_EXPECT(broker))
1853 BEAST_EXPECT(broker->at(sfCoverAvailable) > 0);
1855 auto const brokerPseudoID = broker->at(sfAccount);
1857 if (!BEAST_EXPECT(env.
le(pseudoMptKey)))
1863 Account const brokerHolder(
"broker", brokerPseudoID);
1875 mptt.
convert({.account = carol, .amt = 1, .holderPubKey = mptt.
getPubKey(carol)});
1880 if (carolConverts && !withFix)
1886 BEAST_EXPECT(env.
le(brokerKeylet) !=
nullptr);
1887 BEAST_EXPECT(env.
le(pseudoMptKey) !=
nullptr);
1892 env(coverWithdraw(alice, brokerKeylet.key, mpt(5'000).value()));
1899 env(del(alice, brokerKeylet.key));
1901 BEAST_EXPECT(env.
le(brokerKeylet) ==
nullptr);
1902 BEAST_EXPECT(env.
le(pseudoMptKey) ==
nullptr);
1915 using namespace jtx;
1918 Vault const vault{env};
1919 auto const [tx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
1922 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(10'000)}));
1925 auto const brokerKeylet =
1927 env(
set(alice, vaultKeylet.key));
1932 env(coverDeposit(alice, brokerKeylet.key, asset(cover).value()));
1935 return brokerKeylet;
1945 int incrementsShort)
1947 using namespace jtx;
1949 auto const fee = env.
current()->fees().base;
1954 if (incrementsShort > 0)
1955 env(
noop(alice),
Fee(env.
current()->fees().increment * incrementsShort));
1974 {
"Cleanup3.5 and Cleanup3.4", features, expected.
both},
1975 {
"Cleanup3.4 only", features - fixCleanup3_5_0, expected.
only34},
1976 {
"Cleanup3.5 only", features - fixCleanup3_4_0, expected.
only35},
1978 "neither Cleanup3.5 nor Cleanup3.4",
1979 features - fixCleanup3_5_0 - fixCleanup3_4_0,
1993 Keylet const& brokerKeylet,
1996 using namespace jtx;
1998 auto const broker = env.
le(brokerKeylet);
1999 if (!BEAST_EXPECT(broker))
2001 STAmount const cover{asset.
raw(), broker->at(sfCoverAvailable)};
2003 auto const ownerCountBefore = env.
ownerCount(alice);
2011 BEAST_EXPECT(!env.
le(brokerKeylet));
2012 BEAST_EXPECT(env.
balance(alice, asset) == balanceBefore + cover);
2013 bool const createsHolding = !hadHolding && cover !=
beast::kZero;
2017 BEAST_EXPECT(env.
ownerCount(alice) == ownerCountBefore - 2 + (createsHolding ? 1 : 0));
2021 BEAST_EXPECT(env.
le(brokerKeylet));
2022 BEAST_EXPECT(env.
balance(alice, asset) == balanceBefore);
2024 BEAST_EXPECT(env.
ownerCount(alice) == ownerCountBefore);
2031 testcase <<
"LoanBrokerDelete - frozen broker pseudo-account IOU";
2032 using namespace jtx;
2035 Account const issuer(
"issuer");
2038 auto const withFix = features[fixCleanup3_2_0];
2041 env.
fund(
XRP(100'000), issuer, alice);
2044 auto const iou = issuer[
"IOU"];
2047 env(
trust(alice, iou(1'000'000)));
2049 env(
pay(issuer, alice, iou(100'000)));
2052 auto const brokerKeylet =
createBroker(env, alice, iou, 5'000);
2055 auto const broker = env.
le(brokerKeylet);
2056 if (!BEAST_EXPECT(broker))
2058 BEAST_EXPECT(broker->at(sfCoverAvailable) > 0);
2061 auto const brokerPseudoID = broker->at(sfAccount);
2062 auto const brokerPseudo =
Account(
"BrokerPseudo", brokerPseudoID);
2065 env(
trust(issuer, brokerPseudo[
"IOU"](0), tfSetFreeze));
2069 auto const aliceBalanceBefore = env.
balance(alice, iou);
2089 BEAST_EXPECT(env.
le(brokerKeylet) !=
nullptr);
2092 auto const aliceBalanceAfter = env.
balance(alice, iou);
2093 BEAST_EXPECT(aliceBalanceAfter == aliceBalanceBefore);
2101 using namespace jtx;
2103 Account const issuer{
"issuer"};
2105 auto const iou = issuer[
"IOU"];
2113 IssuerStep setupIssuer = {};
2114 Step beforeCover = {};
2115 Step beforeDelete = {};
2117 Step afterDelete = {};
2120 auto const defaultRipple = [&](
Env& env) {
2121 env(
fset(issuer, asfDefaultRipple));
2126 env(
fset(issuer, asfRequireAuth));
2128 env(
trust(issuer, iou(0), alice, tfSetfAuth));
2134 auto const deleteOwnerLine = [&](
Env& env,
Keylet const&) {
2135 env(
trust(alice, iou(0)));
2142 .name =
"non-rippling owner line",
2146 Account const brokerPseudo{
"BrokerPseudo", env.
le(broker)->at(sfAccount)};
2147 env(
trust(issuer, brokerPseudo[
"IOU"](0), tfSetNoRipple));
2152 env(
trust(issuer, alice[
"IOU"](0), tfSetNoRipple));
2164 .name =
"owner line deleted",
2165 .setupIssuer = defaultRipple,
2168 deleteOwnerLine(env, broker);
2169 env(
fset(alice, asfDefaultRipple));
2184 if (!BEAST_EXPECT(line))
2186 auto const noRipple =
2187 alice.
id() > issuer.
id() ? lsfHighNoRipple : lsfLowNoRipple;
2189 line->isFlag(noRipple) ==
2190 env.
current()->rules().enabled(fixCleanup3_5_0));
2194 .name =
"owner line deleted, issuer clears DefaultRipple",
2195 .setupIssuer = defaultRipple,
2198 deleteOwnerLine(env, broker);
2199 env(
fclear(issuer, asfDefaultRipple));
2212 .name =
"issuer clears DefaultRipple",
2213 .setupIssuer = defaultRipple,
2216 env(
fclear(issuer, asfDefaultRipple));
2228 .name =
"owner line deleted, owner below reserve",
2229 .setupIssuer = defaultRipple,
2232 deleteOwnerLine(env, broker);
2245 .name =
"owner line deleted, issuer requires auth",
2247 .beforeDelete = deleteOwnerLine,
2258 .name =
"owner line recreated unauthorized",
2262 deleteOwnerLine(env, broker);
2263 env(
trust(alice, iou(10'000)));
2266 if (BEAST_EXPECT(line))
2269 !line->isFlag(alice.
id() > issuer.
id() ? lsfLowAuth : lsfHighAuth));
2282 .name =
"zero cover, owner line deleted",
2283 .setupIssuer = defaultRipple,
2287 env(
pay(alice, issuer, iou(5'000)));
2289 deleteOwnerLine(env, broker);
2301 for (
auto const& c : cases)
2303 for (
auto const& [amendments, features, expected] :
cleanupRuns(
all_, c.expected))
2305 testcase <<
"LoanBrokerDelete - IOU " << c.name <<
", " << amendments;
2307 Env env(*
this, features);
2308 env.
fund(
XRP(100'000), issuer, alice);
2313 env(
trust(alice, iou(15'000)));
2315 env(
pay(issuer, alice, iou(15'000)));
2320 c.beforeCover(env, broker);
2326 c.beforeDelete(env, broker);
2329 c.afterDelete(env, broker);
2337 testcase <<
"LoanBrokerDelete - auth-required broker pseudo-account MPT "
2338 << (features[fixCleanup3_4_0] ?
"post-fix" :
"pre-fix");
2339 using namespace jtx;
2342 Account const issuer(
"issuer");
2345 Env env(*
this, features);
2346 env.
fund(
XRP(100'000), issuer, alice);
2359 .flags = tfMPTRequireAuth | tfMPTCanTransfer,
2365 auto const brokerKeylet =
createBroker(env, alice, mpt, 5'000);
2368 auto const broker = env.
le(brokerKeylet);
2369 if (!BEAST_EXPECT(broker))
2371 BEAST_EXPECT(broker->at(sfCoverAvailable) > 0);
2374 auto const brokerPseudoID = broker->at(sfAccount);
2379 auto const pseudoMptKey =
keylet::mptoken(tester.issuanceID(), brokerPseudoID);
2380 auto const pseudoMpt = env.
le(pseudoMptKey);
2381 if (!BEAST_EXPECT(pseudoMpt))
2383 BEAST_EXPECT(!pseudoMpt->isFlag(lsfMPTAuthorized));
2386 auto const aliceBalanceBefore = env.
balance(alice, mpt);
2399 BEAST_EXPECT(env.
le(brokerKeylet) ==
nullptr);
2400 BEAST_EXPECT(env.
le(pseudoMptKey) ==
nullptr);
2403 auto const aliceBalanceAfter = env.
balance(alice, mpt);
2404 BEAST_EXPECT(aliceBalanceAfter > aliceBalanceBefore);
2412 using namespace jtx;
2414 Account const issuer(
"issuer");
2427 mpt.authorize({.account = issuer, .holder = alice, .flags = tfMPTUnauthorize});
2431 mpt.authorize({.account = alice, .flags = tfMPTUnauthorize});
2435 auto const withdrawCoverAndDeleteMPToken =
2439 env(
pay(alice, issuer, asset(5'000)));
2441 deleteOwnerMPToken(env, mpt, broker);
2448 .name =
"owner unauthorized",
2449 .flags = tfMPTRequireAuth | tfMPTCanTransfer,
2450 .beforeDelete = unauthorizeOwner,
2461 .name =
"owner unauthorized, zero cover",
2462 .flags = tfMPTRequireAuth | tfMPTCanTransfer | tfMPTCanClawback,
2465 unauthorizeOwner(env, mpt, broker);
2470 BEAST_EXPECT(env.
le(broker)->at(sfCoverAvailable) ==
beast::kZero);
2483 .name =
"owner MPToken deleted",
2484 .beforeDelete = deleteOwnerMPToken,
2496 .name =
"owner MPToken deleted, owner at reserve",
2499 deleteOwnerMPToken(env, mpt, broker);
2511 .name =
"owner MPToken deleted, owner below reserve",
2514 deleteOwnerMPToken(env, mpt, broker);
2528 .name =
"zero cover, owner MPToken deleted",
2529 .beforeDelete = withdrawCoverAndDeleteMPToken,
2540 .name =
"zero cover, owner MPToken deleted, owner below reserve",
2543 withdrawCoverAndDeleteMPToken(env, mpt, broker);
2559 auto const features =
all_ - featureMPTokensV2;
2561 for (
auto const& c : cases)
2563 for (
auto const& [amendments, runFeatures, expected] :
2566 testcase <<
"LoanBrokerDelete - MPT " << c.name <<
", " << amendments;
2571 env.
fund(
XRP(100'000), issuer, alice);
2580 .authHolder = (c.flags & tfMPTRequireAuth) != 0,
2584 auto const broker =
createBroker(env, alice, asset, 5'000);
2585 c.beforeDelete(env, mpt, broker);
2594 using namespace jtx;
2597 Account const issuer{
"issuer"};
2602 testcase(
"LoanBrokerCoverDeposit IOU freeze checks");
2604 Vault const vault{env};
2606 env.
fund(
XRP(100'000), issuer, alice);
2607 env(
trust(alice, issuer[
"IOU"](1'000'000)));
2610 env(
pay(issuer, alice, asset(100'000)));
2613 auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
2615 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(50)}));
2618 auto const brokerKeylet =
2620 env(
set(alice, vaultKeylet.key));
2623 auto const broker = env.
le(brokerKeylet);
2624 if (!BEAST_EXPECT(broker))
2626 Account const brokerPseudo(
"pseudo", broker->at(sfAccount));
2628 env(coverDeposit(alice, brokerKeylet.key, asset(10)));
2631 auto const runTests = [&] {
2632 auto const fix330Enabled = env.
current()->rules().enabled(fixCleanup3_3_0);
2635 env(
fset(issuer, asfGlobalFreeze));
2636 env(coverDeposit(alice, brokerKeylet.key, asset(1)),
Ter(
tecFROZEN));
2637 env(
fclear(issuer, asfGlobalFreeze));
2640 env(
trust(issuer, asset(0), alice, tfSetFreeze));
2641 env(coverDeposit(alice, brokerKeylet.key, asset(1)),
Ter(
tecFROZEN));
2642 env(
trust(issuer, asset(0), alice, tfClearFreeze));
2645 env(
trust(issuer, asset(0), alice, tfSetFreeze | tfSetDeepFreeze));
2646 env(coverDeposit(alice, brokerKeylet.key, asset(1)),
Ter(
tecFROZEN));
2647 env(
trust(issuer, asset(0), alice, tfClearFreeze | tfClearDeepFreeze));
2651 env(
trust(issuer, asset(0), brokerPseudo, tfSetFreeze));
2652 env(coverDeposit(alice, brokerKeylet.key, asset(1)),
Ter(pseudoTer));
2653 env(
trust(issuer, asset(0), brokerPseudo, tfClearFreeze));
2656 env(
trust(issuer, asset(0), brokerPseudo, tfSetFreeze | tfSetDeepFreeze));
2657 env(coverDeposit(alice, brokerKeylet.key, asset(1)),
Ter(
tecFROZEN));
2658 env(
trust(issuer, asset(0), brokerPseudo, tfClearFreeze | tfClearDeepFreeze));
2669 testcase(
"LoanBrokerCoverDeposit MPT lock checks");
2671 Vault const vault{env};
2673 env.
fund(
XRP(100'000), issuer, alice);
2677 mptt.
create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
2681 env(
pay(issuer, alice, mpt(100'000)));
2684 auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = mpt});
2686 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = mpt(50)}));
2689 auto const brokerKeylet =
2691 env(
set(alice, vaultKeylet.key));
2694 auto const broker = env.
le(brokerKeylet);
2695 if (!BEAST_EXPECT(broker))
2697 Account const brokerPseudo(
"pseudo", broker->at(sfAccount));
2699 env(coverDeposit(alice, brokerKeylet.key, mpt(10)));
2704 auto const runTests = [&] {
2706 mptt.
set({.flags = tfMPTLock});
2708 env(coverDeposit(alice, brokerKeylet.key, mpt(1)),
Ter(
tecLOCKED));
2709 mptt.
set({.flags = tfMPTUnlock});
2713 mptt.
set({.holder = alice, .flags = tfMPTLock});
2715 env(coverDeposit(alice, brokerKeylet.key, mpt(1)),
Ter(
tecLOCKED));
2716 mptt.
set({.holder = alice, .flags = tfMPTUnlock});
2720 mptt.
set({.holder = brokerPseudo, .flags = tfMPTLock});
2722 env(coverDeposit(alice, brokerKeylet.key, mpt(1)),
Ter(
tecLOCKED));
2723 mptt.
set({.holder = brokerPseudo, .flags = tfMPTUnlock});
2745 testcase(
"LoanBrokerCoverWithdraw IOU self-withdrawal while individually frozen");
2747 using namespace jtx;
2750 Account const issuer{
"issuer"};
2754 Vault const vault{env};
2756 env.
fund(
XRP(100'000), issuer, alice, dest);
2757 env(
trust(alice, issuer[
"IOU"](1'000'000)));
2758 env(
trust(dest, issuer[
"IOU"](1'000'000)));
2762 env(
pay(issuer, alice, asset(100'000)));
2765 auto [vaultTx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
2767 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(50)}));
2770 auto const brokerKeylet =
2772 env(
set(alice, vaultKeylet.key));
2775 env(coverDeposit(alice, brokerKeylet.key, asset(10)));
2778 auto const runTests = [&] {
2779 auto const fix330Enabled = env.
current()->rules().enabled(fixCleanup3_3_0);
2782 env(
trust(issuer, asset(0), alice, tfSetFreeze));
2789 env(coverWithdraw(alice, brokerKeylet.key, asset(1)),
Ter(
tesSUCCESS));
2793 env(coverWithdraw(alice, brokerKeylet.key, asset(1)),
2797 env(
trust(issuer, asset(0), alice, tfClearFreeze));
2810 using namespace jtx;
2813 Account const issuer{
"issuer"};
2818 testcase(
"LoanBrokerCoverWithdraw IOU freeze checks");
2820 Vault const vault{env};
2822 env.
fund(
XRP(100'000), issuer, alice);
2823 env(
trust(alice, issuer[
"IOU"](1'000'000)));
2826 env(
pay(issuer, alice, asset(100'000)));
2829 auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
2831 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(50)}));
2834 auto const brokerKeylet =
2836 env(
set(alice, vaultKeylet.key));
2839 auto const broker = env.
le(brokerKeylet);
2840 if (!BEAST_EXPECT(broker))
2842 Account const brokerPseudo(
"pseudo", broker->at(sfAccount));
2844 env(coverDeposit(alice, brokerKeylet.key, asset(10)));
2849 env(
trust(dest, asset(1'000)));
2851 auto const runTests = [&] {
2852 auto const fix330Enabled = env.
current()->rules().enabled(fixCleanup3_3_0);
2856 env(
fset(issuer, asfGlobalFreeze));
2857 env(coverWithdraw(alice, brokerKeylet.key, asset(1)),
2860 env(
fclear(issuer, asfGlobalFreeze));
2863 env(
trust(issuer, asset(0), brokerPseudo, tfSetFreeze));
2864 env(coverWithdraw(alice, brokerKeylet.key, asset(1)),
2867 env(
trust(issuer, asset(0), brokerPseudo, tfClearFreeze));
2870 env(
trust(issuer, asset(0), brokerPseudo, tfSetFreeze | tfSetDeepFreeze));
2871 env(coverWithdraw(alice, brokerKeylet.key, asset(1)),
2874 env(
trust(issuer, asset(0), brokerPseudo, tfClearFreeze | tfClearDeepFreeze));
2877 env(
trust(issuer, asset(0), alice, tfSetFreeze));
2878 env(coverWithdraw(alice, brokerKeylet.key, asset(1)),
2882 env(coverWithdraw(alice, brokerKeylet.key, asset(1)),
Ter(
tesSUCCESS));
2883 env(
trust(issuer, asset(0), alice, tfClearFreeze));
2885 alice, brokerKeylet.key, asset(
isTesSuccess(expectedTec) ? 2 : 1)));
2888 env(
trust(issuer, asset(0), alice, tfSetFreeze | tfSetDeepFreeze));
2889 env(coverWithdraw(alice, brokerKeylet.key, asset(1)),
2893 env(coverWithdraw(alice, brokerKeylet.key, asset(1)),
Ter(
tecFROZEN));
2894 env(
trust(issuer, asset(0), alice, tfClearFreeze | tfClearDeepFreeze));
2896 env(coverDeposit(alice, brokerKeylet.key, asset(1)));
2899 env(
trust(issuer, asset(0), dest, tfSetFreeze));
2900 env(coverWithdraw(alice, brokerKeylet.key, asset(1)),
2903 env(
trust(issuer, asset(0), dest, tfClearFreeze));
2904 env(coverDeposit(alice, brokerKeylet.key, asset(1)));
2907 env(
trust(issuer, asset(0), dest, tfSetFreeze | tfSetDeepFreeze));
2908 env(coverWithdraw(alice, brokerKeylet.key, asset(1)),
2911 env(
trust(issuer, asset(0), dest, tfClearFreeze | tfClearDeepFreeze));
2914 env(
trust(issuer, asset(0), alice, tfSetFreeze));
2915 env(coverWithdraw(alice, brokerKeylet.key, asset(1)),
2916 kDestination(issuer),
2918 env(
trust(issuer, asset(0), alice, tfClearFreeze));
2919 env(coverDeposit(alice, brokerKeylet.key, asset(1)));
2930 testcase(
"LoanBrokerCoverWithdraw MPT lock checks");
2932 Vault const vault{env};
2934 env.
fund(
XRP(100'000), issuer, alice);
2938 mptt.
create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
2942 env(
pay(issuer, alice, mpt(100'000)));
2945 auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = mpt});
2947 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = mpt(50)}));
2950 auto const brokerKeylet =
2952 env(
set(alice, vaultKeylet.key));
2955 auto const broker = env.
le(brokerKeylet);
2956 if (!BEAST_EXPECT(broker))
2958 Account const brokerPseudo(
"pseudo", broker->at(sfAccount));
2960 env(coverDeposit(alice, brokerKeylet.key, mpt(10)));
2968 auto const runTests = [&] {
2969 auto const withFix = env.
current()->rules().enabled(fixCleanup3_3_0);
2976 mptt.
set({.flags = tfMPTLock});
2978 env(coverWithdraw(alice, brokerKeylet.key, mpt(1)),
2981 mptt.
set({.flags = tfMPTUnlock});
2985 mptt.
set({.holder = brokerPseudo, .flags = tfMPTLock});
2987 env(coverWithdraw(alice, brokerKeylet.key, mpt(1)),
2990 mptt.
set({.holder = brokerPseudo, .flags = tfMPTUnlock});
2994 mptt.
set({.holder = alice, .flags = tfMPTLock});
2996 env(coverWithdraw(alice, brokerKeylet.key, mpt(1)),
2998 Ter(submitterToDest));
3000 env(coverWithdraw(alice, brokerKeylet.key, mpt(1)),
Ter(
tecLOCKED));
3001 mptt.
set({.holder = alice, .flags = tfMPTUnlock});
3004 env(coverDeposit(alice, brokerKeylet.key, mpt(1)));
3008 mptt.
set({.holder = dest, .flags = tfMPTLock});
3010 env(coverWithdraw(alice, brokerKeylet.key, mpt(1)),
3013 mptt.
set({.holder = dest, .flags = tfMPTUnlock});
3017 mptt.
set({.holder = alice, .flags = tfMPTLock});
3019 env(coverWithdraw(alice, brokerKeylet.key, mpt(1)),
3020 kDestination(issuer),
3022 mptt.
set({.holder = alice, .flags = tfMPTUnlock});
3023 env(coverDeposit(alice, brokerKeylet.key, mpt(1)));
3037 using namespace jtx;
3038 Account const issuer(
"broker");
3039 Account const broker(
"issuer");
3040 Account const dest(
"destination");
3041 auto const token = issuer[
"IOU"];
3043 enum class TrustState {
3051 auto const test = [&](TrustState trustState) {
3054 testcase <<
"RIPD-4274 IOU with state: " <<
static_cast<int>(trustState);
3056 auto const setTrustLine = [&](
Account const& acct, TrustState state) {
3059 case TrustState::RequireAuth:
3060 env(
trust(issuer,
token(0), acct, tfSetfAuth));
3062 case TrustState::ZeroLimit: {
3066 jv[sfQualityIn] = 10'000'000;
3070 case TrustState::ReachedLimit: {
3072 env(
pay(issuer, acct,
token(1'000)));
3076 case TrustState::NearLimit: {
3078 env(
pay(issuer, acct,
token(950)));
3082 case TrustState::NoTrustLine:
3086 BEAST_EXPECT(
false);
3091 env.
fund(
XRP(1'000), issuer, broker, dest);
3094 if (trustState == TrustState::RequireAuth)
3096 env(
fset(issuer, asfRequireAuth));
3099 setTrustLine(broker, TrustState::RequireAuth);
3102 setTrustLine(dest, trustState);
3105 env(
pay(issuer, broker,
token(2'000)));
3108 Vault const vault(env);
3109 auto const [tx,
keylet] = vault.create({.owner = broker, .asset =
token.asset()});
3114 env(vault.deposit({.depositor = broker, .id = keylet.key, .amount = token(1'000)}));
3117 env(vault.withdraw({.depositor = broker, .id = keylet.key, .amount = token(1'000)}),
3123 env(vault.withdraw({.depositor = broker, .id = keylet.key, .amount = token(1'000)}));
3126 auto const brokerKeylet =
3142 if (trustState == TrustState::RequireAuth)
3144 env(
fclear(issuer, asfRequireAuth));
3155 test(TrustState::RequireAuth);
3156 test(TrustState::ZeroLimit);
3157 test(TrustState::ReachedLimit);
3158 test(TrustState::NearLimit);
3159 test(TrustState::NoTrustLine);
3165 using namespace jtx;
3166 Account const issuer(
"broker");
3167 Account const broker(
"issuer");
3168 Account const dest(
"destination");
3170 enum class MPTState {
3176 auto const test = [&](MPTState mptState) {
3179 testcase <<
"RIPD-4274 MPT with state: " <<
static_cast<int>(mptState);
3181 env.
fund(
XRP(1'000), issuer, broker, dest);
3187 case MPTState::RequireAuth: {
3191 .holders = {broker, dest},
3199 {.account = issuer, .holder = dest, .flags = tfMPTUnauthorize});
3202 case MPTState::ReachedMAX: {
3206 .holders = {broker, dest},
3211 BEAST_EXPECT(env.
balance(issuer, tester) == tester(-4'000));
3214 case MPTState::NoMPT: {
3218 .holders = {broker},
3225 return std::nullopt;
3228 if (!BEAST_EXPECT(maybeToken))
3231 auto const&
token = *maybeToken;
3233 Vault const vault(env);
3234 auto const [tx,
keylet] = vault.create({.owner = broker, .asset =
token.asset()});
3239 env(vault.deposit({.depositor = broker, .id = keylet.key, .amount = token(1'000)}));
3242 env(vault.withdraw({.depositor = broker, .id = keylet.key, .amount = token(1'000)}),
3248 BEAST_EXPECT(env.
ter() == err);
3254 {.depositor = broker, .id = keylet.key, .amount = token(1'000)}));
3258 auto const brokerKeylet =
3270 BEAST_EXPECT(env.
ter() == err);
3274 test(MPTState::RequireAuth);
3275 test(MPTState::ReachedMAX);
3276 test(MPTState::NoMPT);
3290 std::string{
"CoverWithdraw with credential-based deposit preauth "} +
3291 (features[fixCleanup3_4_0] ?
"post-fix" :
"pre-fix"));
3292 using namespace jtx;
3293 using namespace std::chrono_literals;
3295 bool const fix340Enabled = features[fixCleanup3_4_0];
3297 Env env(*
this, features);
3299 Account const broker{
"broker"};
3301 Account const credIssuer{
"credIssuer"};
3302 char const credType[] =
"abcde";
3304 env.
fund(
XRP(10'000), broker, dest, credIssuer);
3305 env(
fset(dest, asfDepositAuth));
3310 Vault const vault(env);
3311 auto const [vaultTx, vaultKeylet] = vault.create({.owner = broker, .asset = asset});
3315 env(vault.deposit({.depositor = broker, .id = vaultKeylet.key, .amount = asset(1'000)}));
3318 auto const brokerKeylet =
3326 auto const coverWithdrawToDest = [&] {
3337 env.
current()->header().parentCloseTime.time_since_epoch().count() + 100;
3338 jv[sfExpiration.jsonName] = expiration;
3344 auto const credIdx =
3359 env(coverWithdrawToDest(),
3373 "0E0B04ED60588A758B67E21FBBE95AC5A63598BA951761DC0EC9C08D7E01E034";
3374 env(coverWithdrawToDest(),
3381 env(coverWithdrawToDest(),
3388 char const credType2[] =
"fghij";
3392 auto const credIdx2 =
3395 env(coverWithdrawToDest(),
3403 BEAST_EXPECT(env.
le(credKeylet));
3404 env(coverWithdrawToDest(),
3409 BEAST_EXPECT(!env.
le(credKeylet));
3415 using namespace jtx;
3418 testcase(
"FixedPrecision LoanBroker cover and DebtMaximum grid");
3420 FeatureBitset const v12{
all_ | featureLendingProtocolV1_1 | featureLendingProtocolV1_2};
3421 Account const issuer{
"issuer"};
3423 Env env{*
this, v12};
3424 env.
fund(
XRP(100'000), issuer, alice);
3426 env(
fset(issuer, asfAllowTrustLineClawback));
3431 env(
pay(issuer, alice, iou(
Number{10, 9})));
3433 Vault const vault{env};
3434 [[maybe_unused]]
auto [
createTx, vaultKeylet, subscriptionDate] =
3435 vault.createClosedEnded({.owner = alice, .asset = iou});
3438 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = iou(100)}));
3439 vault.closePastSubscription(subscriptionDate);
3443 auto const brokerKeylet =
3445 env(
set(alice, vaultKeylet.key), kDebtMaximum(
Number{1, -6}));
3448 env(
set(alice, vaultKeylet.key),
3449 kLoanBrokerId(brokerKeylet.key),
3450 kDebtMaximum(
Number{15, -7}),
3452 env(
set(alice, vaultKeylet.key),
3453 kLoanBrokerId(brokerKeylet.key),
3454 kDebtMaximum(
Number{2, -6}));
3455 env(
set(alice, vaultKeylet.key),
3456 kLoanBrokerId(brokerKeylet.key),
3457 kDebtMaximum(
Number{1, -6}));
3459 auto const coverAvailable = [&] {
3460 auto const broker = env.
le(brokerKeylet);
3461 BEAST_EXPECT(broker);
3462 return broker ? broker->at(sfCoverAvailable) :
Number{0};
3464 auto const pseudoBalance = [&] {
3465 auto const broker = env.
le(brokerKeylet);
3466 BEAST_EXPECT(broker);
3475 Number const openLimit{9, 9};
3477 Number const coverBefore = coverAvailable();
3478 Number const aliceBefore = aliceBalance();
3479 Number const pseudoBefore = pseudoBalance();
3480 env(coverDeposit(alice, brokerKeylet.key, iou(
Number{18, -7})));
3481 Number const credited = coverAvailable() - coverBefore;
3482 BEAST_EXPECT(credited == (
Number{1, -6}));
3483 BEAST_EXPECT(aliceBefore - aliceBalance() == credited);
3484 BEAST_EXPECT(pseudoBalance() - pseudoBefore == credited);
3486 env(coverDeposit(alice, brokerKeylet.key, iou(openLimit -
Number{1, -6})));
3489 BEAST_EXPECT(coverAvailable() == openLimit);
3492 Number const coverBefore = coverAvailable();
3493 Number const aliceBefore = aliceBalance();
3494 Number const pseudoBefore = pseudoBalance();
3495 env(coverWithdraw(alice, brokerKeylet.key, iou(
Number{18, -7})));
3496 Number const debited = coverBefore - coverAvailable();
3497 BEAST_EXPECT((coverAvailable() == openLimit -
Number{1, -6}));
3498 BEAST_EXPECT(aliceBalance() - aliceBefore == debited);
3499 BEAST_EXPECT(pseudoBefore - pseudoBalance() == debited);
3510 Number const coverBefore = coverAvailable();
3511 env(coverWithdraw(alice, brokerKeylet.key, iou(
Number{18, -7})), kDestination(bob));
3512 BEAST_EXPECT(coverBefore - coverAvailable() == (
Number{1, -6}));
3515 env(coverDeposit(alice, brokerKeylet.key, iou(
Number{1, -6})));
3519 Number const coverBefore = coverAvailable();
3520 Number const pseudoBefore = pseudoBalance();
3521 env(coverClawback(issuer),
3522 kLoanBrokerId(brokerKeylet.key),
3524 Number const debited = coverBefore - coverAvailable();
3525 BEAST_EXPECT((coverAvailable() == openLimit -
Number{2, -6}));
3526 BEAST_EXPECT(pseudoBefore - pseudoBalance() == debited);
3530 env(coverClawback(issuer),
3531 kLoanBrokerId(brokerKeylet.key),
3535 env(coverClawback(issuer), kLoanBrokerId(brokerKeylet.key));
3536 BEAST_EXPECT((coverAvailable() ==
Number{0}));
3537 BEAST_EXPECT(pseudoBalance() ==
Number{0});
3540 testcase(
"FixedPrecision LoanBroker cover: XRP");
3541 [[maybe_unused]]
auto [xrpTx, xrpVault, xrpSub] =
3542 vault.createClosedEnded({.owner = alice, .asset =
xrpIssue()});
3544 auto const xrpBroker =
3546 env(
set(alice, xrpVault.key));
3549 env(
set(alice, xrpVault.key),
3550 kLoanBrokerId(xrpBroker.key),
3551 kDebtMaximum(
Number{5, -1}),
3553 env(coverDeposit(alice, xrpBroker.key,
XRP(10)));
3554 env(coverWithdraw(alice, xrpBroker.key,
XRP(1)));
3558 testcase(
"FixedPrecision LoanBroker cover: MPT");
3560 mptt.
create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
3563 env(
pay(issuer, alice, mpt(100)));
3564 [[maybe_unused]]
auto [mptTx, mptVault, mptSub] =
3565 vault.createClosedEnded({.owner = alice, .asset = mpt});
3567 auto const mptBroker =
3569 env(
set(alice, mptVault.key));
3570 env(coverDeposit(alice, mptBroker.key, mpt(10).value()));
3571 env(coverWithdraw(alice, mptBroker.key, mpt(1).value()));
3572 env(coverClawback(issuer), kLoanBrokerId(mptBroker.key),
kAmount(mpt(1)));
3586 using namespace jtx;
3589 testcase(
"FixedPrecision LoanBroker cover: exact round trip at grid boundaries");
3591 FeatureBitset const v12{
all_ | featureLendingProtocolV1_1 | featureLendingProtocolV1_2};
3600 {.scale = 3, .before =
Number{9'999, -3}},
3601 {.scale = 6, .before =
Number{999'999'999'999, -6}},
3602 {.scale = 6, .before =
Number{8'999'999'999'999'999, -6}},
3606 for (
auto const& c : cases)
3608 Account const issuer{
"issuer"};
3610 Env env{*
this, v12};
3611 env.
fund(
XRP(100'000), issuer, alice);
3616 env(
pay(issuer, alice, iou(
Number{1, 19})));
3619 Vault const vault{env};
3620 [[maybe_unused]]
auto [
createTx, vaultKeylet, subscriptionDate] =
3621 vault.createClosedEnded({.owner = alice, .asset = iou});
3626 auto const brokerKeylet =
3628 env(
set(alice, vaultKeylet.key));
3631 Number const unit{1, -
static_cast<int>(c.scale)};
3633 auto const coverAvailable = [&] {
3634 auto const broker = env.
le(brokerKeylet);
3635 BEAST_EXPECT(broker);
3636 return broker ?
Number(broker->at(sfCoverAvailable)) :
Number{0};
3638 auto const pseudoBalance = [&] {
3639 auto const broker = env.
le(brokerKeylet);
3640 BEAST_EXPECT(broker);
3646 env(coverDeposit(alice, brokerKeylet.key, iou(c.before)));
3648 BEAST_EXPECT(coverAvailable() == c.before);
3649 BEAST_EXPECT(pseudoBalance() == c.before);
3652 env(coverDeposit(alice, brokerKeylet.key, iou(
unit)));
3654 BEAST_EXPECT(coverAvailable() == c.before +
unit);
3655 BEAST_EXPECT(pseudoBalance() == c.before +
unit);
3658 env(coverWithdraw(alice, brokerKeylet.key, iou(
unit)));
3660 BEAST_EXPECT(coverAvailable() == c.before);
3661 BEAST_EXPECT(pseudoBalance() == c.before);
3672 using namespace jtx;
3675 Account const issuer{
"issuer"};
3685 Vault const vault{env};
3687 env.
fund(
XRP(100'000), issuer, alice);
3689 env(
fset(issuer, asfAllowTrustLineClawback));
3693 env(
trust(alice, iou(1'000'000)));
3695 env(
pay(issuer, alice, iou(1'000)));
3698 auto [
createTx, vaultKeylet] = vault.create({.owner = alice, .asset = iou});
3702 auto const brokerKeylet =
3704 env(
set(alice, vaultKeylet.key));
3707 env(coverDeposit(alice, brokerKeylet.key, iou(10)));
3710 return {brokerKeylet, iou};
3714 TER const expected =
3718 testcase(
"Cover precision guard: Deposit zero-at-scale");
3719 Env env{*
this, features};
3720 auto const [brokerKeylet, iou] = setup(env);
3722 auto const coverBefore = env.
le(brokerKeylet)->at(sfCoverAvailable);
3723 env(coverDeposit(alice, brokerKeylet.key, subUlpAmt),
Ter(expected));
3727 if (
auto const broker = env.
le(brokerKeylet); BEAST_EXPECT(broker))
3728 BEAST_EXPECT(broker->at(sfCoverAvailable) == coverBefore);
3733 testcase(
"Cover precision guard: Deposit rounds down");
3741 Env env{*
this, features};
3742 auto const [brokerKeylet, iou] = setup(env);
3744 auto const coverBefore = env.
le(brokerKeylet)->at(sfCoverAvailable);
3745 env(coverDeposit(alice, brokerKeylet.key, subUlpAmt),
Ter(
tesSUCCESS));
3747 auto const brokerAfter = env.
le(brokerKeylet);
3748 if (!BEAST_EXPECT(brokerAfter))
3752 BEAST_EXPECT(brokerAfter->at(sfCoverAvailable) - coverBefore == delta);
3761 if (features[fixCleanup3_2_0])
3763 testcase(
"Cover precision guard: Deposit rounding bound");
3764 Env env{*
this, features};
3765 auto const [brokerKeylet, iou] = setup(env);
3766 Number const oneUlp{1, -14};
3773 auto const broker = env.
le(brokerKeylet);
3774 if (!BEAST_EXPECT(broker))
3776 Number const coverBefore = broker->at(sfCoverAvailable);
3777 env(coverDeposit(alice, brokerKeylet.key, iou(requested)),
Ter(
tesSUCCESS));
3779 auto const brokerAfter = env.
le(brokerKeylet);
3780 if (!BEAST_EXPECT(brokerAfter))
3782 Number const coverAfter = brokerAfter->at(sfCoverAvailable);
3783 Number const actual = coverAfter - coverBefore;
3784 Number const lost = requested - actual;
3785 BEAST_EXPECT(lost >=
Number{0});
3786 BEAST_EXPECT(lost < oneUlp);
3791 testcase(
"Cover precision guard: Withdraw");
3792 Env env{*
this, features};
3793 auto const [brokerKeylet, iou] = setup(env);
3795 auto const coverBefore = env.
le(brokerKeylet)->at(sfCoverAvailable);
3796 auto const aliceBalanceBefore = env.
balance(alice, iou);
3797 env(coverWithdraw(alice, brokerKeylet.key, subUlpAmt),
Ter(expected));
3801 if (
auto const broker = env.
le(brokerKeylet); BEAST_EXPECT(broker))
3802 BEAST_EXPECT(broker->at(sfCoverAvailable) == coverBefore);
3803 BEAST_EXPECT(env.
balance(alice, iou) == aliceBalanceBefore);
3808 testcase(
"Cover precision guard: Clawback");
3809 Env env{*
this, features};
3810 auto const [brokerKeylet, iou] = setup(env);
3812 auto const coverBefore = env.
le(brokerKeylet)->at(sfCoverAvailable);
3813 env(coverClawback(issuer),
3814 kLoanBrokerId(brokerKeylet.key),
3820 if (
auto const broker = env.
le(brokerKeylet); BEAST_EXPECT(broker))
3821 BEAST_EXPECT(broker->at(sfCoverAvailable) == coverBefore);
3828 testcase(
"Cover precision guard: MPT min amount passes");
3831 env.
fund(
XRP(100'000), issuer, alice);
3835 mptt.
create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
3842 env(
pay(issuer, alice, mptAsset(100)));
3845 Vault const vault{env};
3846 auto [
createTx, vaultKeylet] = vault.create({.owner = alice, .asset = mptAsset});
3850 auto const brokerKeylet =
3852 env(
set(alice, vaultKeylet.key));
3855 env(coverDeposit(alice, brokerKeylet.key, mptAsset(10)));
3858 env(coverDeposit(alice, brokerKeylet.key, mptAsset(1)),
Ter(
tesSUCCESS));
3861 env(coverWithdraw(alice, brokerKeylet.key, mptAsset(1)),
Ter(
tesSUCCESS));
3864 env(coverClawback(issuer),
3865 kLoanBrokerId(brokerKeylet.key),
3873 runTestCases(
all_ - fixCleanup3_2_0);
3879 testcase(
"Private Loan Broker with Permissioned Domain");
3880 using namespace jtx;
3883 Account const issuer{
"issuer"};
3885 Account const credIssuer{
"credIssuer"};
3889 Env env{*
this,
all_ | featureLendingProtocolV1_2};
3890 Vault const vault{env};
3892 env.
fund(
XRP(100'000), issuer, alice, credIssuer);
3896 env(
trust(alice, issuer[
"IOU"](1'000'000)));
3899 env(
pay(issuer, alice, asset(100'000)));
3902 auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
3913 auto const brokerKeylet =
3916 testcase(
"Create a private loan broker with DomainID");
3917 env(
set(alice, vaultKeylet.key, tfLoanBrokerPrivate), kDomainId(domainId));
3922 testcase(
"Verify the broker was created with the correct flags and DomainID");
3923 auto const sleBroker = env.
le(brokerKeylet);
3924 if (!BEAST_EXPECT(sleBroker))
3928 BEAST_EXPECT(sleBroker->isFlag(lsfLoanBrokerPrivate));
3929 BEAST_EXPECT(sleBroker->at(~sfDomainID) == domainId);
3933 testcase(
"Cannot create public broker with DomainID");
3939 testcase(
"Cannot create broker with zero DomainID");
3940 env(
set(alice, vaultKeylet.key, tfLoanBrokerPrivate),
3946 testcase(
"Cannot create broker with non-existent DomainID");
3948 BEAST_EXPECT(fakeDomainId.
parseHex(
3949 "1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF"));
3950 env(
set(alice, vaultKeylet.key, tfLoanBrokerPrivate),
3951 kDomainId(fakeDomainId),
3959 testcase(
"Modify Private Loan Broker DomainID");
3960 using namespace jtx;
3963 Account const issuer{
"issuer"};
3965 Account const credIssuer{
"credIssuer"};
3969 Env env{*
this,
all_ | featureLendingProtocolV1_2};
3970 Vault const vault{env};
3972 env.
fund(
XRP(100'000), issuer, alice, credIssuer);
3976 env(
trust(alice, issuer[
"IOU"](1'000'000)));
3979 env(
pay(issuer, alice, asset(100'000)));
3982 auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
3997 auto const brokerKeylet =
3999 env(
set(alice, vaultKeylet.key, tfLoanBrokerPrivate), kDomainId(domainId1));
4003 testcase(
"Modify DomainID to a different domain");
4004 env(
set(alice, vaultKeylet.key), kLoanBrokerId(brokerKeylet.key), kDomainId(domainId2));
4006 auto const sleBroker = env.
le(brokerKeylet);
4007 if (!BEAST_EXPECT(sleBroker))
4011 BEAST_EXPECT(sleBroker->at(~sfDomainID) == domainId2);
4015 testcase(
"Clear DomainID by setting to zero");
4016 env(
set(alice, vaultKeylet.key),
4017 kLoanBrokerId(brokerKeylet.key),
4020 auto const sleBroker = env.
le(brokerKeylet);
4021 if (!BEAST_EXPECT(sleBroker))
4025 BEAST_EXPECT(!sleBroker->at(~sfDomainID));
4030 env(
set(alice, vaultKeylet.key), kLoanBrokerId(brokerKeylet.key), kDomainId(domainId1));
4032 auto const sleBroker = env.
le(brokerKeylet);
4033 if (!BEAST_EXPECT(sleBroker))
4037 BEAST_EXPECT(sleBroker->at(~sfDomainID) == domainId1);
4041 BEAST_EXPECT(fakeDomainId.
parseHex(
4042 "1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF"));
4045 testcase(
"Cannot modify DomainID to a non-existent domain");
4046 env(
set(alice, vaultKeylet.key),
4047 kLoanBrokerId(brokerKeylet.key),
4048 kDomainId(fakeDomainId),
4051 auto const sleBroker = env.
le(brokerKeylet);
4052 if (!BEAST_EXPECT(sleBroker))
4058 BEAST_EXPECT(sleBroker->at(~sfDomainID) == domainId1);
4062 testcase(
"Updating other fields without specifying DomainID does not affect DomainID");
4063 env(
set(alice, vaultKeylet.key),
4064 kLoanBrokerId(brokerKeylet.key),
4066 kDebtMaximum(
Number(1000)));
4068 auto const sleBroker = env.
le(brokerKeylet);
4069 if (!BEAST_EXPECT(sleBroker))
4074 BEAST_EXPECT(sleBroker->at(~sfDomainID) == domainId1);
4076 BEAST_EXPECT(sleBroker->isFieldPresent(sfData));
4077 BEAST_EXPECT(sleBroker->at(~sfDebtMaximum) ==
Number(1000));
4081 testcase(
"Updating only DomainID does not affect other fields");
4082 env(
set(alice, vaultKeylet.key), kLoanBrokerId(brokerKeylet.key), kDomainId(domainId2));
4084 auto const sleBroker = env.
le(brokerKeylet);
4085 if (!BEAST_EXPECT(sleBroker))
4090 BEAST_EXPECT(sleBroker->at(~sfDomainID) == domainId2);
4092 BEAST_EXPECT(sleBroker->isFieldPresent(sfData));
4093 BEAST_EXPECT(sleBroker->at(~sfDebtMaximum) ==
Number(1000));
4097 testcase(
"Cannot set tfLoanBrokerPrivate when modifying (flag is immutable)");
4098 env(
set(alice, vaultKeylet.key, tfLoanBrokerPrivate),
4099 kLoanBrokerId(brokerKeylet.key),
4103 auto const publicBrokerKeylet =
4106 testcase(
"Create a public broker and try to set DomainID on it");
4107 env(
set(alice, vaultKeylet.key));
4109 auto const sleBroker = env.
le(publicBrokerKeylet);
4110 if (!BEAST_EXPECT(sleBroker))
4114 BEAST_EXPECT(!sleBroker->isFlag(lsfLoanBrokerPrivate));
4118 env(
set(alice, vaultKeylet.key),
4119 kLoanBrokerId(publicBrokerKeylet.key),
4120 kDomainId(domainId1),
4124 env(
set(alice, vaultKeylet.key),
4125 kLoanBrokerId(publicBrokerKeylet.key),
4132 env(
set(alice, vaultKeylet.key),
4133 kLoanBrokerId(publicBrokerKeylet.key),
4134 kDomainId(fakeDomainId),
4143 using namespace jtx;
4146 bool const withFix = features[fixCleanup3_5_0];
4148 std::string(
"DebtMaximum out of range for the asset (") + (withFix ?
"post" :
"pre") +
4149 "-fixCleanup3_5_0)");
4151 Env env(*
this, features);
4153 env.
fund(
XRP(100'000), alice);
4156 Vault const vault{env};
4157 auto const [tx,
keylet] = vault.create({.owner = alice, .asset =
xrpIssue()});
4166 kDebtMaximum(maxXrp + 1),
4171 env(
set(alice,
keylet.key), kDebtMaximum(maxXrp));
A generic endpoint for log messages.
void fail(String const &reason, char const *file, int line)
Record a failure.
TestcaseT testcase
Memberspace for declaring test cases.
static constexpr Int kMaxInt
std::string asString() const
Returns the unquoted string value.
State information when applying a tx.
virtual SLE::pointer peek(Keylet const &k)=0
Prepare to modify the SLE associated with key.
virtual void erase(SLE::Ref sle)=0
Remove a peeked SLE.
constexpr bool parseHex(std::string_view sv)
Parse a hex string into a base_uint.
A currency issued by an account.
static TER preclaim(PreclaimContext const &ctx)
Number is a floating point type that can represent a wide range of values.
static MantissaRange::MantissaScale getMantissaScale()
Returns which mantissa scale is currently in use for normalization.
Writable ledger view that accumulates state and tx changes.
static constexpr std::uint64_t kMaxNativeN
std::shared_ptr< STLedgerEntry const > const & ConstRef
void setFieldAmount(SField const &field, STAmount const &)
void setAccountID(SField const &field, AccountID const &)
void setFieldH256(SField const &field, UInt256 const &)
static constexpr SeqProxy rawSequence(std::uint32_t v)
Factory function to return a sequence-based SeqProxy.
Slice slice() const noexcept
A step in a payment path.
void testInvalidLoanBrokerSet()
static std::vector< std::tuple< std::string, FeatureBitset, TER > > cleanupRuns(FeatureBitset features, ExpectedByCleanup const &expected)
void testFixedPrecisionCover()
void testPrivateLoanBroker()
void testLoanBrokerDeleteRequireAuthMPT(FeatureBitset features)
void testLoanBrokerDeleteFrozenIOU(FeatureBitset features)
void run() override
Runs the suite.
void testCoverPrecisionGuard()
static void leaveBelowReserve(jtx::Env &env, jtx::Account const &alice, jtx::Account const &sink, int incrementsShort)
void testLoanBroker(std::function< jtx::PrettyAsset(jtx::Env &, jtx::Account const &, jtx::Account const &)> getAsset, LoanBrokerTest brokerTest)
void testLoanBrokerDeleteCoverPayoutMPT()
void testInvalidLoanBrokerCoverClawback()
void testInvalidLoanBrokerCoverWithdraw()
void testCoverWithdrawSelfWhileFrozen()
void testPrivateLoanBrokerModify()
void testInvalidLoanBrokerCoverDeposit()
void testCoverDepositFreezes()
static Keylet createBroker(jtx::Env &env, jtx::Account const &alice, jtx::PrettyAsset const &asset, std::int64_t cover)
void testCoverWithdrawFreezes()
void testLoanBrokerSetDebtMaximum()
void lifecycle(char const *label, jtx::Env &env, jtx::Account const &issuer, jtx::Account const &alice, jtx::Account const &evan, jtx::Account const &bystander, VaultInfo const &vault, VaultInfo const &badVault, std::function< jtx::JTx(jtx::JTx const &)> modifyJTx, std::function< void(SLE::ConstRef)> checkBroker, std::function< void(SLE::ConstRef)> changeBroker, std::function< void(SLE::ConstRef)> checkChangedBroker)
void testAmB06VaultFreezeCheckMissing()
void testDebtMaximumOutOfRange(FeatureBitset features)
void deleteBrokerAndCheck(jtx::Env &env, jtx::Account const &alice, jtx::PrettyAsset const &asset, Keylet const &brokerKeylet, TER expected)
void testLoanBrokerCoverDepositNullVault()
void testLoanBrokerDeleteConfidentialCOA(FeatureBitset features)
void testCoverWithdrawCredentialDepositPreauth(FeatureBitset features)
void testFixedPrecisionCoverExactAtGridBoundaries()
void testLoanBrokerDeleteLockedMPT(FeatureBitset features)
void testLoanBrokerDeleteCoverPayoutIOU()
void testInvalidLoanBrokerDelete()
Immutable cryptographic account descriptor.
std::string const & human() const
Returns the human readable public key.
AccountID id() const
Returns the Account ID.
A transaction testing environment.
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
TER ter() const
Return the TER for the last JTx.
json::Value json(JsonValue &&jv, FN const &... fN)
Create JSON from parameters.
SLE::const_pointer le(Account const &account) const
Return an account root.
std::uint32_t ownerCount(Account const &account) const
Return the number of objects owned by an account.
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
std::uint32_t seq(Account const &account) const
Returns the next sequence number on account.
json::Value rpc(unsigned apiVersion, std::unordered_map< std::string, std::string > const &headers, std::string const &cmd, Args &&... args)
Execute an RPC command.
void setParseFailureExpected(bool b)
JTx jt(JsonValue &&jv, FN const &... fN)
Create a JTx from parameters.
PrettyAmount balance(Account const &account) const
Returns the XRP balance on an account.
void disableFeature(UInt256 const feature)
void enableFeature(UInt256 const feature)
std::shared_ptr< STTx const > ust(JTx const &jt)
Create a STTx from a JTx without sanitizing Use to inject bogus values into test transactions by firs...
std::shared_ptr< STObject const > meta()
Return metadata for the last JTx.
beast::Journal const journal
void require(Args const &... args)
Check a set of requirements.
std::shared_ptr< OpenView const > current() const
Returns the current ledger.
Test helper for creating, mutating, and asserting MPT and confidential MPT ledger state.
static constexpr auto holderEncryptedInbox
std::optional< Buffer > getEncryptedBalance(Account const &account, EncryptedBalanceType option=holderEncryptedInbox) const
std::uint32_t generateKeyPair(Account const &account)
static constexpr auto issuerEncryptedBalance
MPTID const & issuanceID() const
static constexpr auto holderEncryptedSpending
std::optional< Buffer > getPubKey(Account const &account, std::optional< std::uint32_t > epoch=std::nullopt) const
static constexpr auto auditorEncryptedBalance
void create(MPTCreate const &arg=MPTCreate{}, std::source_location const &loc=std::source_location::current())
void set(MPTSet const &set={}, std::source_location const &loc=std::source_location::current())
std::int64_t getIssuanceConfidentialBalance() const
void authorize(MPTAuthorize const &arg=MPTAuthorize{}, std::source_location const &loc=std::source_location::current())
void convert(MPTConvert const &arg=MPTConvert{}, std::source_location const &loc=std::source_location::current())
Converts to MPT Issue or STAmount.
Set the regular signature on a JTx.
Set the expected result code for a JTx The test will fail if the code doesn't match.
T emplace_back(T... args)
Keylet computation functions.
Keylet vault(AccountID const &owner, SeqProxy const &seq) noexcept
Keylet mptoken(MPTID const &issuanceID, AccountID const &holder) noexcept
Keylet loanBroker(AccountID const &owner, SeqProxy const &seq) noexcept
Keylet account(AccountID const &id) noexcept
AccountID root.
Keylet loan(UInt256 const &loanBrokerID, SeqProxy const &loanSeq) noexcept
Keylet trustLine(AccountID const &id0, AccountID const &id1, Currency const ¤cy) noexcept
The index of a trust line for a given currency.
constexpr TenthBips32 kMaxCoverRate
The maximum coverage rate required of a loan broker in 1/10 bips.
constexpr TenthBips16 kMaxManagementFeeRate(unsafeCast< std::uint16_t >(percentageToTenthBips(10).value()))
The maximum management fee rate allowed by a loan broker in 1/10 bips.
json::Value accept(jtx::Account const &subject, jtx::Account const &issuer, std::string_view credType)
json::Value create(jtx::Account const &subject, jtx::Account const &issuer, std::string_view credType)
json::Value ledgerEntry(jtx::Env &env, jtx::Account const &subject, jtx::Account const &issuer, std::string_view credType)
Keylet keylet(test::jtx::Account const &subject, test::jtx::Account const &issuer, std::string_view credType)
Deposit preauthorize operations.
json::Value authCredentials(jtx::Account const &account, std::vector< AuthorizeCredentials > const &auth)
json::Value set(AccountID const &account, UInt256 const &vaultId, uint32_t flags)
json::Value coverWithdraw(AccountID const &account, UInt256 const &brokerID, STAmount const &amount, uint32_t flags)
json::Value coverDeposit(AccountID const &account, UInt256 const &brokerID, STAmount const &amount, uint32_t flags)
json::Value del(AccountID const &account, UInt256 const &brokerID, uint32_t flags)
json::Value coverClawback(AccountID const &account, std::uint32_t flags)
json::Value set(AccountID const &account, UInt256 const &loanBrokerID, Number principalRequested, std::uint32_t flags)
json::Value del(AccountID const &account, UInt256 const &loanID, std::uint32_t flags)
json::Value pay(AccountID const &account, UInt256 const &loanID, STAmount const &amount, std::uint32_t flags)
std::vector< Credential > Credentials
UInt256 getNewDomain(std::shared_ptr< STObject const > const &meta)
json::Value setTx(AccountID const &account, Credentials const &credentials, std::optional< UInt256 > domain)
json::Value pay(AccountID const &account, AccountID const &to, AnyAmount amount)
Create a payment.
XrpT const XRP
Converts to XRP Issue or STAmount.
json::Value noop(Account const &account)
The null transaction.
std::uint32_t ownerCount(Env const &env, Account const &account)
json::Value fclear(Account const &account, std::uint32_t off)
Remove account flag.
FeatureBitset testableAmendments()
auto const kData
General field definitions, or fields used in multiple transaction namespaces.
std::array< Account, 1+sizeof...(Args)> noripple(Account const &account, Args const &... args)
Designate accounts as no-ripple in Env::fund.
json::Value trust(Account const &account, STAmount const &amount, std::uint32_t flags)
Modify a trust line.
bool checkVL(Slice const &result, std::string const &expected)
json::Value fset(Account const &account, std::uint32_t on, std::uint32_t off=0)
Add and/or remove flag.
static MPTInit const kMptInitNoFund
BEAST_DEFINE_TESTSUITE(AMMClawback, app, xrpl)
static STAmount accountReserve(jtx::Env const &env, std::uint32_t count=1)
STTx createTx(bool disabling, LedgerIndex seq, PublicKey const &txKey)
Create ttUNL_MODIFY Tx.
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
bool set(T &target, std::string const &name, Section const §ion)
Set a value from a configuration Section If the named value is not found or doesn't parse as a T,...
Issue const & xrpIssue()
Returns an asset specifier that represents XRP.
std::string strHex(FwdIt begin, FwdIt end)
int scale(Number const &number, Asset const &asset)
Get the scale of a Number for a given asset.
std::string toBase58(AccountID const &v)
Convert AccountID to base58 checked string.
static bool authorized(Port const &port, std::map< std::string, std::string > const &h)
Number power(Number const &f, unsigned n)
TenthBips< std::uint32_t > TenthBips32
TenthBips< std::uint16_t > TenthBips16
constexpr FlagValue tfUniversal
std::string to_string(BaseUInt< Bits, Tag > const &a)
constexpr std::size_t kMaxDataPayloadLength
The maximum length of Data payload.
Asset getAsset(T const &amt)
void roundToAsset(A const &asset, Number &value)
Round an arbitrary precision Number IN PLACE to the precision of a given Asset.
BaseUInt< 160, detail::AccountIDTag > AccountID
A 160-bit unsigned that uniquely identifies an account.
bool isTesSuccess(TER x) noexcept
TERSubset< CanCvtToTER > TER
TER requireAuth(ReadView const &view, MPTIssue const &mptIssue, AccountID const &account, AuthType authType=AuthType::Legacy, std::uint8_t depth=0)
Check if the account lacks required authorization for MPT.
@ tecNO_LINE_INSUF_RESERVE
@ tecINSUFFICIENT_RESERVE
constexpr std::uint64_t kMaxMpTokenAmount
The maximum amount of MPTokenIssuance.
constexpr FlagValue tfFullyCanonicalSig
bool holdingExists(ReadView const &view, AccountID const &account, Asset const &asset)
True if the account already holds this asset (or is the issuer / XRP).
A pair of SHAMap key and LedgerEntryType.
State information when determining if a tx is likely to claim a fee.
jtx::Account pseudoAccount
VaultInfo(jtx::PrettyAsset const &asset, UInt256 const &vaultId, AccountID const &pseudo)
Set the destination tag on a JTx.
Execution context for applying a JSON transaction.
Represents an XRP, IOU, or MPT quantity This customizes the string conversion and supports XRP conver...
STAmount const & value() const
Asset const & raw() const
Set the sequence number on a JTx.