xrpld
Loading...
Searching...
No Matches
LoanBroker_test.cpp
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>
25
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>
58
59#include <array>
60#include <cstdint>
61#include <exception>
62#include <functional>
63#include <memory>
64#include <optional>
65#include <string>
66#include <string_view>
67#include <tuple>
68#include <utility>
69#include <vector>
70
71namespace xrpl::test {
72
74{
75 // Ensure that all the features needed for Lending Protocol are included,
76 // even if they are set to unsupported.
77 //
78 // V1.1 and V1.2 are excluded from the default set: they add the
79 // closed-ended Vault gate and fixed-precision behavior, while this suite
80 // primarily exercises legacy LoanBroker mechanics on open-ended Vaults.
81 // Tests for the new behavior opt both amendments back in explicitly.
83 jtx::testableAmendments() - featureLendingProtocolV1_1 - featureLendingProtocolV1_2,
84 };
85
86 void
88 {
89 testcase("Disabled");
90 // Lending Protocol depends on Single Asset Vault (SAV). Test
91 // combinations of the two amendments.
92 // Single Asset Vault depends on MPTokensV1, but don't test every combo
93 // of that.
94 using namespace jtx;
95 auto const failAll = [this](FeatureBitset features, bool goodVault = false) {
96 Env env(*this, features);
97
98 Account const alice{"alice"};
99 env.fund(XRP(10000), alice);
100
101 // Try to create a vault
102 PrettyAsset const asset{xrpIssue(), 1'000'000};
103 Vault const vault{env};
104 auto const [tx, keylet] = vault.create({.owner = alice, .asset = asset});
105 env(tx, Ter(goodVault ? Ter(tesSUCCESS) : Ter(temDISABLED)));
106 env.close();
107 BEAST_EXPECT(static_cast<bool>(env.le(keylet)) == goodVault);
108
109 using namespace loan_broker;
110 // Can't create a loan broker regardless of whether the vault exists
111 env(set(alice, keylet.key), Ter(temDISABLED));
112 auto const brokerKeylet =
113 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
114 // Other LoanBroker transactions are disabled, too.
115 // 1. LoanBrokerCoverDeposit
116 env(coverDeposit(alice, brokerKeylet.key, asset(1000)), Ter(temDISABLED));
117 // 2. LoanBrokerCoverWithdraw
118 env(coverWithdraw(alice, brokerKeylet.key, asset(1000)), Ter(temDISABLED));
119 // 3. LoanBrokerCoverClawback
120 env(coverClawback(alice), Ter(temDISABLED));
121 env(coverClawback(alice), kLoanBrokerId(brokerKeylet.key), Ter(temDISABLED));
122 env(coverClawback(alice), kAmount(asset(0)), Ter(temDISABLED));
123 env(coverClawback(alice),
124 kLoanBrokerId(brokerKeylet.key),
125 kAmount(asset(1000)),
127 // 4. LoanBrokerDelete
128 env(del(alice, brokerKeylet.key), Ter(temDISABLED));
129 };
130 failAll(all_ - featureMPTokensV1);
131 failAll(all_ - featureSingleAssetVault - featureLendingProtocol);
132 failAll(all_ - featureSingleAssetVault);
133 failAll(all_ - featureLendingProtocol, true);
134
135 // Without featureLendingProtocolV1_2, private brokers and DomainID
136 // are rejected in preflight.
137 {
138 Env env(*this, all_ - featureLendingProtocolV1_2);
139
140 Account const alice{"alice"};
141 env.fund(XRP(10000), alice);
142
143 PrettyAsset const asset{xrpIssue(), 1'000'000};
144 Vault const vault{env};
145 auto const [tx, keylet] = vault.create({.owner = alice, .asset = asset});
146 env(tx);
147 env.close();
148
149 using namespace loan_broker;
150 env(set(alice, keylet.key, tfLoanBrokerPrivate), Ter(temINVALID_FLAG));
151 env(set(alice, keylet.key), kDomainId(uint256(1)), Ter(temDISABLED));
152 }
153 }
154
156 {
160 VaultInfo(jtx::PrettyAsset const& asset, UInt256 const& vaultId, AccountID const& pseudo)
161 : asset(asset), vaultID(vaultId), pseudoAccount("vault", pseudo)
162 {
163 }
164 };
165
166 void
168 char const* label,
169 jtx::Env& env,
170 jtx::Account const& issuer,
171 jtx::Account const& alice,
172 jtx::Account const& evan,
173 jtx::Account const& bystander,
174 VaultInfo const& vault,
175 VaultInfo const& badVault,
176 std::function<jtx::JTx(jtx::JTx const&)> modifyJTx,
177 std::function<void(SLE::ConstRef)> checkBroker,
178 std::function<void(SLE::ConstRef)> changeBroker,
179 std::function<void(SLE::ConstRef)> checkChangedBroker)
180 {
181 {
182 auto const& asset = vault.asset.raw();
183 std::string_view assetLabel;
184 if (asset.native())
185 {
186 assetLabel = "XRP ";
187 }
188 else if (asset.holds<Issue>())
189 {
190 assetLabel = "IOU ";
191 }
192 else if (asset.holds<MPTIssue>())
193 {
194 assetLabel = "MPT ";
195 }
196 else
197 {
198 assetLabel = "Unknown ";
199 }
200 testcase << "Lifecycle: " << assetLabel << label;
201 }
202
203 using namespace jtx;
204 using namespace loan_broker;
205
206 // Bogus assets to use in test cases
207 static PrettyAsset const kBadMptAsset = [&] {
208 MPTTester badMptt{env, evan, kMptInitNoFund};
209 badMptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
210 env.close();
211 return badMptt["BAD"];
212 }();
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"];
217
218 auto const badKeylet =
219 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
220 env(set(alice, badVault.vaultID));
221 env.close();
222 auto const badBrokerPseudo = [&] {
223 if (auto const le = env.le(badKeylet); BEAST_EXPECT(le))
224 {
225 return Account{"Bad Broker pseudo-account", le->at(sfAccount)};
226 }
227 // Just to make the build work
228 return vault.pseudoAccount;
229 }();
230 PrettyAsset const badBrokerPseudoIouAsset = badBrokerPseudo["WAT"];
231
232 auto const keylet = keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
233 {
234 // Start with default values
235 auto jtx = env.jt(set(alice, vault.vaultID));
236 // Modify as desired
237 if (modifyJTx)
238 jtx = modifyJTx(jtx);
239 // Successfully create a Loan Broker
240 env(jtx);
241 }
242
243 env.close();
244 if (auto broker = env.le(keylet); BEAST_EXPECT(broker))
245 {
246 // log << "Broker after create: " << to_string(broker->getJson())
247 // << std::endl;
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);
257 if (checkBroker)
258 checkBroker(broker);
259
260 // if (auto const vaultSLE = env.le(keylet::vault(vault.vaultID)))
261 //{
262 // log << "Vault: " << to_string(vaultSLE->getJson()) <<
263 // std::endl;
264 // }
265 // Load the pseudo-account
266 Account const pseudoAccount{"Broker pseudo-account", broker->at(sfAccount)};
267
268 auto const pseudoKeylet = keylet::account(pseudoAccount);
269 if (auto const pseudo = env.le(pseudoKeylet); BEAST_EXPECT(pseudo))
270 {
271 // log << "Pseudo-account after create: "
272 // << to_string(pseudo->getJson()) << std::endl
273 // << std::endl;
274 BEAST_EXPECT(
275 pseudo->at(sfFlags) == (lsfDisableMaster | lsfDefaultRipple | lsfDepositAuth));
276 BEAST_EXPECT(pseudo->at(sfSequence) == 0);
277 BEAST_EXPECT(pseudo->at(sfBalance) == beast::kZero);
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);
296 }
297
298 {
299 // Get the AccountInfo RPC result for the broker pseudo-account
300 std::string const pseudoStr = to_string(pseudoAccount.id());
301 auto const accountInfo = env.rpc("account_info", pseudoStr);
302 if (BEAST_EXPECT(accountInfo.isObject()))
303 {
304 auto const& accountData = accountInfo[jss::result][jss::account_data];
305 if (BEAST_EXPECT(accountData.isObject()))
306 {
307 BEAST_EXPECT(accountData[jss::Account] == pseudoStr);
308 BEAST_EXPECT(accountData[sfLoanBrokerID] == to_string(keylet.key));
309 }
310 auto const& pseudoInfo = accountInfo[jss::result][jss::pseudo_account];
311 if (BEAST_EXPECT(pseudoInfo.isObject()))
312 {
313 BEAST_EXPECT(pseudoInfo[jss::type] == "LoanBroker");
314 }
315 }
316 }
317
318 auto const verifyCoverAmount =
319 [&env, &vault, &pseudoAccount, &broker, &keylet, this](auto n) {
320 using namespace jtx;
321
322 broker = env.le(keylet);
323 if (BEAST_EXPECT(broker))
324 {
325 auto const amount = vault.asset(n);
326 BEAST_EXPECT(broker->at(sfCoverAvailable) == amount.number());
327 env.require(jtx::Balance(pseudoAccount, amount));
328 }
329 };
330
331 // Test Cover funding before allowing alterations
332 env(coverDeposit(alice, UInt256(0), vault.asset(10)), Ter(temINVALID));
333 env(coverDeposit(evan, keylet.key, vault.asset(10)), Ter(tecNO_PERMISSION));
334 env(coverDeposit(evan, keylet.key, vault.asset(0)), Ter(temBAD_AMOUNT));
335 env(coverDeposit(evan, keylet.key, vault.asset(-10)), Ter(temBAD_AMOUNT));
336 env(coverDeposit(alice, vault.vaultID, vault.asset(10)), Ter(tecNO_ENTRY));
337
338 verifyCoverAmount(0);
339
340 // Test cover clawback failure cases BEFORE depositing any cover
341 // Need one of brokerID or amount
342 env(coverClawback(alice), Ter(temINVALID));
343 env(coverClawback(alice), kLoanBrokerId(UInt256(0)), Ter(temINVALID));
344 env(coverClawback(alice), kAmount(XRP(1000)), Ter(temBAD_AMOUNT));
345 env(coverClawback(alice), kAmount(vault.asset(-10)), Ter(temBAD_AMOUNT));
346 // Clawbacks with an MPT need to specify the broker ID
347 env(coverClawback(alice), kAmount(kBadMptAsset(1)), Ter(temINVALID));
348 env(coverClawback(evan), kLoanBrokerId(vault.vaultID), Ter(tecNO_ENTRY));
349 // Only the issuer can clawback
350 env(coverClawback(alice), kLoanBrokerId(keylet.key), Ter(tecNO_PERMISSION));
351 if (vault.asset.raw().native())
352 {
353 // Can not clawback XRP under any circumstances
354 env(coverClawback(issuer), kLoanBrokerId(keylet.key), Ter(tecNO_PERMISSION));
355 }
356 else
357 {
358 if (vault.asset.raw().holds<Issue>())
359 {
360 // Clawbacks without a kLoanBrokerId need to specify an IOU
361 // with the broker's pseudo-account as the issuer
362 env(coverClawback(alice), kAmount(kGhostIouAsset(1)), Ter(tecNO_ENTRY));
363 env(coverClawback(alice), kAmount(kBadIouAsset(1)), Ter(tecOBJECT_NOT_FOUND));
364 // Pseudo-account is not for a broker
365 env(coverClawback(alice),
366 kAmount(vaultPseudoIouAsset(1)),
368 // If we specify a pseudo-account as the IOU amount, it
369 // needs to match the loan broker
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)),
379 }
380 else
381 {
382 // Clawbacks with an MPT need to specify the broker ID, even
383 // if the asset is valid
384 BEAST_EXPECT(vault.asset.raw().holds<MPTIssue>());
385 env(coverClawback(alice), kAmount(vault.asset(10)), Ter(temINVALID));
386 }
387 // Since no cover has been deposited, there's nothing to claw
388 // back
389 env(coverClawback(issuer),
390 kLoanBrokerId(keylet.key),
391 kAmount(vault.asset(10)),
393 }
394 env.close();
395
396 // Fund the cover deposit
397 env(coverDeposit(alice, keylet.key, vault.asset(10)));
398 env.close();
399 verifyCoverAmount(10);
400
401 // Test withdrawal failure cases
402 env(coverWithdraw(alice, UInt256(0), vault.asset(10)), Ter(temINVALID));
403 env(coverWithdraw(evan, keylet.key, vault.asset(10)), Ter(tecNO_PERMISSION));
404 env(coverWithdraw(evan, keylet.key, vault.asset(0)), Ter(temBAD_AMOUNT));
405 env(coverWithdraw(evan, keylet.key, vault.asset(-10)), Ter(temBAD_AMOUNT));
406 env(coverWithdraw(alice, vault.vaultID, vault.asset(10)), Ter(tecNO_ENTRY));
407 env(coverWithdraw(alice, keylet.key, vault.asset(900)), Ter(tecINSUFFICIENT_FUNDS));
408
409 // Skip this test for XRP, because that can always be sent
410 if (!vault.asset.raw().native())
411 {
412 TER const expected = vault.asset.raw().holds<MPTIssue>() ? tecNO_AUTH : tecNO_LINE;
413 env(coverWithdraw(alice, keylet.key, vault.asset(1)),
414 kDestination(bystander),
415 Ter(expected));
416 }
417
418 // Can not withdraw to the zero address
419 env(coverWithdraw(alice, keylet.key, vault.asset(1)),
420 kDestination(AccountID{}),
422
423 // Withdraw some of the cover amount
424 env(coverWithdraw(alice, keylet.key, vault.asset(7)));
425 env.close();
426 verifyCoverAmount(3);
427
428 // Add some more cover
429 env(coverDeposit(alice, keylet.key, vault.asset(5)));
430 env.close();
431 verifyCoverAmount(8);
432
433 // Withdraw some more. Send it to Evan. Very generous, considering
434 // how much trouble he's been.
435 env(coverWithdraw(alice, keylet.key, vault.asset(1)), kDestination(evan));
436 env.close();
437 verifyCoverAmount(7);
438
439 // Withdraw some more. Send it to Evan. Very generous, considering
440 // how much trouble he's been.
441 env(coverWithdraw(alice, keylet.key, vault.asset(1)), kDestination(evan), Dtag(3));
442 env.close();
443 verifyCoverAmount(6);
444
445 if (!vault.asset.raw().native())
446 {
447 // Issuer claws back some of the cover
448 env(coverClawback(issuer), kLoanBrokerId(keylet.key), kAmount(vault.asset(2)));
449 env.close();
450 verifyCoverAmount(4);
451
452 // Deposit some back
453 env(coverDeposit(alice, keylet.key, vault.asset(5)));
454 env.close();
455 verifyCoverAmount(9);
456
457 // Issuer claws it all back in various different ways
458 for (auto const& tx : {
459 // defer autofills until submission time
460 env.json(
461 coverClawback(issuer),
462 kLoanBrokerId(keylet.key),
463 Fee(kNone),
464 Seq(kNone),
465 Sig(kNone)),
466 env.json(
467 coverClawback(issuer),
468 kLoanBrokerId(keylet.key),
469 kAmount(vault.asset(0)),
470 Fee(kNone),
471 Seq(kNone),
472 Sig(kNone)),
473 env.json(
474 coverClawback(issuer),
475 kLoanBrokerId(keylet.key),
476 kAmount(vault.asset(6)),
477 Fee(kNone),
478 Seq(kNone),
479 Sig(kNone)),
480 // amount will be truncated to what's available
481 env.json(
482 coverClawback(issuer),
483 kLoanBrokerId(keylet.key),
484 kAmount(vault.asset(100)),
485 Fee(kNone),
486 Seq(kNone),
487 Sig(kNone)),
488 })
489 {
490 // Issuer claws it all back
491 env(tx);
492 env.close();
493 verifyCoverAmount(0);
494
495 // Deposit some back
496 env(coverDeposit(alice, keylet.key, vault.asset(6)));
497 env.close();
498 verifyCoverAmount(6);
499 }
500 }
501
502 // no-op
503 env(set(alice, vault.vaultID), kLoanBrokerId(keylet.key));
504 env.close();
505
506 // Make modifications to the broker
507 if (changeBroker)
508 changeBroker(broker);
509
510 env.close();
511
512 // Check the results of modifications
513 broker = env.le(keylet);
514 if (BEAST_EXPECT(broker) && checkChangedBroker)
515 checkChangedBroker(broker);
516
517 // Verify that fields get removed when set to default values
518 // Debt maximum: explicit 0
519 // Data: explicit empty
520 env(set(alice, vault.vaultID),
521 kLoanBrokerId(broker->key()),
522 kDebtMaximum(Number(0)),
523 kData(""));
524 env.close();
525
526 // Check the updated fields
527 broker = env.le(keylet);
528 if (BEAST_EXPECT(broker))
529 {
530 BEAST_EXPECT(!broker->isFieldPresent(sfDebtMaximum));
531 BEAST_EXPECT(!broker->isFieldPresent(sfData));
532 }
533
535 // try to delete the wrong broker object
536 env(del(alice, vault.vaultID), Ter(tecNO_ENTRY));
537 // evan tries to delete the broker
538 env(del(evan, keylet.key), Ter(tecNO_PERMISSION));
539
540 // Get the "bad" broker out of the way
541 env(del(alice, badKeylet.key));
542 env.close();
543
544 // Note alice's balance of the asset and the broker account's cover
545 // funds
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));
549 BEAST_EXPECT(coverFunds != beast::kZero);
550 verifyCoverAmount(6);
551
552 // delete the broker
553 // log << "Broker before delete: " << to_string(broker->getJson())
554 // << std::endl;
555 // if (auto const pseudo = env.le(pseudoKeylet);
556 // BEAST_EXPECT(pseudo))
557 //{
558 // log << "Pseudo-account before delete: "
559 // << to_string(pseudo->getJson()) << std::endl
560 // << std::endl;
561 //}
562
563 env(del(alice, keylet.key));
564 env.close();
565 {
566 broker = env.le(keylet);
567 BEAST_EXPECT(!broker);
568 auto const pseudo = env.le(pseudoKeylet);
569 BEAST_EXPECT(!pseudo);
570 }
571 auto const expectedBalance = aliceBalance + coverFunds -
572 (aliceBalance.value().native() ? STAmount(env.current()->fees().base.value())
573 : vault.asset(0));
574 env.require(jtx::Balance(alice, expectedBalance));
575 env.require(jtx::Balance(pseudoAccount, vault.asset(kNone)));
576 }
577 }
578
579 void
581 {
582 testcase("Lifecycle");
583 using namespace jtx;
584
585 // Create 3 loan brokers: one for XRP, one for an IOU, and one for an
586 // MPT. That'll require three corresponding SAVs.
587 Env env(*this, all_);
588
589 Account const issuer{"issuer"};
590 // For simplicity, alice will be the sole actor for the vault & brokers.
591 Account const alice{"alice"};
592 // Evan will attempt to be naughty
593 Account const evan{"evan"};
594 // Bystander doesn't have anything to do with the SAV or Broker, or any
595 // of the relevant tokens
596 Account const bystander{"bystander"};
597 Vault vault{env};
598
599 // Fund the accounts and trust lines with the same amount so that tests
600 // can use the same values regardless of the asset.
601 env.fund(XRP(100'000), issuer, noripple(alice, evan, bystander));
602 env.close();
603
604 env(fset(issuer, asfAllowTrustLineClawback));
605 env.close();
606
607 // Create assets
608 PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
609 PrettyAsset const iouAsset = issuer["IOU"];
610 env(trust(alice, iouAsset(1'000'000)));
611 env(trust(evan, iouAsset(1'000'000)));
612 env.close();
613 env(pay(issuer, evan, iouAsset(100'000)));
614 env(pay(issuer, alice, iouAsset(100'000)));
615 env.close();
616
617 MPTTester mptt{env, issuer, kMptInitNoFund};
618 mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
619 env.close();
620 PrettyAsset const mptAsset = mptt["MPT"];
621 mptt.authorize({.account = alice});
622 mptt.authorize({.account = evan});
623 env.close();
624 env(pay(issuer, alice, mptAsset(100'000)));
625 env(pay(issuer, evan, mptAsset(100'000)));
626 env.close();
627
628 std::array const assets{xrpAsset, iouAsset, mptAsset};
629
630 // Create vaults
632 for (auto const& asset : assets)
633 {
634 auto [tx, keylet] = vault.create({.owner = alice, .asset = asset});
635 env(tx);
636 env.close();
637 if (auto const le = env.le(keylet); BEAST_EXPECT(env.le(keylet)))
638 {
639 vaults.emplace_back(asset, keylet.key, le->at(sfAccount));
640 }
641
642 env(vault.deposit({.depositor = alice, .id = keylet.key, .amount = asset(50)}));
643 env.close();
644 }
645 VaultInfo const badVault = [&] -> VaultInfo {
646 auto [tx, keylet] = vault.create({.owner = alice, .asset = iouAsset});
647 env(tx);
648 env.close();
649 if (auto const le = env.le(keylet); BEAST_EXPECT(env.le(keylet)))
650 {
651 return {iouAsset, keylet.key, le->at(sfAccount)};
652 }
653 // This should never happen
654 return {iouAsset, keylet.key, evan.id()};
655 }();
656
657 auto const aliceOriginalCount = env.ownerCount(alice);
658
659 // Create and update Loan Brokers
660 for (auto const& vault : vaults)
661 {
662 {
663 // Get the AccountInfo RPC result for the vault pseudo-account
664 std::string const pseudoStr = to_string(vault.pseudoAccount.id());
665 auto const accountInfo = env.rpc("account_info", pseudoStr);
666 if (BEAST_EXPECT(accountInfo.isObject()))
667 {
668 auto const& accountData = accountInfo[jss::result][jss::account_data];
669 if (BEAST_EXPECT(accountData.isObject()))
670 {
671 BEAST_EXPECT(accountData[jss::Account] == pseudoStr);
672 BEAST_EXPECT(accountData[sfVaultID] == to_string(vault.vaultID));
673 }
674 auto const& pseudoInfo = accountInfo[jss::result][jss::pseudo_account];
675 if (BEAST_EXPECT(pseudoInfo.isObject()))
676 {
677 BEAST_EXPECT(pseudoInfo[jss::type] == "Vault");
678 }
679 }
680 }
681
682 using namespace loan_broker;
683 using namespace xrpl::lending;
684
685 TenthBips32 const tenthBipsZero{0};
686
687 auto const badKeylet = keylet::vault(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
688 // Try some failure cases
689 // not the vault owner
690 env(set(evan, vault.vaultID), Ter(tecNO_PERMISSION));
691 // not a vault
692 env(set(alice, badKeylet.key), Ter(tecNO_ENTRY));
693 // flags are checked first
694 env(set(evan, vault.vaultID, ~tfUniversal), Ter(temINVALID_FLAG));
695 // field length validation
696 // sfData: good length, bad account
697 env(set(evan, vault.vaultID),
700 // sfData: too long
701 env(set(evan, vault.vaultID),
703 Ter(temINVALID));
704 // sfManagementFeeRate: good value, bad account
705 env(set(evan, vault.vaultID),
706 kManagementFeeRate(kMaxManagementFeeRate),
708 // sfManagementFeeRate: too big
709 env(set(evan, vault.vaultID),
710 kManagementFeeRate(kMaxManagementFeeRate + TenthBips16(10)),
711 Ter(temINVALID));
712 // sfCoverRateMinimum and sfCoverRateLiquidation are linked
713 // Cover: good value, bad account
714 env(set(evan, vault.vaultID),
715 kCoverRateMinimum(kMaxCoverRate),
716 kCoverRateLiquidation(kMaxCoverRate),
718 // CoverMinimum: too big
719 env(set(evan, vault.vaultID),
720 kCoverRateMinimum(kMaxCoverRate + 1),
721 kCoverRateLiquidation(kMaxCoverRate + 1),
722 Ter(temINVALID));
723 // CoverLiquidation: too big
724 env(set(evan, vault.vaultID),
725 kCoverRateMinimum(kMaxCoverRate / 2),
726 kCoverRateLiquidation(kMaxCoverRate + 1),
727 Ter(temINVALID));
728 // Cover: zero min, non-zero liquidation - implicit and
729 // explicit zero values.
730 env(set(evan, vault.vaultID), kCoverRateLiquidation(kMaxCoverRate), Ter(temINVALID));
731 env(set(evan, vault.vaultID),
732 kCoverRateMinimum(tenthBipsZero),
733 kCoverRateLiquidation(kMaxCoverRate),
734 Ter(temINVALID));
735 // Cover: non-zero min, zero liquidation - implicit and
736 // explicit zero values.
737 env(set(evan, vault.vaultID), kCoverRateMinimum(kMaxCoverRate), Ter(temINVALID));
738 env(set(evan, vault.vaultID),
739 kCoverRateMinimum(kMaxCoverRate),
740 kCoverRateLiquidation(tenthBipsZero),
741 Ter(temINVALID));
742 // sfDebtMaximum: good value, bad account
743 env(set(evan, vault.vaultID), kDebtMaximum(Number(0)), Ter(tecNO_PERMISSION));
744 // sfDebtMaximum: overflow
745 env(set(evan, vault.vaultID), kDebtMaximum(Number(1, 100)), Ter(temINVALID));
746 // sfDebtMaximum: negative
747 env(set(evan, vault.vaultID), kDebtMaximum(Number(-1)), Ter(temINVALID));
748
749 std::string testData;
750 lifecycle(
751 "default fields",
752 env,
753 issuer,
754 alice,
755 evan,
756 bystander,
757 vault,
758 badVault,
759 // No modifications
760 {},
761 [&](SLE::ConstRef broker) {
762 // Extra checks
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);
771
772 BEAST_EXPECT(env.ownerCount(alice) == aliceOriginalCount + 4);
773 },
774 [&](SLE::ConstRef broker) {
775 // Modifications
776
777 // Update the fields
778 auto const nextKeylet =
779 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
780
781 // fields that can't be changed
782 // LoanBrokerID
783 env(set(alice, vault.vaultID), kLoanBrokerId(nextKeylet.key), Ter(tecNO_ENTRY));
784 // VaultID
785 env(set(alice, nextKeylet.key), kLoanBrokerId(broker->key()), Ter(tecNO_ENTRY));
786 // Owner
787 env(set(evan, vault.vaultID),
788 kLoanBrokerId(broker->key()),
790 // ManagementFeeRate
791 env(set(alice, vault.vaultID),
792 kLoanBrokerId(broker->key()),
793 kManagementFeeRate(kMaxManagementFeeRate),
794 Ter(temINVALID));
795 // CoverRateMinimum
796 env(set(alice, vault.vaultID),
797 kLoanBrokerId(broker->key()),
798 kCoverRateMinimum(kMaxManagementFeeRate),
799 Ter(temINVALID));
800 // CoverRateLiquidation
801 env(set(alice, vault.vaultID),
802 kLoanBrokerId(broker->key()),
803 kCoverRateLiquidation(kMaxManagementFeeRate),
804 Ter(temINVALID));
805
806 // fields that can be changed
807 testData = "Test Data 1234";
808 // Bad data: too long
809 env(set(alice, vault.vaultID),
810 kLoanBrokerId(broker->key()),
812 Ter(temINVALID));
813
814 // Bad debt maximum
815 env(set(alice, vault.vaultID),
816 kLoanBrokerId(broker->key()),
817 kDebtMaximum(Number(-175, -1)),
818 Ter(temINVALID));
819 Number debtMax{175, -1};
820 if (vault.asset.integral())
821 {
822 env(set(alice, vault.vaultID),
823 kLoanBrokerId(broker->key()),
824 kData(testData),
825 kDebtMaximum(debtMax),
827 roundToAsset(vault.asset, debtMax);
828 }
829 // Data & Debt maximum
830 env(set(alice, vault.vaultID),
831 kLoanBrokerId(broker->key()),
832 kData(testData),
833 kDebtMaximum(debtMax));
834 },
835 [&](SLE::ConstRef broker) {
836 // Check the updated fields
837 BEAST_EXPECT(checkVL(broker->at(sfData), testData));
838 Number const expected = STAmount{vault.asset, Number(175, -1)};
839 auto const actual = broker->at(sfDebtMaximum);
840 BEAST_EXPECTS(
841 actual == expected,
842 "Expected: " + to_string(expected) + ", Actual: " + to_string(actual));
843 });
844
845 lifecycle(
846 "non-default fields",
847 env,
848 issuer,
849 alice,
850 evan,
851 bystander,
852 vault,
853 badVault,
854 [&](jtx::JTx const& jv) {
855 testData = "spam spam spam spam";
856 // Finally, create another Loan Broker with kNone of the
857 // values at default
858 return env.jt(
859 jv,
860 kData(testData),
861 kManagementFeeRate(TenthBips16(123)),
862 kDebtMaximum(Number(9)),
863 kCoverRateMinimum(TenthBips32(100)),
864 kCoverRateLiquidation(TenthBips32(200)));
865 },
866 [&](SLE::ConstRef broker) {
867 // Extra checks
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));
873 },
874 [&](SLE::ConstRef broker) {
875 // Reset Data & Debt maximum to default values
876 env(set(alice, vault.vaultID),
877 kLoanBrokerId(broker->key()),
878 kData(""),
879 kDebtMaximum(Number(0)));
880 },
881 [&](SLE::ConstRef broker) {
882 // Check the updated fields
883 BEAST_EXPECT(!broker->isFieldPresent(sfData));
884 BEAST_EXPECT(!broker->isFieldPresent(sfDebtMaximum));
885 });
886 }
887
888 BEAST_EXPECT(env.ownerCount(alice) == aliceOriginalCount);
889 }
890
892
893 void
896 getAsset,
897 LoanBrokerTest brokerTest)
898 {
899 using namespace jtx;
900 using namespace loan_broker;
901 Account const issuer{"issuer"};
902 Account const alice{"alice"};
903 Env env(*this, all_);
904 Vault const vault{env};
905
906 env.fund(XRP(100'000), issuer, alice);
907 env.close();
908
909 PrettyAsset const asset = [&] {
910 if (getAsset)
911 return getAsset(env, issuer, alice);
912 env(trust(alice, issuer["IOU"](1'000'000)));
913 env.close();
914 return PrettyAsset(issuer["IOU"]);
915 }();
916
917 env(pay(issuer, alice, asset(100'000)));
918 env.close();
919
920 auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
921 env(tx);
922 env.close();
923 auto const le = env.le(vaultKeylet);
924 VaultInfo vaultInfo = [&] {
925 if (BEAST_EXPECT(le))
926 return VaultInfo{asset, vaultKeylet.key, le->at(sfAccount)};
927 return VaultInfo{asset, {}, {}};
928 }();
929 if (vaultInfo.vaultID == UInt256{})
930 return;
931
932 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(50)}));
933 env.close();
934
935 auto const brokerKeylet =
936 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
937 env(set(alice, vaultInfo.vaultID));
938 env.close();
939
940 auto const broker = env.le(brokerKeylet);
941 if (!BEAST_EXPECT(broker))
942 return;
943
944 auto const testZeroBrokerID = [&](auto&& getTxJv) {
945 auto jv = getTxJv();
946 // empty broker ID
947 jv[sfLoanBrokerID] = "";
948 env(jv, Ter(temINVALID));
949 // zero broker ID
950 jv[sfLoanBrokerID] = to_string(UInt256{});
951 // needs a flag to distinguish the parsed STTx from the prior
952 // test
954 };
955 auto const testZeroVaultID = [&](auto&& getTxJv) {
956 auto jv = getTxJv();
957 // empty broker ID
958 jv[sfVaultID] = "";
959 env(jv, Ter(temINVALID));
960 // zero broker ID
961 jv[sfVaultID] = to_string(UInt256{});
962 // needs a flag to distinguish the parsed STTx from the prior
963 // test
965 };
966
967 if (brokerTest == LoanBrokerTest::CoverDeposit)
968 {
969 // preflight: temINVALID (empty/zero broker id)
970 testZeroBrokerID([&] { return coverDeposit(alice, brokerKeylet.key, asset(10)); });
971
972 // preclaim: tecWRONG_ASSET
973 env(coverDeposit(alice, brokerKeylet.key, issuer["BAD"](10)), Ter(tecWRONG_ASSET));
974
975 // preclaim: tecINSUFFICIENT_FUNDS
976 env(pay(alice, issuer, asset(100'000 - 50)));
977 env.close();
978 env(coverDeposit(alice, brokerKeylet.key, vaultInfo.asset(10)),
980 // Freeze/lock tests are in testCoverDepositFreezes/testCoverWithdrawFreezes
981 }
982 else
983 {
984 // Fund the cover deposit
985 env(coverDeposit(alice, brokerKeylet.key, vaultInfo.asset(10)));
986 }
987 env.close();
988
989 if (brokerTest == LoanBrokerTest::CoverWithdraw)
990 {
991 // preflight: temINVALID (empty/zero broker id)
992 testZeroBrokerID([&] { return coverWithdraw(alice, brokerKeylet.key, asset(10)); });
993
994 // preclaim: tecWRONG_ASSET
995 env(coverWithdraw(alice, brokerKeylet.key, issuer["BAD"](10)), Ter(tecWRONG_ASSET));
996
997 // preclaim: tecNO_DST
998 Account const bogus{"bogus"};
999 env(coverWithdraw(alice, brokerKeylet.key, asset(10)),
1000 kDestination(bogus),
1001 Ter(tecNO_DST));
1002
1003 // preclaim: tecDST_TAG_NEEDED
1004 Account const dest{"dest"};
1005 env.fund(XRP(1'000), dest);
1006
1007 env(fset(dest, asfRequireDest));
1008 env(coverWithdraw(alice, brokerKeylet.key, asset(10)),
1009 kDestination(dest),
1011 env(fclear(dest, asfRequireDest));
1012
1013 // preclaim: tecNO_PERMISSION
1014 env(fset(dest, asfDepositAuth));
1015 env(coverWithdraw(alice, brokerKeylet.key, asset(10)),
1016 kDestination(dest),
1018 env(fclear(dest, asfDepositAuth));
1019 // Freeze/lock tests are in testCoverDepositFreezes/testCoverWithdrawFreezes
1020
1021 // preclaim: tecPSEUDO_ACCOUNT
1022 env(coverWithdraw(alice, brokerKeylet.key, asset(10)),
1023 kDestination(vaultInfo.pseudoAccount),
1025 }
1026
1027 if (brokerTest == LoanBrokerTest::CoverClawback)
1028 {
1029 // preflight: temINVALID (empty/zero broker id)
1030 testZeroBrokerID([&] {
1031 return env.json(
1032 coverClawback(alice),
1033 kLoanBrokerId(brokerKeylet.key),
1034 kAmount(vaultInfo.asset(2)));
1035 });
1036
1037 if (asset.holds<Issue>())
1038 {
1039 // preclaim: AllowTrustLineClawback is not set
1040 env(coverClawback(issuer),
1041 kLoanBrokerId(brokerKeylet.key),
1042 kAmount(vaultInfo.asset(2)),
1044
1045 // preclaim: NoFreeze is set
1046 env(fset(issuer, asfAllowTrustLineClawback | asfNoFreeze));
1047 env.close();
1048 env(coverClawback(issuer),
1049 kLoanBrokerId(brokerKeylet.key),
1050 kAmount(vaultInfo.asset(2)),
1052 }
1053 else
1054 {
1055 // preclaim: MPTCanClawback is not set or MPTCanLock is not set
1056 env(coverClawback(issuer),
1057 kLoanBrokerId(brokerKeylet.key),
1058 kAmount(vaultInfo.asset(2)),
1060 }
1061 env.close();
1062 }
1063
1064 if (brokerTest == LoanBrokerTest::Delete)
1065 {
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),
1070 Fee(env.current()->fees().base * 2));
1071
1072 // preflight: temINVALID (empty/zero broker id)
1073 testZeroBrokerID([&] { return del(alice, brokerKeylet.key); });
1074
1075 // preclaim: tecHAS_OBLIGATIONS
1076 env(del(alice, brokerKeylet.key), Ter(tecHAS_OBLIGATIONS));
1077
1078 // Repay and delete the loan
1079 auto const loanKeylet = keylet::loan(brokerKeylet.key, SeqProxy::rawSequence(1));
1080 env(loan::pay(borrower, loanKeylet.key, asset(50).value()));
1081 env(loan::del(alice, loanKeylet.key));
1082
1083 env(trust(issuer, asset(0), alice, tfSetFreeze | tfSetDeepFreeze));
1084 // preclaim: tecFROZEN (deep frozen)
1085 env(del(alice, brokerKeylet.key), Ter(tecFROZEN));
1086 env(trust(issuer, asset(0), alice, tfClearFreeze | tfClearDeepFreeze));
1087
1088 // successful delete the loan broker object
1089 env(del(alice, brokerKeylet.key), Ter(tesSUCCESS));
1090 }
1091 else
1092 {
1093 env(del(alice, brokerKeylet.key));
1094 }
1095
1096 if (brokerTest == LoanBrokerTest::Set)
1097 {
1098 // preflight: temINVALID (empty/zero broker id)
1099 testZeroBrokerID([&] {
1100 return env.json(set(alice, vaultInfo.vaultID), kLoanBrokerId(brokerKeylet.key));
1101 });
1102 // preflight: temINVALID (empty/zero vault id)
1103 testZeroVaultID([&] {
1104 return env.json(set(alice, vaultInfo.vaultID), kLoanBrokerId(brokerKeylet.key));
1105 });
1106
1107 if (asset.holds<Issue>())
1108 {
1109 env(fclear(issuer, asfDefaultRipple));
1110 env.close();
1111 // preclaim: DefaultRipple is not set
1112 env(set(alice, vaultInfo.vaultID), Ter(terNO_RIPPLE));
1113
1114 env(fset(issuer, asfDefaultRipple));
1115 env.close();
1116 }
1117
1118 auto const amt =
1119 env.balance(alice) - accountReserve(*env.current(), alice.id(), env.journal);
1120 env(pay(alice, issuer, amt));
1121
1122 // preclaim:: tecINSUFFICIENT_RESERVE
1123 env(set(alice, vaultInfo.vaultID), Ter(tecINSUFFICIENT_RESERVE));
1124 }
1125 }
1126
1127 void
1129 {
1130 testcase("Invalid LoanBrokerCoverClawback");
1131 using namespace jtx;
1132 using namespace loan_broker;
1133
1134 // preflight
1135 {
1136 Account const alice{"alice"};
1137 Account const issuer{"issuer"};
1138 auto const usd = alice["USD"];
1139 Env env(*this, all_);
1140 env.fund(XRP(100'000), alice);
1141 env.close();
1142
1143 auto jtx = env.jt(coverClawback(alice), kAmount(usd(100)));
1144
1145 // holder == account
1146 env(jtx, Ter(temINVALID));
1147
1148 // holder == beast::kZero
1149 STAmount const bad(Issue{usd.currency, beast::kZero}, 100);
1150 jtx.jv[sfAmount] = bad.getJson();
1151 jtx.stx = env.ust(jtx);
1152 Serializer s;
1153 jtx.stx->add(s);
1154 auto const jrr = env.rpc("submit", strHex(s.slice()))[jss::result];
1155 // fails in doSubmit() on STTx construction
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");
1160 }
1161
1162 // preclaim
1163
1164 // Issue:
1165 // AllowTrustLineClawback is not set or NoFreeze is set
1167
1168 // MPTIssue:
1169 // MPTCanClawback is not set
1171 [&](Env& env, Account const& issuer, Account const& alice) -> MPT {
1172 MPTTester const mpt({.env = env, .issuer = issuer, .holders = {alice}});
1173 return mpt;
1174 },
1176 }
1177
1178 void
1180 {
1181 testcase("Invalid LoanBrokerCoverDeposit");
1182 using namespace jtx;
1183
1184 // preclaim:
1185 // tecWRONG_ASSET, tecINSUFFICIENT_FUNDS, frozen asset
1187 }
1188
1189 void
1191 {
1192 testcase("Invalid LoanBrokerCoverWithdraw");
1193 using namespace jtx;
1194
1195 /*
1196 preflight: illegal net
1197 isLegalNet() check is probably redundant. STAmount parsing
1198 should throw an exception on deserialize
1199
1200 preclaim: tecWRONG_ASSET, tecNO_DST, tecDST_TAG_NEEDED,
1201 tecNO_PERMISSION, checkFrozen failure, checkDeepFrozenFailure,
1202 second+third tecINSUFFICIENT_FUNDS (can this happen)?
1203 doApply: tecPATH_DRY (can it happen, funds already checked?)
1204 */
1206 }
1207
1208 void
1210 {
1211 using namespace jtx;
1212 testcase("Invalid LoanBrokerDelete");
1213 /*
1214 preclaim: tecHAS_OBLIGATIONS
1215 doApply:
1216 accountSend failure, removeEmptyHolding failure,
1217 all tecHAS_OBLIGATIONS (can any of these happen?)
1218 */
1220 }
1221
1222 void
1224 {
1225 using namespace jtx;
1226 testcase("Invalid LoanBrokerSet");
1227
1228 /*preclaim: canAddHolding failure (can it happen with MPT?
1229 can't create Vault if CanTransfer is not enabled.)
1230 doApply:
1231 first+second dirLink failure, createPseudoAccount failure,
1232 addEmptyHolding failure
1233 can any of these happen?
1234 */
1236 }
1237
1238 void
1240 {
1241 // This test is lifted directly from
1242 // https://bugs.immunefi.com/dashboard/submission/57808
1243 using namespace jtx;
1244 Env env(*this, all_);
1245
1246 Account const alice{"alice"};
1247 env.fund(XRP(10000), alice);
1248 env.close();
1249
1250 // Create a Vault owned by alice with an XRP asset
1251 PrettyAsset const asset{xrpIssue(), 1};
1252 Vault const vault{env};
1253 auto const [createTx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
1254 env(createTx);
1255 env.close();
1256
1257 // Predict LoanBroker key using alice's current sequence BEFORE submit
1258 auto const brokerKeylet =
1259 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
1260
1261 // Create LoanBroker pointing to the vault
1262 env(loan_broker::set(alice, vaultKeylet.key));
1263 env.close();
1264
1265 // Build the CoverDeposit STTx directly
1266 STTx tx{ttLOAN_BROKER_COVER_DEPOSIT, [](STObject&) {}};
1267 tx.setAccountID(sfAccount, alice.id());
1268 tx.setFieldH256(sfLoanBrokerID, brokerKeylet.key);
1269 tx.setFieldAmount(sfAmount, asset(1));
1270
1271 // Create a writable view cloned from the current ledger and remove the
1272 // vault SLE
1273 OpenView ov{*env.current()};
1275 beast::Journal const jlog{sink};
1276 ApplyContext ac{env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
1277
1278 if (auto const sleBroker = ac.view().peek(keylet::loanBroker(brokerKeylet.key)))
1279 {
1280 auto const vaultID = (*sleBroker)[sfVaultID];
1281 if (auto const sleVault = ac.view().peek(keylet::vault(vaultID)))
1282 {
1283 ac.view().erase(sleVault);
1284 }
1285 }
1286
1287 // Invoke preclaim against the mutated (ApplyView) view; triggers
1288 // nullptr deref
1289 PreclaimContext const pctx{env.app(), ac.view(), tesSUCCESS, tx, TapNone, jlog};
1291 }
1292
1293 void
1295 {
1296 testcase("Require Auth - Implicit Pseudo-account authorization");
1297 using namespace jtx;
1298 using namespace loan_broker;
1299
1300 Account const issuer{"issuer"};
1301 Account const alice{"alice"};
1302 Env env(*this, all_);
1303 Vault vault{env};
1304
1305 env.fund(XRP(100'000), issuer, alice);
1306 env.close();
1307
1308 auto asset = MPTTester({
1309 .env = env,
1310 .issuer = issuer,
1311 .holders = {alice},
1312 .flags = kMptDexFlags | tfMPTRequireAuth | tfMPTCanClawback | tfMPTCanLock,
1313 .authHolder = true,
1314 });
1315
1316 env(pay(issuer, alice, asset(100'000)));
1317 env.close();
1318
1319 // Alice is not authorized, can still create the vault
1320 asset.authorize({.account = issuer, .holder = alice, .flags = tfMPTUnauthorize});
1321 auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
1322 env(tx);
1323 env.close();
1324
1325 auto const le = env.le(vaultKeylet);
1326 VaultInfo vaultInfo = [&] {
1327 if (BEAST_EXPECT(le))
1328 return VaultInfo{asset, vaultKeylet.key, le->at(sfAccount)};
1329 return VaultInfo{asset, {}, {}};
1330 }();
1331 if (vaultInfo.vaultID == UInt256{})
1332 return;
1333
1334 // Can't unauthorize Vault pseudo-account
1335 asset.authorize({
1336 .account = issuer,
1337 .holder = vaultInfo.pseudoAccount,
1338 .flags = tfMPTUnauthorize,
1339 .err = tecNO_PERMISSION,
1340 });
1341
1342 auto const forUnauthAuth = [&](auto&& doTx) {
1343 for (auto const flag : {tfMPTUnauthorize, 0u})
1344 {
1345 asset.authorize({.account = issuer, .holder = alice, .flags = flag});
1346 env.close();
1347 doTx(flag == 0);
1348 env.close();
1349 }
1350 };
1351
1352 // Can't deposit into Vault if the vault owner is not authorized
1353 forUnauthAuth([&](bool authorized) {
1354 auto const err = !authorized ? Ter(tecNO_AUTH) : Ter(tesSUCCESS);
1355 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(51)}),
1356 err);
1357 });
1358
1359 // Can't withdraw from Vault if the vault owner is not authorized
1360 forUnauthAuth([&](bool authorized) {
1361 auto const err = !authorized ? Ter(tecNO_AUTH) : Ter(tesSUCCESS);
1362 env(vault.withdraw({.depositor = alice, .id = vaultKeylet.key, .amount = asset(1)}),
1363 err);
1364 });
1365
1366 auto const brokerKeylet =
1367 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
1368 // Can create LoanBroker if the vault owner is not authorized
1369 forUnauthAuth([&](auto) { env(set(alice, vaultInfo.vaultID)); });
1370
1371 auto const broker = env.le(brokerKeylet);
1372 if (!BEAST_EXPECT(broker))
1373 return;
1374 Account const brokerPseudo("pseudo", broker->at(sfAccount));
1375
1376 // Can't unauthorize LoanBroker pseudo-account
1377 asset.authorize({
1378 .account = issuer,
1379 .holder = brokerPseudo,
1380 .flags = tfMPTUnauthorize,
1381 .err = tecNO_PERMISSION,
1382 });
1383
1384 // Can't cover deposit into Vault if the vault owner is not authorized
1385 forUnauthAuth([&](bool authorized) {
1386 auto const err = !authorized ? Ter(tecNO_AUTH) : Ter(tesSUCCESS);
1387 env(coverDeposit(alice, brokerKeylet.key, vaultInfo.asset(10)), err);
1388 });
1389
1390 // Can't cover withdraw from Vault if the vault owner is not authorized
1391 forUnauthAuth([&](bool authorized) {
1392 auto const err = !authorized ? Ter(tecNO_AUTH) : Ter(tesSUCCESS);
1393 env(coverWithdraw(alice, brokerKeylet.key, vaultInfo.asset(5)), err);
1394 });
1395
1396 // Issuer can always cover clawback. The holder authorization is n/a.
1397 forUnauthAuth([&](bool) {
1398 env(coverClawback(issuer),
1399 kLoanBrokerId(brokerKeylet.key),
1400 kAmount(vaultInfo.asset(1)));
1401 });
1402 }
1403
1404 void
1406 {
1407 testcase("testLoanBrokerSetDebtMaximum");
1408 using namespace jtx;
1409 using namespace loan_broker;
1410 Account const issuer{"issuer"};
1411 Account const alice{"alice"};
1412 Env env(*this, all_);
1413 Vault const vault{env};
1414
1415 env.fund(XRP(100'000), issuer, alice);
1416 env.close();
1417
1418 PrettyAsset const asset = [&] {
1419 MPTTester mptt{env, issuer, kMptInitNoFund};
1420 mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
1421 env.close();
1422 PrettyAsset const mptAsset = mptt["MPT"];
1423 mptt.authorize({.account = alice});
1424 env.close();
1425 return mptAsset;
1426 }();
1427
1428 env(pay(issuer, alice, asset(100'000)));
1429 env.close();
1430
1431 auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
1432 env(tx);
1433 env.close();
1434 auto const le = env.le(vaultKeylet);
1435 VaultInfo const vaultInfo = [&] {
1436 if (BEAST_EXPECT(le))
1437 return VaultInfo{asset, vaultKeylet.key, le->at(sfAccount)};
1438 return VaultInfo{asset, {}, {}};
1439 }();
1440 if (vaultInfo.vaultID == UInt256{})
1441 return;
1442
1443 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(50)}));
1444 env.close();
1445
1446 auto const brokerKeylet =
1447 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
1448 env(set(alice, vaultInfo.vaultID));
1449 env.close();
1450
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),
1455 Fee(env.current()->fees().base * 2));
1456 auto const broker = env.le(brokerKeylet);
1457 if (!BEAST_EXPECT(broker))
1458 return;
1459
1460 BEAST_EXPECT(broker->at(sfDebtTotal) == 50);
1461 auto const debtTotal = broker->at(sfDebtTotal);
1462
1463 auto tx2 = set(alice, vaultInfo.vaultID);
1464 tx2[sfLoanBrokerID] = to_string(brokerKeylet.key);
1465 tx2[sfDebtMaximum] = debtTotal - 1;
1466 env(tx2, Ter(tecLIMIT_EXCEEDED));
1467
1468 tx2[sfDebtMaximum] = debtTotal + 1;
1469 env(tx2, Ter(tesSUCCESS));
1470
1471 tx2[sfDebtMaximum] = 0;
1472 env(tx2, Ter(tesSUCCESS));
1473
1474 tx2[sfDebtMaximum] = json::Value::kMaxInt;
1475 env(tx2, Ter(tesSUCCESS));
1476
1477 {
1478 auto const dm = power(2, 64) - 1;
1479 BEAST_EXPECT(dm > kMaxMpTokenAmount);
1480 tx2[sfDebtMaximum] = dm;
1481 env(tx2, Ter(temINVALID));
1482 }
1483
1484 env.setParseFailureExpected(true);
1485 try
1486 {
1487 tx2[sfDebtMaximum] = "9223372036854775808";
1488 env(tx2, Ter(temINVALID));
1489 // should throw in parser
1490 fail();
1491 }
1492 catch (std::exception const& e)
1493 {
1494 BEAST_EXPECT(
1495 std::string(e.what()) ==
1496 "invalidParamsField 'tx_json.DebtMaximum' has invalid data.");
1497 }
1498 env.setParseFailureExpected(false);
1499
1501 {
1502 // For the Large330 scale, 2^63 rounds _down_ to Number::kMaxRep
1503 {
1504 auto const dm = power(2, 63);
1505 BEAST_EXPECTS(dm == kMaxMpTokenAmount, to_string(dm));
1506 tx2[sfDebtMaximum] = dm;
1507 env(tx2, Ter(tesSUCCESS));
1508 }
1509
1510 {
1511 auto const dm = power(2, 63) + Number{1, -1};
1512 BEAST_EXPECTS(dm == kMaxMpTokenAmount, to_string(dm));
1513 tx2[sfDebtMaximum] = dm;
1514 env(tx2, Ter(tesSUCCESS));
1515 }
1516
1517 {
1518 auto const dm = power(2, 63) - 1;
1519 BEAST_EXPECTS(dm < kMaxMpTokenAmount, to_string(dm));
1520 tx2[sfDebtMaximum] = dm;
1521 env(tx2, Ter(tesSUCCESS));
1522 }
1523
1524 {
1525 auto const dm = power(2, 63) - 3;
1526 BEAST_EXPECTS(dm < kMaxMpTokenAmount, to_string(dm));
1527 tx2[sfDebtMaximum] = dm;
1528 env(tx2, Ter(tesSUCCESS));
1529 }
1530
1531 {
1532 auto const dm = power(2, 63) + 3;
1533 BEAST_EXPECTS(dm > kMaxMpTokenAmount, to_string(dm));
1534 tx2[sfDebtMaximum] = dm;
1535 env(tx2, Ter(temINVALID));
1536 }
1537 }
1538 else
1539 {
1540 // For other scales, 2^63 rounds _up_ to Number::kMaxRepUp. Subtracting 1 rounds up
1541 // again.
1542 {
1543 auto const dm = power(2, 63) - 1;
1544 BEAST_EXPECTS(dm > kMaxMpTokenAmount, to_string(dm));
1545 tx2[sfDebtMaximum] = dm;
1546 env(tx2, Ter(temINVALID));
1547 }
1548
1549 {
1550 auto const dm = power(2, 63) - 3;
1551 BEAST_EXPECTS(dm == kMaxMpTokenAmount, to_string(dm));
1552 tx2[sfDebtMaximum] = dm;
1553 env(tx2, Ter(tesSUCCESS));
1554 }
1555 }
1556
1557 {
1558 auto const dm = 2 * (power(2, 62) - 1) + 1;
1559 BEAST_EXPECTS(dm == kMaxMpTokenAmount, to_string(dm));
1560 tx2[sfDebtMaximum] = dm;
1561 env(tx2, Ter(tesSUCCESS));
1562 }
1563
1564 tx2[sfDebtMaximum] = Number{9223372036854775807, 0};
1565 env(tx2, Ter(tesSUCCESS));
1566 }
1567
1568 void
1570 {
1571 testcase << "RIPD-4323";
1572 using namespace jtx;
1573 Account const issuer("issuer");
1574 Account const holder("holder");
1575 Account const& broker = issuer;
1576
1577 auto const test = [&](auto&& getToken) {
1578 Env env(*this, all_);
1579
1580 env.fund(XRP(1'000), issuer, holder);
1581 env.close();
1582
1583 auto const [token, deposit, err] = getToken(env);
1584
1585 Vault const vault(env);
1586 auto const [tx, keylet] = vault.create({.owner = broker, .asset = token.asset()});
1587 env(tx);
1588 env.close();
1589
1590 env(vault.deposit({.depositor = broker, .id = keylet.key, .amount = deposit}),
1591 Ter(err));
1592 env.close();
1593
1594 auto const brokerKeylet =
1595 keylet::loanBroker(broker, SeqProxy::rawSequence(env.seq(broker)));
1596
1597 env(loan_broker::set(broker, keylet.key));
1598 env.close();
1599
1600 env(loan_broker::coverDeposit(broker, brokerKeylet.key, deposit), Ter(err));
1601 env.close();
1602 };
1603
1604 test([&](Env&) {
1605 // issuer can issue any amount
1606 auto const token = issuer["IOU"];
1607 return std::make_tuple(token, token(1'000), tesSUCCESS);
1608 });
1610 std::uint64_t, // pay to holder
1611 std::optional<std::uint64_t>, // max amount
1612 std::uint64_t, // deposit amount
1613 TER>> // expected error
1614 const mptTests = {
1615 // issuer can issue up to 2'000 tokens
1616 {2'000, 4'000, 1'000, tesSUCCESS},
1617 // issuer can issue 500 tokens (250 VaultDeposit +
1618 // 250 LoanBrokerCoverDeposit)
1619 {2'000, 2'500, 250, tesSUCCESS},
1620 // issuer can issue 500 tokens (250 VaultDeposit +
1621 // 250 LoanBrokerCoverDeposit). MaximumAmount is default.
1622 {kMaxMpTokenAmount - 500, std::nullopt, 250, tesSUCCESS},
1623 // issuer can issue 500, and fails on depositing 1'000
1624 {2'000, 2'500, 1'000, tecINSUFFICIENT_FUNDS},
1625 // issuer has already issued MaximumAmount
1626 {2'000, 2'000, 1'000, tecINSUFFICIENT_FUNDS},
1627 // issuer has already issued MaximumAmount. MaximumAmount is
1628 // default.
1629 {kMaxMpTokenAmount, std::nullopt, 250, tecINSUFFICIENT_FUNDS},
1630 };
1631 for (auto const& [pay, max, deposit, err] : mptTests)
1632 {
1634 MPT const token = MPTTester({
1635 .env = env,
1636 .issuer = issuer,
1637 .holders = {holder},
1638 .pay = pay,
1639 .flags = kMptDexFlags,
1640 .maxAmt = max,
1641 });
1642 return std::make_tuple(token, token(deposit), err);
1643 });
1644 }
1645 }
1646
1647 void
1649 {
1650 testcase << "RIPD-4466 - LoanBrokerSet disallows frozen vaults";
1651 using namespace jtx;
1652 Env env(*this, all_);
1653
1654 Account const issuer{"issuer"}, lender{"lender"}, borrower{"borrower"};
1655 env.fund(XRP(20'000), issuer, lender, borrower);
1656 auto const iou = issuer["IOU"];
1657
1658 Vault const vault{env};
1659 auto [tx, vaultKeylet] = vault.create({.owner = lender, .asset = iou.asset()});
1660 env(tx);
1661 env.close();
1662
1663 // Get vault pseudo-account and FREEZE it
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));
1668
1669 env(loan_broker::set(lender, vaultKeylet.key), Ter(tecFROZEN));
1670 }
1671
1672 void
1674 {
1675 testcase << "LoanBrokerDelete - locked broker pseudo-account MPT";
1676 using namespace jtx;
1677 using namespace loan_broker;
1678
1679 Account const issuer("issuer");
1680 Account const alice("alice");
1681
1682 auto const withFix = features[fixCleanup3_2_0];
1683 Env env(*this, features);
1684 env.fund(XRP(100'000), issuer, alice);
1685 env.close();
1686
1687 // Create MPT with locking enabled
1688 MPTTester mptt{env, issuer, kMptInitNoFund};
1689 mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
1690
1691 PrettyAsset const mpt{mptt.issuanceID()};
1692
1693 // Fund alice
1694 mptt.authorize({.account = alice});
1695 env.close();
1696 env(pay(issuer, alice, mpt(100'000)));
1697 env.close();
1698
1699 // Create vault
1700 Vault const vault{env};
1701 auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = mpt});
1702 env(tx);
1703 env.close();
1704
1705 // Deposit into vault
1706 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = mpt(10'000)}));
1707 env.close();
1708
1709 // Create loan broker
1710 auto const brokerKeylet =
1711 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
1712 env(set(alice, vaultKeylet.key));
1713 env.close();
1714
1715 // Deposit cover
1716 env(coverDeposit(alice, brokerKeylet.key, mpt(5'000).value()));
1717 env.close();
1718
1719 // Verify cover is deposited
1720 auto const broker = env.le(brokerKeylet);
1721 if (!BEAST_EXPECT(broker))
1722 return;
1723 BEAST_EXPECT(broker->at(sfCoverAvailable) > 0);
1724
1725 // Get the broker pseudo-account ID
1726 auto const brokerPseudoID = broker->at(sfAccount);
1727
1728 // Verify the broker pseudo-account has an MPToken
1729 auto const pseudoMptKey = keylet::mptoken(mptt.issuanceID(), brokerPseudoID);
1730 auto const pseudoMpt = env.le(pseudoMptKey);
1731 if (!BEAST_EXPECT(pseudoMpt))
1732 return;
1733
1734 // Issuer locks the broker pseudo-account's individual MPToken
1735 {
1736 json::Value jv;
1737 jv[jss::Account] = issuer.human();
1738 jv[sfMPTokenIssuanceID] = to_string(mptt.issuanceID());
1739 jv[jss::Holder] = toBase58(brokerPseudoID);
1740 jv[jss::TransactionType] = jss::MPTokenIssuanceSet;
1741 jv[jss::Flags] = tfMPTLock;
1742 env(jv);
1743 env.close();
1744 }
1745
1746 // Verify the pseudo-account's MPToken is now locked
1747 {
1748 auto const sle = env.le(pseudoMptKey);
1749 if (!BEAST_EXPECT(sle))
1750 return;
1751 BEAST_EXPECT(sle->isFlag(lsfMPTLocked));
1752 }
1753
1754 // Record alice's balance before deletion
1755 auto const aliceBalanceBefore = env.balance(alice, mpt);
1756
1757 // With fixCleanup3_2_0, preclaim() checks the broker pseudo-account's
1758 // freeze/lock state via checkFrozen(), so deletion is blocked.
1759 // Without the fix, the check is missing and the locked cover is
1760 // returned to the owner.
1761 if (withFix)
1762 {
1763 env(del(alice, brokerKeylet.key), Ter(tecLOCKED));
1764 env.close();
1765
1766 // Verify the broker is not deleted
1767 BEAST_EXPECT(env.le(brokerKeylet) != nullptr);
1768
1769 // Verify alice did not receive the cover despite the lock
1770 auto const aliceBalanceAfter = env.balance(alice, mpt);
1771 BEAST_EXPECT(aliceBalanceAfter == aliceBalanceBefore);
1772
1773 // Verify the locked MPToken was not deleted
1774 BEAST_EXPECT(env.le(pseudoMptKey) != nullptr);
1775 }
1776 else
1777 {
1778 env(del(alice, brokerKeylet.key), Ter(tesSUCCESS));
1779 env.close();
1780
1781 // Verify the broker is deleted
1782 BEAST_EXPECT(env.le(brokerKeylet) == nullptr);
1783
1784 // Verify alice received the cover despite the lock
1785 auto const aliceBalanceAfter = env.balance(alice, mpt);
1786 BEAST_EXPECT(aliceBalanceAfter > aliceBalanceBefore);
1787
1788 // Verify the locked MPToken was deleted
1789 BEAST_EXPECT(env.le(pseudoMptKey) == nullptr);
1790 }
1791 }
1792
1793 // LoanBrokerDelete should succeed even when an unrelated third party
1794 // holds a confidential balance. The broker pseudo-account carries no
1795 // confidential fields of its own, but pre-fixCleanup3_5_0 the erase
1796 // was rejected.
1797 void
1799 {
1800 testcase << "LoanBrokerDelete - unrelated confidential holder";
1801 using namespace jtx;
1802 using namespace loan_broker;
1803
1804 auto const withFix = features[fixCleanup3_5_0];
1805
1806 Account const issuer("issuer");
1807 Account const alice("alice");
1808 // carol holds the same MPT but has no relationship to the vault, the
1809 // broker, or alice.
1810 Account const carol("carol");
1811
1812 for (bool const carolConverts : {false, true})
1813 {
1814 Env env(*this, features);
1815 env.fund(XRP(100'000), issuer, alice, carol);
1816 env.close();
1817
1818 MPTTester mptt{env, issuer, kMptInitNoFund};
1819 mptt.create({.flags = tfMPTCanTransfer | tfMPTCanHoldConfidentialBalance});
1820
1821 PrettyAsset const mpt{mptt.issuanceID()};
1822
1823 mptt.authorize({.account = alice});
1824 mptt.authorize({.account = carol});
1825 env(pay(issuer, alice, mpt(100'000)));
1826 env(pay(issuer, carol, mpt(100)));
1827 env.close();
1828
1829 // The issuer must publish an encryption key before any holder can
1830 // convert into confidential form.
1831 mptt.generateKeyPair(issuer);
1832 mptt.set({.account = issuer, .issuerPubKey = mptt.getPubKey(issuer)});
1833
1834 Vault const vault{env};
1835 auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = mpt});
1836 env(tx);
1837 env.close();
1838
1839 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = mpt(10'000)}));
1840 env.close();
1841
1842 auto const brokerKeylet =
1843 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
1844 env(set(alice, vaultKeylet.key));
1845 env.close();
1846
1847 env(coverDeposit(alice, brokerKeylet.key, mpt(5'000).value()));
1848 env.close();
1849
1850 auto const broker = env.le(brokerKeylet);
1851 if (!BEAST_EXPECT(broker))
1852 return;
1853 BEAST_EXPECT(broker->at(sfCoverAvailable) > 0);
1854
1855 auto const brokerPseudoID = broker->at(sfAccount);
1856 auto const pseudoMptKey = keylet::mptoken(mptt.issuanceID(), brokerPseudoID);
1857 if (!BEAST_EXPECT(env.le(pseudoMptKey)))
1858 return;
1859
1860 // The broker pseudo-account has no signing key, so it can never
1861 // submit a confidential transaction and its MPToken holds none of
1862 // the four ciphertext fields.
1863 Account const brokerHolder("broker", brokerPseudoID);
1864 BEAST_EXPECT(!mptt.getEncryptedBalance(brokerHolder, MPTTester::holderEncryptedInbox));
1865 BEAST_EXPECT(
1867 BEAST_EXPECT(
1869 BEAST_EXPECT(
1871
1872 if (carolConverts)
1873 {
1874 mptt.generateKeyPair(carol);
1875 mptt.convert({.account = carol, .amt = 1, .holderPubKey = mptt.getPubKey(carol)});
1876 }
1877
1878 BEAST_EXPECT(mptt.getIssuanceConfidentialBalance() == (carolConverts ? 1 : 0));
1879
1880 if (carolConverts && !withFix)
1881 {
1882 // The cover is non-zero at the start of the transaction, so
1883 // the erase is flagged and carol's COA rejects it.
1884 env(del(alice, brokerKeylet.key), Ter(tecINVARIANT_FAILED));
1885 env.close();
1886 BEAST_EXPECT(env.le(brokerKeylet) != nullptr);
1887 BEAST_EXPECT(env.le(pseudoMptKey) != nullptr);
1888
1889 // Draining the cover in an earlier transaction leaves the
1890 // MPToken's pre-transaction balance at zero, which sidesteps
1891 // the flag entirely.
1892 env(coverWithdraw(alice, brokerKeylet.key, mpt(5'000).value()));
1893 env.close();
1894 }
1895
1896 // With the fix the balance is read at erase time, so returning
1897 // the cover and deleting the broker in one transaction succeeds
1898 // regardless of carol's confidential balance.
1899 env(del(alice, brokerKeylet.key));
1900 env.close();
1901 BEAST_EXPECT(env.le(brokerKeylet) == nullptr);
1902 BEAST_EXPECT(env.le(pseudoMptKey) == nullptr);
1903 }
1904 }
1905
1906 // Alice creates a vault over `asset`, deposits 10'000 into it and creates a broker for it.
1907 // A nonzero `cover` also goes into the broker as first-loss cover.
1908 static Keylet
1910 jtx::Env& env,
1911 jtx::Account const& alice,
1912 jtx::PrettyAsset const& asset,
1913 std::int64_t cover)
1914 {
1915 using namespace jtx;
1916 using namespace loan_broker;
1917
1918 Vault const vault{env};
1919 auto const [tx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
1920 env(tx);
1921 env.close();
1922 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(10'000)}));
1923 env.close();
1924
1925 auto const brokerKeylet =
1926 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
1927 env(set(alice, vaultKeylet.key));
1928 env.close();
1929
1930 if (cover != 0)
1931 {
1932 env(coverDeposit(alice, brokerKeylet.key, asset(cover).value()));
1933 env.close();
1934 }
1935 return brokerKeylet;
1936 }
1937
1938 // Leaves alice `incrementsShort` owner reserve increments below her current reserve.
1939 // Fees can be paid out of the reserve, which is how she gets below it.
1940 static void
1942 jtx::Env& env,
1943 jtx::Account const& alice,
1944 jtx::Account const& sink,
1945 int incrementsShort)
1946 {
1947 using namespace jtx;
1948
1949 auto const fee = env.current()->fees().base;
1950 env(pay(
1951 alice,
1952 sink,
1953 env.balance(alice) - accountReserve(*env.current(), alice.id(), env.journal) - fee));
1954 if (incrementsShort > 0)
1955 env(noop(alice), Fee(env.current()->fees().increment * incrementsShort));
1956 env.close();
1957 }
1958
1959 // Expected LoanBrokerDelete results by which of fixCleanup3_5_0 and fixCleanup3_4_0 are on.
1967
1968 // The four combinations of fixCleanup3_5_0 and fixCleanup3_4_0 on top of `features`, each with
1969 // its name and expected result.
1972 {
1973 return {
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},
1977 {
1978 "neither Cleanup3.5 nor Cleanup3.4",
1979 features - fixCleanup3_5_0 - fixCleanup3_4_0,
1980 expected.neither,
1981 },
1982 };
1983 }
1984
1985 // Alice deletes her broker. On success she gets the remaining cover, in a holding that is
1986 // created only if she has none and the cover is not empty. On failure her broker, balance,
1987 // holding and owner count stay as they were.
1988 void
1990 jtx::Env& env,
1991 jtx::Account const& alice,
1992 jtx::PrettyAsset const& asset,
1993 Keylet const& brokerKeylet,
1994 TER expected)
1995 {
1996 using namespace jtx;
1997
1998 auto const broker = env.le(brokerKeylet);
1999 if (!BEAST_EXPECT(broker))
2000 return;
2001 STAmount const cover{asset.raw(), broker->at(sfCoverAvailable)};
2002 STAmount const balanceBefore = env.balance(alice, asset);
2003 auto const ownerCountBefore = env.ownerCount(alice);
2004 bool const hadHolding = holdingExists(*env.current(), alice.id(), asset);
2005
2006 env(loan_broker::del(alice, brokerKeylet.key), Ter(expected));
2007 env.close();
2008
2009 if (isTesSuccess(expected))
2010 {
2011 BEAST_EXPECT(!env.le(brokerKeylet));
2012 BEAST_EXPECT(env.balance(alice, asset) == balanceBefore + cover);
2013 bool const createsHolding = !hadHolding && cover != beast::kZero;
2014 BEAST_EXPECT(
2015 holdingExists(*env.current(), alice.id(), asset) == (hadHolding || createsHolding));
2016 // The broker and its pseudo-account are released, a new holding is counted.
2017 BEAST_EXPECT(env.ownerCount(alice) == ownerCountBefore - 2 + (createsHolding ? 1 : 0));
2018 }
2019 else
2020 {
2021 BEAST_EXPECT(env.le(brokerKeylet));
2022 BEAST_EXPECT(env.balance(alice, asset) == balanceBefore);
2023 BEAST_EXPECT(holdingExists(*env.current(), alice.id(), asset) == hadHolding);
2024 BEAST_EXPECT(env.ownerCount(alice) == ownerCountBefore);
2025 }
2026 }
2027
2028 void
2030 {
2031 testcase << "LoanBrokerDelete - frozen broker pseudo-account IOU";
2032 using namespace jtx;
2033 using namespace loan_broker;
2034
2035 Account const issuer("issuer");
2036 Account const alice("alice");
2037
2038 auto const withFix = features[fixCleanup3_2_0];
2039 std::string logs;
2040 Env env(*this, features, std::make_unique<CaptureLogs>(&logs));
2041 env.fund(XRP(100'000), issuer, alice);
2042 env.close();
2043
2044 auto const iou = issuer["IOU"];
2045
2046 // Set up trust lines and fund alice
2047 env(trust(alice, iou(1'000'000)));
2048 env.close();
2049 env(pay(issuer, alice, iou(100'000)));
2050 env.close();
2051
2052 auto const brokerKeylet = createBroker(env, alice, iou, 5'000);
2053
2054 // Verify cover is deposited
2055 auto const broker = env.le(brokerKeylet);
2056 if (!BEAST_EXPECT(broker))
2057 return;
2058 BEAST_EXPECT(broker->at(sfCoverAvailable) > 0);
2059
2060 // Get the broker pseudo-account
2061 auto const brokerPseudoID = broker->at(sfAccount);
2062 auto const brokerPseudo = Account("BrokerPseudo", brokerPseudoID);
2063
2064 // Issuer freezes the broker pseudo-account's trust line
2065 env(trust(issuer, brokerPseudo["IOU"](0), tfSetFreeze));
2066 env.close();
2067
2068 // Record alice's balance before deletion attempt
2069 auto const aliceBalanceBefore = env.balance(alice, iou);
2070
2071 // With fixCleanup3_2_0, preclaim() checks the broker
2072 // pseudo-account's freeze state via checkFrozen(), so
2073 // deletion is blocked early with tecFROZEN.
2074 // Without the fix, preclaim() does not check the pseudo-account,
2075 // but the TransfersNotFrozen invariant catches the frozen transfer
2076 // in doApply() and fails with tecINVARIANT_FAILED.
2077 // Either way, the broker survives and alice's balance is unchanged.
2078 if (withFix)
2079 {
2080 env(del(alice, brokerKeylet.key), Ter(tecFROZEN));
2081 }
2082 else
2083 {
2084 env(del(alice, brokerKeylet.key), Ter(tecINVARIANT_FAILED));
2085 }
2086 env.close();
2087
2088 // Broker still exists
2089 BEAST_EXPECT(env.le(brokerKeylet) != nullptr);
2090
2091 // Alice's balance unchanged
2092 auto const aliceBalanceAfter = env.balance(alice, iou);
2093 BEAST_EXPECT(aliceBalanceAfter == aliceBalanceBefore);
2094 }
2095
2096 // Alice puts all her IOU into a vault and the cover of her broker, changes something about the
2097 // line the cover would be paid to, and deletes the broker.
2098 void
2100 {
2101 using namespace jtx;
2102
2103 Account const issuer{"issuer"};
2104 Account const alice{"alice"};
2105 auto const iou = issuer["IOU"];
2106
2107 using IssuerStep = std::function<void(Env&)>;
2108 using Step = std::function<void(Env&, Keylet const& broker)>;
2109 struct Case
2110 {
2111 std::string name;
2112 // Runs before alice trusts the issuer.
2113 IssuerStep setupIssuer = {}; // NOLINT(readability-redundant-member-init)
2114 Step beforeCover = {}; // NOLINT(readability-redundant-member-init)
2115 Step beforeDelete = {}; // NOLINT(readability-redundant-member-init)
2116 ExpectedByCleanup expected;
2117 Step afterDelete = {}; // NOLINT(readability-redundant-member-init)
2118 };
2119
2120 auto const defaultRipple = [&](Env& env) {
2121 env(fset(issuer, asfDefaultRipple));
2122 env.close();
2123 };
2124 // With DefaultRipple set, canTransfer passes and only authorization decides.
2125 auto const requireAuth = [&](Env& env) {
2126 env(fset(issuer, asfRequireAuth));
2127 defaultRipple(env);
2128 env(trust(issuer, iou(0), alice, tfSetfAuth));
2129 env.close();
2130 };
2131
2132 // Alice spent her whole balance, so zeroing the limit deletes her line.
2133 // The cover payout would have to recreate it.
2134 auto const deleteOwnerLine = [&](Env& env, Keylet const&) {
2135 env(trust(alice, iou(0)));
2136 env.close();
2137 BEAST_EXPECT(!env.le(keylet::trustLine(alice.id(), iou.issue())));
2138 };
2139
2140 std::vector<Case> const cases{
2141 {
2142 .name = "non-rippling owner line",
2143 // Rippling can be blocked on the pseudo-account line only while it is empty.
2144 .beforeCover =
2145 [&](Env& env, Keylet const& broker) {
2146 Account const brokerPseudo{"BrokerPseudo", env.le(broker)->at(sfAccount)};
2147 env(trust(issuer, brokerPseudo["IOU"](0), tfSetNoRipple));
2148 env.close();
2149 },
2150 .beforeDelete =
2151 [&](Env& env, Keylet const&) {
2152 env(trust(issuer, alice["IOU"](0), tfSetNoRipple));
2153 env.close();
2154 },
2155 .expected =
2156 {
2157 .both = terNO_RIPPLE,
2158 .only34 = tesSUCCESS,
2159 .only35 = terNO_RIPPLE,
2160 .neither = tesSUCCESS,
2161 },
2162 },
2163 {
2164 .name = "owner line deleted",
2165 .setupIssuer = defaultRipple,
2166 .beforeDelete =
2167 [&](Env& env, Keylet const& broker) {
2168 deleteOwnerLine(env, broker);
2169 env(fset(alice, asfDefaultRipple));
2170 env.close();
2171 },
2172 .expected =
2173 {
2174 .both = tesSUCCESS,
2175 .only34 = tesSUCCESS,
2176 .only35 = tesSUCCESS,
2177 .neither = tesSUCCESS,
2178 },
2179 // Pre-Cleanup3.5 the recreated line takes NoRipple from alice's DefaultRipple.
2180 // Post-Cleanup3.5 it always has NoRipple, as on a withdrawal to self.
2181 .afterDelete =
2182 [&](Env& env, Keylet const&) {
2183 auto const line = env.le(keylet::trustLine(alice.id(), iou.issue()));
2184 if (!BEAST_EXPECT(line))
2185 return;
2186 auto const noRipple =
2187 alice.id() > issuer.id() ? lsfHighNoRipple : lsfLowNoRipple;
2188 BEAST_EXPECT(
2189 line->isFlag(noRipple) ==
2190 env.current()->rules().enabled(fixCleanup3_5_0));
2191 },
2192 },
2193 {
2194 .name = "owner line deleted, issuer clears DefaultRipple",
2195 .setupIssuer = defaultRipple,
2196 .beforeDelete =
2197 [&](Env& env, Keylet const& broker) {
2198 deleteOwnerLine(env, broker);
2199 env(fclear(issuer, asfDefaultRipple));
2200 env.close();
2201 },
2202 .expected =
2203 {
2204 .both = terNO_RIPPLE,
2205 .only34 = tesSUCCESS,
2206 .only35 = terNO_RIPPLE,
2207 .neither = tesSUCCESS,
2208 },
2209 },
2210 // Lines that exist keep rippling, so the cover can still be paid out.
2211 {
2212 .name = "issuer clears DefaultRipple",
2213 .setupIssuer = defaultRipple,
2214 .beforeDelete =
2215 [&](Env& env, Keylet const&) {
2216 env(fclear(issuer, asfDefaultRipple));
2217 env.close();
2218 },
2219 .expected =
2220 {
2221 .both = tesSUCCESS,
2222 .only34 = tesSUCCESS,
2223 .only35 = tesSUCCESS,
2224 .neither = tesSUCCESS,
2225 },
2226 },
2227 {
2228 .name = "owner line deleted, owner below reserve",
2229 .setupIssuer = defaultRipple,
2230 .beforeDelete =
2231 [&](Env& env, Keylet const& broker) {
2232 deleteOwnerLine(env, broker);
2233 // Still short after the broker's reserve is released.
2234 leaveBelowReserve(env, alice, issuer, 2);
2235 },
2236 .expected =
2237 {
2239 .only34 = tesSUCCESS,
2240 .only35 = tecNO_LINE_INSUF_RESERVE,
2241 .neither = tesSUCCESS,
2242 },
2243 },
2244 {
2245 .name = "owner line deleted, issuer requires auth",
2246 .setupIssuer = requireAuth,
2247 .beforeDelete = deleteOwnerLine,
2248 .expected =
2249 {
2250 .both = tecNO_LINE,
2251 .only34 = tesSUCCESS,
2252 .only35 = tecNO_LINE,
2253 .neither = tesSUCCESS,
2254 },
2255 },
2256 // The issuer cannot revoke IOU authorization, but a recreated line starts unauthorized.
2257 {
2258 .name = "owner line recreated unauthorized",
2259 .setupIssuer = requireAuth,
2260 .beforeDelete =
2261 [&](Env& env, Keylet const& broker) {
2262 deleteOwnerLine(env, broker);
2263 env(trust(alice, iou(10'000)));
2264 env.close();
2265 auto const line = env.le(keylet::trustLine(alice.id(), iou.issue()));
2266 if (BEAST_EXPECT(line))
2267 {
2268 BEAST_EXPECT(
2269 !line->isFlag(alice.id() > issuer.id() ? lsfLowAuth : lsfHighAuth));
2270 }
2271 },
2272 .expected =
2273 {
2274 .both = tecNO_AUTH,
2275 .only34 = tesSUCCESS,
2276 .only35 = tecNO_AUTH,
2277 .neither = tesSUCCESS,
2278 },
2279 },
2280 // Nothing is paid out, so no line is needed.
2281 {
2282 .name = "zero cover, owner line deleted",
2283 .setupIssuer = defaultRipple,
2284 .beforeDelete =
2285 [&](Env& env, Keylet const& broker) {
2286 env(loan_broker::coverWithdraw(alice, broker.key, iou(5'000)));
2287 env(pay(alice, issuer, iou(5'000)));
2288 env.close();
2289 deleteOwnerLine(env, broker);
2290 },
2291 .expected =
2292 {
2293 .both = tesSUCCESS,
2294 .only34 = tesSUCCESS,
2295 .only35 = tesSUCCESS,
2296 .neither = tesSUCCESS,
2297 },
2298 },
2299 };
2300
2301 for (auto const& c : cases)
2302 {
2303 for (auto const& [amendments, features, expected] : cleanupRuns(all_, c.expected))
2304 {
2305 testcase << "LoanBrokerDelete - IOU " << c.name << ", " << amendments;
2306
2307 Env env(*this, features);
2308 env.fund(XRP(100'000), issuer, alice);
2309 env.close();
2310
2311 if (c.setupIssuer)
2312 c.setupIssuer(env);
2313 env(trust(alice, iou(15'000)));
2314 env.close();
2315 env(pay(issuer, alice, iou(15'000)));
2316 env.close();
2317
2318 auto const broker = createBroker(env, alice, iou, 0);
2319 if (c.beforeCover)
2320 c.beforeCover(env, broker);
2321 env(loan_broker::coverDeposit(alice, broker.key, iou(5'000)));
2322 env.close();
2323 BEAST_EXPECT(env.balance(alice, iou) == beast::kZero);
2324
2325 if (c.beforeDelete)
2326 c.beforeDelete(env, broker);
2327 deleteBrokerAndCheck(env, alice, iou, broker, expected);
2328 if (c.afterDelete)
2329 c.afterDelete(env, broker);
2330 }
2331 }
2332 }
2333
2334 void
2336 {
2337 testcase << "LoanBrokerDelete - auth-required broker pseudo-account MPT "
2338 << (features[fixCleanup3_4_0] ? "post-fix" : "pre-fix");
2339 using namespace jtx;
2340 using namespace loan_broker;
2341
2342 Account const issuer("issuer");
2343 Account const alice("alice");
2344
2345 Env env(*this, features);
2346 env.fund(XRP(100'000), issuer, alice);
2347 env.close();
2348
2349 // Create an auth-required MPT and authorize alice as a holder. The
2350 // broker pseudo-account's cover MPToken is auto-created later
2351 // (addEmptyHolding -> authorizeMPToken) with lsfMPTAuthorized clear;
2352 // the pseudo-account is implicitly authorized to hold any MPT
2353 // regardless of that flag.
2354 auto const tester = MPTTester({
2355 .env = env,
2356 .issuer = issuer,
2357 .holders = {alice},
2358 .pay = 20'000,
2359 .flags = tfMPTRequireAuth | tfMPTCanTransfer,
2360 .authHolder = true,
2361 });
2362
2363 PrettyAsset const mpt{tester.issuanceID()};
2364
2365 auto const brokerKeylet = createBroker(env, alice, mpt, 5'000);
2366
2367 // Verify cover is deposited
2368 auto const broker = env.le(brokerKeylet);
2369 if (!BEAST_EXPECT(broker))
2370 return;
2371 BEAST_EXPECT(broker->at(sfCoverAvailable) > 0);
2372
2373 // Get the broker pseudo-account
2374 auto const brokerPseudoID = broker->at(sfAccount);
2375
2376 // Verify the broker pseudo-account has an MPToken, and that it was
2377 // never explicitly authorized (issuer cannot authorize a
2378 // pseudo-account holder; see MPTokenAuthorize::preclaim).
2379 auto const pseudoMptKey = keylet::mptoken(tester.issuanceID(), brokerPseudoID);
2380 auto const pseudoMpt = env.le(pseudoMptKey);
2381 if (!BEAST_EXPECT(pseudoMpt))
2382 return;
2383 BEAST_EXPECT(!pseudoMpt->isFlag(lsfMPTAuthorized));
2384
2385 // Record alice's balance before deletion
2386 auto const aliceBalanceBefore = env.balance(alice, mpt);
2387
2388 // LoanBrokerDelete sends the remaining cover out of the broker pseudo-account, deletes its
2389 // now-empty MPToken, and erases the pseudo AccountRoot. Before the fix,
2390 // ValidMPTTransfer::isAuthorized evaluates isPseudoAccount() on the post-transaction view
2391 // (where the pseudo-account is already gone) and falls back to the MPToken's
2392 // lsfMPTAuthorized flag, which was never set, so the invariant treats the broker as an
2393 // unauthorized sender and the whole transaction fails once fixCleanup3_4_0 makes the check
2394 // enforcing.
2395 env(del(alice, brokerKeylet.key), Ter(tesSUCCESS));
2396 env.close();
2397
2398 // Broker and its pseudo-account MPToken are gone
2399 BEAST_EXPECT(env.le(brokerKeylet) == nullptr);
2400 BEAST_EXPECT(env.le(pseudoMptKey) == nullptr);
2401
2402 // Alice received the cover
2403 auto const aliceBalanceAfter = env.balance(alice, mpt);
2404 BEAST_EXPECT(aliceBalanceAfter > aliceBalanceBefore);
2405 }
2406
2407 // Alice puts all her MPT into a vault and 5'000 of cover for her broker, changes something
2408 // about her MPToken or her reserve, and deletes the broker.
2409 void
2411 {
2412 using namespace jtx;
2413
2414 Account const issuer("issuer");
2415 Account const alice("alice");
2416
2417 using Step = std::function<void(Env&, MPTTester&, Keylet const& broker)>;
2418 struct Case
2419 {
2420 std::string name;
2421 std::uint32_t flags = tfMPTCanTransfer;
2422 Step beforeDelete;
2423 ExpectedByCleanup expected;
2424 };
2425
2426 auto const unauthorizeOwner = [&](Env&, MPTTester& mpt, Keylet const&) {
2427 mpt.authorize({.account = issuer, .holder = alice, .flags = tfMPTUnauthorize});
2428 };
2429 // Alice spent her whole balance, so she can delete her MPToken.
2430 auto const deleteOwnerMPToken = [&](Env& env, MPTTester& mpt, Keylet const&) {
2431 mpt.authorize({.account = alice, .flags = tfMPTUnauthorize});
2432 BEAST_EXPECT(!env.le(keylet::mptoken(mpt.issuanceID(), alice.id())));
2433 };
2434 // Alice takes her cover back and returns it to the issuer, which empties her MPToken.
2435 auto const withdrawCoverAndDeleteMPToken =
2436 [&](Env& env, MPTTester& mpt, Keylet const& broker) {
2437 PrettyAsset const asset{mpt.issuanceID()};
2438 env(loan_broker::coverWithdraw(alice, broker.key, asset(5'000).value()));
2439 env(pay(alice, issuer, asset(5'000)));
2440 env.close();
2441 deleteOwnerMPToken(env, mpt, broker);
2442 };
2443
2444 std::vector<Case> const cases{
2445 // Cleanup3.5 rejects the payout in preclaim. Before it, the enforcing
2446 // ValidMPTTransfer invariant of Cleanup3.4 is the only thing that catches it.
2447 {
2448 .name = "owner unauthorized",
2449 .flags = tfMPTRequireAuth | tfMPTCanTransfer,
2450 .beforeDelete = unauthorizeOwner,
2451 .expected =
2452 {
2453 .both = tecNO_AUTH,
2454 .only34 = tecINVARIANT_FAILED,
2455 .only35 = tecNO_AUTH,
2456 .neither = tesSUCCESS,
2457 },
2458 },
2459 // Nothing is paid out, so the owner's authorization does not matter.
2460 {
2461 .name = "owner unauthorized, zero cover",
2462 .flags = tfMPTRequireAuth | tfMPTCanTransfer | tfMPTCanClawback,
2463 .beforeDelete =
2464 [&](Env& env, MPTTester& mpt, Keylet const& broker) {
2465 unauthorizeOwner(env, mpt, broker);
2466 env(loan_broker::coverClawback(issuer),
2468 kAmount(PrettyAsset{mpt.issuanceID()}(5'000)));
2469 env.close();
2470 BEAST_EXPECT(env.le(broker)->at(sfCoverAvailable) == beast::kZero);
2471 },
2472 .expected =
2473 {
2474 .both = tesSUCCESS,
2475 .only34 = tesSUCCESS,
2476 .only35 = tesSUCCESS,
2477 .neither = tesSUCCESS,
2478 },
2479 },
2480 // Pre-Cleanup3.5 the payout fails, and alice has to authorize the MPT again first.
2481 // Post-Cleanup3.5 the payout creates her MPToken.
2482 {
2483 .name = "owner MPToken deleted",
2484 .beforeDelete = deleteOwnerMPToken,
2485 .expected =
2486 {
2487 .both = tesSUCCESS,
2488 .only34 = tecNO_AUTH,
2489 .only35 = tesSUCCESS,
2490 .neither = tecNO_AUTH,
2491 },
2492 },
2493 // The new MPToken fits only because the broker's reserve is released before it is
2494 // created.
2495 {
2496 .name = "owner MPToken deleted, owner at reserve",
2497 .beforeDelete =
2498 [&](Env& env, MPTTester& mpt, Keylet const& broker) {
2499 deleteOwnerMPToken(env, mpt, broker);
2500 leaveBelowReserve(env, alice, issuer, 0);
2501 },
2502 .expected =
2503 {
2504 .both = tesSUCCESS,
2505 .only34 = tecNO_AUTH,
2506 .only35 = tesSUCCESS,
2507 .neither = tecNO_AUTH,
2508 },
2509 },
2510 {
2511 .name = "owner MPToken deleted, owner below reserve",
2512 .beforeDelete =
2513 [&](Env& env, MPTTester& mpt, Keylet const& broker) {
2514 deleteOwnerMPToken(env, mpt, broker);
2515 // Still short after the broker's reserve is released.
2516 leaveBelowReserve(env, alice, issuer, 2);
2517 },
2518 .expected =
2519 {
2521 .only34 = tecNO_AUTH,
2522 .only35 = tecINSUFFICIENT_RESERVE,
2523 .neither = tecNO_AUTH,
2524 },
2525 },
2526 // Nothing is paid out, so no MPToken is needed.
2527 {
2528 .name = "zero cover, owner MPToken deleted",
2529 .beforeDelete = withdrawCoverAndDeleteMPToken,
2530 .expected =
2531 {
2532 .both = tesSUCCESS,
2533 .only34 = tesSUCCESS,
2534 .only35 = tesSUCCESS,
2535 .neither = tesSUCCESS,
2536 },
2537 },
2538 // Nothing is paid out, so the reserve does not matter.
2539 {
2540 .name = "zero cover, owner MPToken deleted, owner below reserve",
2541 .beforeDelete =
2542 [&](Env& env, MPTTester& mpt, Keylet const& broker) {
2543 withdrawCoverAndDeleteMPToken(env, mpt, broker);
2544 leaveBelowReserve(env, alice, issuer, 2);
2545 },
2546 .expected =
2547 {
2548 .both = tesSUCCESS,
2549 .only34 = tesSUCCESS,
2550 .only35 = tesSUCCESS,
2551 .neither = tesSUCCESS,
2552 },
2553 },
2554 };
2555
2556 // featureMPTokensV2 independently makes ValidMPTTransfer enforcing,
2557 // but it is not enabled on real networks. Exclude it so Cleanup3.4
2558 // alone determines whether the invariant rejects the transfer.
2559 auto const features = all_ - featureMPTokensV2;
2560
2561 for (auto const& c : cases)
2562 {
2563 for (auto const& [amendments, runFeatures, expected] :
2564 cleanupRuns(features, c.expected))
2565 {
2566 testcase << "LoanBrokerDelete - MPT " << c.name << ", " << amendments;
2567
2568 // Hides the expected invariant failure from the log.
2569 std::string logs;
2570 Env env(*this, runFeatures, std::make_unique<CaptureLogs>(&logs));
2571 env.fund(XRP(100'000), issuer, alice);
2572 env.close();
2573
2574 MPTTester mpt({
2575 .env = env,
2576 .issuer = issuer,
2577 .holders = {alice},
2578 .pay = 15'000,
2579 .flags = c.flags,
2580 .authHolder = (c.flags & tfMPTRequireAuth) != 0,
2581 });
2582 PrettyAsset const asset{mpt.issuanceID()};
2583
2584 auto const broker = createBroker(env, alice, asset, 5'000);
2585 c.beforeDelete(env, mpt, broker);
2586 deleteBrokerAndCheck(env, alice, asset, broker, expected);
2587 }
2588 }
2589 }
2590
2591 void
2593 {
2594 using namespace jtx;
2595 using namespace loan_broker;
2596
2597 Account const issuer{"issuer"};
2598 Account const alice{"alice"};
2599
2600 // === IOU ===
2601 {
2602 testcase("LoanBrokerCoverDeposit IOU freeze checks");
2603 Env env(*this, all_);
2604 Vault const vault{env};
2605
2606 env.fund(XRP(100'000), issuer, alice);
2607 env(trust(alice, issuer["IOU"](1'000'000)));
2608 env.close();
2609 PrettyAsset const asset(issuer["IOU"]);
2610 env(pay(issuer, alice, asset(100'000)));
2611 env.close();
2612
2613 auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
2614 env(tx);
2615 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(50)}));
2616 env.close();
2617
2618 auto const brokerKeylet =
2619 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
2620 env(set(alice, vaultKeylet.key));
2621 env.close();
2622
2623 auto const broker = env.le(brokerKeylet);
2624 if (!BEAST_EXPECT(broker))
2625 return;
2626 Account const brokerPseudo("pseudo", broker->at(sfAccount));
2627
2628 env(coverDeposit(alice, brokerKeylet.key, asset(10)));
2629 env.close();
2630
2631 auto const runTests = [&] {
2632 auto const fix330Enabled = env.current()->rules().enabled(fixCleanup3_3_0);
2633
2634 // Global freeze
2635 env(fset(issuer, asfGlobalFreeze));
2636 env(coverDeposit(alice, brokerKeylet.key, asset(1)), Ter(tecFROZEN));
2637 env(fclear(issuer, asfGlobalFreeze));
2638
2639 // Source regular freeze
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));
2643
2644 // Source deep freeze
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));
2648
2649 // Pseudo regular freeze — post-fix blocks, pre-fix allows (BUG)
2650 TER const pseudoTer = fix330Enabled ? TER(tecFROZEN) : TER(tesSUCCESS);
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));
2654
2655 // Pseudo deep freeze
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));
2659 };
2660
2661 runTests();
2662 env.disableFeature(fixCleanup3_3_0);
2663 runTests();
2664 env.enableFeature(fixCleanup3_3_0);
2665 }
2666
2667 // === MPT ===
2668 {
2669 testcase("LoanBrokerCoverDeposit MPT lock checks");
2670 Env env(*this, all_);
2671 Vault const vault{env};
2672
2673 env.fund(XRP(100'000), issuer, alice);
2674 env.close();
2675
2676 MPTTester mptt{env, issuer, kMptInitNoFund};
2677 mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
2678 PrettyAsset const mpt{mptt.issuanceID()};
2679
2680 mptt.authorize({.account = alice});
2681 env(pay(issuer, alice, mpt(100'000)));
2682 env.close();
2683
2684 auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = mpt});
2685 env(tx);
2686 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = mpt(50)}));
2687 env.close();
2688
2689 auto const brokerKeylet =
2690 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
2691 env(set(alice, vaultKeylet.key));
2692 env.close();
2693
2694 auto const broker = env.le(brokerKeylet);
2695 if (!BEAST_EXPECT(broker))
2696 return;
2697 Account const brokerPseudo("pseudo", broker->at(sfAccount));
2698
2699 env(coverDeposit(alice, brokerKeylet.key, mpt(10)));
2700 env.close();
2701
2702 // For MPT isDeepFrozen == isFrozen, so all locks block in
2703 // both pre- and post-fix. No behavioral difference.
2704 auto const runTests = [&] {
2705 // Global lock
2706 mptt.set({.flags = tfMPTLock});
2707 env.close();
2708 env(coverDeposit(alice, brokerKeylet.key, mpt(1)), Ter(tecLOCKED));
2709 mptt.set({.flags = tfMPTUnlock});
2710 env.close();
2711
2712 // Source (alice) individual lock
2713 mptt.set({.holder = alice, .flags = tfMPTLock});
2714 env.close();
2715 env(coverDeposit(alice, brokerKeylet.key, mpt(1)), Ter(tecLOCKED));
2716 mptt.set({.holder = alice, .flags = tfMPTUnlock});
2717 env.close();
2718
2719 // Pseudo individual lock
2720 mptt.set({.holder = brokerPseudo, .flags = tfMPTLock});
2721 env.close();
2722 env(coverDeposit(alice, brokerKeylet.key, mpt(1)), Ter(tecLOCKED));
2723 mptt.set({.holder = brokerPseudo, .flags = tfMPTUnlock});
2724 env.close();
2725 };
2726
2727 runTests();
2728 env.disableFeature(fixCleanup3_3_0);
2729 runTests();
2730 env.enableFeature(fixCleanup3_3_0);
2731 }
2732 }
2733
2734 // Focused demonstration: a cover-withdraw submitter under a regular
2735 // individual IOU freeze can still withdraw to themselves (self-withdrawal).
2736 //
2737 // Pre-fixCleanup3_3_0: the old code only checked the pseudo-account source
2738 // and the destination for deep-freeze; it did not check the submitter's
2739 // individual freeze at all. Self-withdrawal therefore always succeeded.
2740 // Post-fixCleanup3_3_0: checkWithdrawFreeze explicitly skips the submitter
2741 // freeze check when submitter == destination, preserving the same result.
2742 void
2744 {
2745 testcase("LoanBrokerCoverWithdraw IOU self-withdrawal while individually frozen");
2746
2747 using namespace jtx;
2748 using namespace loan_broker;
2749
2750 Account const issuer{"issuer"};
2751 Account const alice{"alice"};
2752 Account const dest{"dest"};
2753 Env env{*this, all_};
2754 Vault const vault{env};
2755
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)));
2759 env.close();
2760
2761 PrettyAsset const asset(issuer["IOU"]);
2762 env(pay(issuer, alice, asset(100'000)));
2763 env.close();
2764
2765 auto [vaultTx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
2766 env(vaultTx);
2767 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(50)}));
2768 env.close();
2769
2770 auto const brokerKeylet =
2771 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
2772 env(set(alice, vaultKeylet.key));
2773 env.close();
2774
2775 env(coverDeposit(alice, brokerKeylet.key, asset(10)));
2776 env.close();
2777
2778 auto const runTests = [&] {
2779 auto const fix330Enabled = env.current()->rules().enabled(fixCleanup3_3_0);
2780
2781 // Set a regular individual freeze on alice's IOU trustline.
2782 env(trust(issuer, asset(0), alice, tfSetFreeze));
2783 env.close();
2784
2785 // Self-withdrawal: submitter == destination (no sfDestination in tx).
2786 // Both pre- and post-fixCleanup3_3_0 this succeeds:
2787 // pre-fix: old code never checked the submitter's freeze.
2788 // post-fix: checkWithdrawFreeze skips submitter when submitter==dst.
2789 env(coverWithdraw(alice, brokerKeylet.key, asset(1)), Ter(tesSUCCESS));
2790
2791 // Withdrawal to a third party is blocked by the submitter freeze
2792 // under fixCleanup3_3_0; pre-fix it was not checked.
2793 env(coverWithdraw(alice, brokerKeylet.key, asset(1)),
2794 kDestination(dest),
2795 Ter(fix330Enabled ? TER(tecFROZEN) : TER(tesSUCCESS)));
2796
2797 env(trust(issuer, asset(0), alice, tfClearFreeze));
2798 env.close();
2799 };
2800
2801 runTests();
2802 env.disableFeature(fixCleanup3_3_0);
2803 runTests();
2804 env.enableFeature(fixCleanup3_3_0);
2805 }
2806
2807 void
2809 {
2810 using namespace jtx;
2811 using namespace loan_broker;
2812
2813 Account const issuer{"issuer"};
2814 Account const alice{"alice"};
2815
2816 // === IOU ===
2817 {
2818 testcase("LoanBrokerCoverWithdraw IOU freeze checks");
2819 Env env(*this, all_);
2820 Vault const vault{env};
2821
2822 env.fund(XRP(100'000), issuer, alice);
2823 env(trust(alice, issuer["IOU"](1'000'000)));
2824 env.close();
2825 PrettyAsset const asset(issuer["IOU"]);
2826 env(pay(issuer, alice, asset(100'000)));
2827 env.close();
2828
2829 auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
2830 env(tx);
2831 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(50)}));
2832 env.close();
2833
2834 auto const brokerKeylet =
2835 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
2836 env(set(alice, vaultKeylet.key));
2837 env.close();
2838
2839 auto const broker = env.le(brokerKeylet);
2840 if (!BEAST_EXPECT(broker))
2841 return;
2842 Account const brokerPseudo("pseudo", broker->at(sfAccount));
2843
2844 env(coverDeposit(alice, brokerKeylet.key, asset(10)));
2845 env.close();
2846
2847 Account const dest{"dest"};
2848 env.fund(XRP(1'000), dest);
2849 env(trust(dest, asset(1'000)));
2850
2851 auto const runTests = [&] {
2852 auto const fix330Enabled = env.current()->rules().enabled(fixCleanup3_3_0);
2853 TER const expectedTec = fix330Enabled ? TER(tecFROZEN) : TER(tesSUCCESS);
2854
2855 // Global freeze
2856 env(fset(issuer, asfGlobalFreeze));
2857 env(coverWithdraw(alice, brokerKeylet.key, asset(1)),
2858 kDestination(dest),
2859 Ter(tecFROZEN));
2860 env(fclear(issuer, asfGlobalFreeze));
2861
2862 // Source (pseudo) regular freeze
2863 env(trust(issuer, asset(0), brokerPseudo, tfSetFreeze));
2864 env(coverWithdraw(alice, brokerKeylet.key, asset(1)),
2865 kDestination(dest),
2866 Ter(tecFROZEN));
2867 env(trust(issuer, asset(0), brokerPseudo, tfClearFreeze));
2868
2869 // Source (pseudo) deep freeze
2870 env(trust(issuer, asset(0), brokerPseudo, tfSetFreeze | tfSetDeepFreeze));
2871 env(coverWithdraw(alice, brokerKeylet.key, asset(1)),
2872 kDestination(dest),
2873 Ter(tecFROZEN));
2874 env(trust(issuer, asset(0), brokerPseudo, tfClearFreeze | tfClearDeepFreeze));
2875
2876 // Submitter regular freeze → dest
2877 env(trust(issuer, asset(0), alice, tfSetFreeze));
2878 env(coverWithdraw(alice, brokerKeylet.key, asset(1)),
2879 kDestination(dest),
2880 Ter(expectedTec));
2881 // Submitter regular freeze → self: always allowed
2882 env(coverWithdraw(alice, brokerKeylet.key, asset(1)), Ter(tesSUCCESS));
2883 env(trust(issuer, asset(0), alice, tfClearFreeze));
2884 env(coverDeposit(
2885 alice, brokerKeylet.key, asset(isTesSuccess(expectedTec) ? 2 : 1)));
2886
2887 // Submitter deep freeze → dest
2888 env(trust(issuer, asset(0), alice, tfSetFreeze | tfSetDeepFreeze));
2889 env(coverWithdraw(alice, brokerKeylet.key, asset(1)),
2890 kDestination(dest),
2891 Ter(expectedTec));
2892 // Submitter deep freeze → self: blocked (checkDeepFrozen)
2893 env(coverWithdraw(alice, brokerKeylet.key, asset(1)), Ter(tecFROZEN));
2894 env(trust(issuer, asset(0), alice, tfClearFreeze | tfClearDeepFreeze));
2895 if (isTesSuccess(expectedTec))
2896 env(coverDeposit(alice, brokerKeylet.key, asset(1)));
2897
2898 // Destination regular freeze: only deep freeze blocks
2899 env(trust(issuer, asset(0), dest, tfSetFreeze));
2900 env(coverWithdraw(alice, brokerKeylet.key, asset(1)),
2901 kDestination(dest),
2902 Ter(tesSUCCESS));
2903 env(trust(issuer, asset(0), dest, tfClearFreeze));
2904 env(coverDeposit(alice, brokerKeylet.key, asset(1)));
2905
2906 // Destination deep freeze
2907 env(trust(issuer, asset(0), dest, tfSetFreeze | tfSetDeepFreeze));
2908 env(coverWithdraw(alice, brokerKeylet.key, asset(1)),
2909 kDestination(dest),
2910 Ter(tecFROZEN));
2911 env(trust(issuer, asset(0), dest, tfClearFreeze | tfClearDeepFreeze));
2912
2913 // Submitter frozen → issuer: bypasses all freeze checks
2914 env(trust(issuer, asset(0), alice, tfSetFreeze));
2915 env(coverWithdraw(alice, brokerKeylet.key, asset(1)),
2916 kDestination(issuer),
2917 Ter(tesSUCCESS));
2918 env(trust(issuer, asset(0), alice, tfClearFreeze));
2919 env(coverDeposit(alice, brokerKeylet.key, asset(1)));
2920 };
2921
2922 runTests();
2923 env.disableFeature(fixCleanup3_3_0);
2924 runTests();
2925 env.enableFeature(fixCleanup3_3_0);
2926 }
2927
2928 // === MPT ===
2929 {
2930 testcase("LoanBrokerCoverWithdraw MPT lock checks");
2931 Env env(*this, all_);
2932 Vault const vault{env};
2933
2934 env.fund(XRP(100'000), issuer, alice);
2935 env.close();
2936
2937 MPTTester mptt{env, issuer, kMptInitNoFund};
2938 mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
2939 PrettyAsset const mpt{mptt.issuanceID()};
2940
2941 mptt.authorize({.account = alice});
2942 env(pay(issuer, alice, mpt(100'000)));
2943 env.close();
2944
2945 auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = mpt});
2946 env(tx);
2947 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = mpt(50)}));
2948 env.close();
2949
2950 auto const brokerKeylet =
2951 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
2952 env(set(alice, vaultKeylet.key));
2953 env.close();
2954
2955 auto const broker = env.le(brokerKeylet);
2956 if (!BEAST_EXPECT(broker))
2957 return;
2958 Account const brokerPseudo("pseudo", broker->at(sfAccount));
2959
2960 env(coverDeposit(alice, brokerKeylet.key, mpt(10)));
2961 env.close();
2962
2963 Account const dest{"dest"};
2964 env.fund(XRP(1'000), dest);
2965 mptt.authorize({.account = dest});
2966 env.close();
2967
2968 auto const runTests = [&] {
2969 auto const withFix = env.current()->rules().enabled(fixCleanup3_3_0);
2970 // Only submitter-to-dest differs: post-fix blocks, pre-fix
2971 // doesn't (BUG). All other locks block in both because for
2972 // MPT isDeepFrozen == isFrozen.
2973 TER const submitterToDest = withFix ? TER(tecLOCKED) : TER(tesSUCCESS);
2974
2975 // Global lock
2976 mptt.set({.flags = tfMPTLock});
2977 env.close();
2978 env(coverWithdraw(alice, brokerKeylet.key, mpt(1)),
2979 kDestination(dest),
2980 Ter(tecLOCKED));
2981 mptt.set({.flags = tfMPTUnlock});
2982 env.close();
2983
2984 // Source (pseudo) individual lock
2985 mptt.set({.holder = brokerPseudo, .flags = tfMPTLock});
2986 env.close();
2987 env(coverWithdraw(alice, brokerKeylet.key, mpt(1)),
2988 kDestination(dest),
2989 Ter(tecLOCKED));
2990 mptt.set({.holder = brokerPseudo, .flags = tfMPTUnlock});
2991 env.close();
2992
2993 // Submitter individual lock → dest
2994 mptt.set({.holder = alice, .flags = tfMPTLock});
2995 env.close();
2996 env(coverWithdraw(alice, brokerKeylet.key, mpt(1)),
2997 kDestination(dest),
2998 Ter(submitterToDest));
2999 // Submitter individual lock → self: blocked
3000 env(coverWithdraw(alice, brokerKeylet.key, mpt(1)), Ter(tecLOCKED));
3001 mptt.set({.holder = alice, .flags = tfMPTUnlock});
3002 env.close();
3003 if (isTesSuccess(submitterToDest))
3004 env(coverDeposit(alice, brokerKeylet.key, mpt(1)));
3005 env.close();
3006
3007 // Dest individual lock: blocked
3008 mptt.set({.holder = dest, .flags = tfMPTLock});
3009 env.close();
3010 env(coverWithdraw(alice, brokerKeylet.key, mpt(1)),
3011 kDestination(dest),
3012 Ter(tecLOCKED));
3013 mptt.set({.holder = dest, .flags = tfMPTUnlock});
3014 env.close();
3015
3016 // Submitter locked → issuer: bypasses all freeze checks
3017 mptt.set({.holder = alice, .flags = tfMPTLock});
3018 env.close();
3019 env(coverWithdraw(alice, brokerKeylet.key, mpt(1)),
3020 kDestination(issuer),
3021 Ter(tesSUCCESS));
3022 mptt.set({.holder = alice, .flags = tfMPTUnlock});
3023 env(coverDeposit(alice, brokerKeylet.key, mpt(1)));
3024 env.close();
3025 };
3026
3027 runTests();
3028 env.disableFeature(fixCleanup3_3_0);
3029 runTests();
3030 env.enableFeature(fixCleanup3_3_0);
3031 }
3032 }
3033
3034 void
3036 {
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"];
3042
3043 enum class TrustState {
3044 RequireAuth,
3045 ZeroLimit,
3046 ReachedLimit,
3047 NearLimit,
3048 NoTrustLine,
3049 };
3050
3051 auto const test = [&](TrustState trustState) {
3052 Env env(*this, all_);
3053
3054 testcase << "RIPD-4274 IOU with state: " << static_cast<int>(trustState);
3055
3056 auto const setTrustLine = [&](Account const& acct, TrustState state) {
3057 switch (state)
3058 {
3059 case TrustState::RequireAuth:
3060 env(trust(issuer, token(0), acct, tfSetfAuth));
3061 break;
3062 case TrustState::ZeroLimit: {
3063 auto jv = trust(acct, token(0));
3064 // set QualityIn so that the trustline is not
3065 // auto-deleted
3066 jv[sfQualityIn] = 10'000'000;
3067 env(jv);
3068 }
3069 break;
3070 case TrustState::ReachedLimit: {
3071 env(trust(acct, token(1'000)));
3072 env(pay(issuer, acct, token(1'000)));
3073 env.close();
3074 }
3075 break;
3076 case TrustState::NearLimit: {
3077 env(trust(acct, token(1'000)));
3078 env(pay(issuer, acct, token(950)));
3079 env.close();
3080 }
3081 break;
3082 case TrustState::NoTrustLine:
3083 // don't create a trustline
3084 break;
3085 default:
3086 BEAST_EXPECT(false);
3087 }
3088 env.close();
3089 };
3090
3091 env.fund(XRP(1'000), issuer, broker, dest);
3092 env.close();
3093
3094 if (trustState == TrustState::RequireAuth)
3095 {
3096 env(fset(issuer, asfRequireAuth));
3097 env.close();
3098
3099 setTrustLine(broker, TrustState::RequireAuth);
3100 }
3101
3102 setTrustLine(dest, trustState);
3103
3104 env(trust(broker, token(2'000), 0));
3105 env(pay(issuer, broker, token(2'000)));
3106 env.close();
3107
3108 Vault const vault(env);
3109 auto const [tx, keylet] = vault.create({.owner = broker, .asset = token.asset()});
3110 env(tx);
3111 env.close();
3112
3113 // Test Vault withdraw
3114 env(vault.deposit({.depositor = broker, .id = keylet.key, .amount = token(1'000)}));
3115 env.close();
3116
3117 env(vault.withdraw({.depositor = broker, .id = keylet.key, .amount = token(1'000)}),
3119 Ter(std::ignore));
3120 BEAST_EXPECT(env.ter() == tecNO_LINE);
3121 env.close();
3122
3123 env(vault.withdraw({.depositor = broker, .id = keylet.key, .amount = token(1'000)}));
3124
3125 // Test LoanBroker withdraw
3126 auto const brokerKeylet =
3127 keylet::loanBroker(broker, SeqProxy::rawSequence(env.seq(broker)));
3128
3129 env(loan_broker::set(broker, keylet.key));
3130 env.close();
3131
3132 env(loan_broker::coverDeposit(broker, brokerKeylet.key, token(1'000)));
3133 env.close();
3134
3135 env(loan_broker::coverWithdraw(broker, brokerKeylet.key, token(100)),
3137 Ter(std::ignore));
3138 BEAST_EXPECT(env.ter() == tecNO_LINE);
3139 env.close();
3140
3141 // Clearing RequireAuth shouldn't change the result
3142 if (trustState == TrustState::RequireAuth)
3143 {
3144 env(fclear(issuer, asfRequireAuth));
3145 env.close();
3146
3147 env(loan_broker::coverWithdraw(broker, brokerKeylet.key, token(100)),
3149 Ter(std::ignore));
3150 BEAST_EXPECT(env.ter() == tecNO_LINE);
3151 env.close();
3152 }
3153 };
3154
3155 test(TrustState::RequireAuth);
3156 test(TrustState::ZeroLimit);
3157 test(TrustState::ReachedLimit);
3158 test(TrustState::NearLimit);
3159 test(TrustState::NoTrustLine);
3160 }
3161
3162 void
3164 {
3165 using namespace jtx;
3166 Account const issuer("broker");
3167 Account const broker("issuer");
3168 Account const dest("destination");
3169
3170 enum class MPTState {
3171 RequireAuth,
3172 ReachedMAX,
3173 NoMPT,
3174 };
3175
3176 auto const test = [&](MPTState mptState) {
3177 Env env(*this, all_);
3178
3179 testcase << "RIPD-4274 MPT with state: " << static_cast<int>(mptState);
3180
3181 env.fund(XRP(1'000), issuer, broker, dest);
3182 env.close();
3183
3184 auto const maybeToken = [&] -> std::optional<MPT> {
3185 switch (mptState)
3186 {
3187 case MPTState::RequireAuth: {
3188 auto tester = MPTTester({
3189 .env = env,
3190 .issuer = issuer,
3191 .holders = {broker, dest},
3192 .pay = 2'000,
3193 .flags = kMptDexFlags | tfMPTRequireAuth,
3194 .authHolder = true,
3195 .maxAmt = 5'000,
3196 });
3197 // unauthorize dest
3198 tester.authorize(
3199 {.account = issuer, .holder = dest, .flags = tfMPTUnauthorize});
3200 return tester;
3201 }
3202 case MPTState::ReachedMAX: {
3203 auto tester = MPTTester({
3204 .env = env,
3205 .issuer = issuer,
3206 .holders = {broker, dest},
3207 .pay = 2'000,
3208 .flags = kMptDexFlags,
3209 .maxAmt = 4'000,
3210 });
3211 BEAST_EXPECT(env.balance(issuer, tester) == tester(-4'000));
3212 return tester;
3213 }
3214 case MPTState::NoMPT: {
3215 return MPTTester({
3216 .env = env,
3217 .issuer = issuer,
3218 .holders = {broker},
3219 .pay = 2'000,
3220 .flags = kMptDexFlags,
3221 .maxAmt = 4'000,
3222 });
3223 }
3224 default:
3225 return std::nullopt;
3226 }
3227 }();
3228 if (!BEAST_EXPECT(maybeToken))
3229 return;
3230
3231 auto const& token = *maybeToken;
3232
3233 Vault const vault(env);
3234 auto const [tx, keylet] = vault.create({.owner = broker, .asset = token.asset()});
3235 env(tx);
3236 env.close();
3237
3238 // Test Vault withdraw
3239 env(vault.deposit({.depositor = broker, .id = keylet.key, .amount = token(1'000)}));
3240 env.close();
3241
3242 env(vault.withdraw({.depositor = broker, .id = keylet.key, .amount = token(1'000)}),
3244 Ter(std::ignore));
3245
3246 // Shouldn't fail if at MaximumAmount since no new tokens are issued
3247 TER const err = mptState == MPTState::ReachedMAX ? TER(tesSUCCESS) : tecNO_AUTH;
3248 BEAST_EXPECT(env.ter() == err);
3249 env.close();
3250
3251 if (!isTesSuccess(err))
3252 {
3253 env(vault.withdraw(
3254 {.depositor = broker, .id = keylet.key, .amount = token(1'000)}));
3255 }
3256
3257 // Test LoanBroker withdraw
3258 auto const brokerKeylet =
3259 keylet::loanBroker(broker, SeqProxy::rawSequence(env.seq(broker)));
3260
3261 env(loan_broker::set(broker, keylet.key));
3262 env.close();
3263
3264 env(loan_broker::coverDeposit(broker, brokerKeylet.key, token(1'000)));
3265 env.close();
3266
3267 env(loan_broker::coverWithdraw(broker, brokerKeylet.key, token(100)),
3269 Ter(std::ignore));
3270 BEAST_EXPECT(env.ter() == err);
3271 env.close();
3272 };
3273
3274 test(MPTState::RequireAuth);
3275 test(MPTState::ReachedMAX);
3276 test(MPTState::NoMPT);
3277 }
3278
3279 void
3281 {
3284 }
3285
3286 void
3288 {
3289 testcase(
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;
3294
3295 bool const fix340Enabled = features[fixCleanup3_4_0];
3296
3297 Env env(*this, features);
3298
3299 Account const broker{"broker"};
3300 Account const dest{"dest"};
3301 Account const credIssuer{"credIssuer"};
3302 char const credType[] = "abcde";
3303
3304 env.fund(XRP(10'000), broker, dest, credIssuer);
3305 env(fset(dest, asfDepositAuth));
3306 env.close();
3307
3308 PrettyAsset const asset{xrpIssue(), 1'000'000};
3309
3310 Vault const vault(env);
3311 auto const [vaultTx, vaultKeylet] = vault.create({.owner = broker, .asset = asset});
3312 env(vaultTx);
3313 env.close();
3314
3315 env(vault.deposit({.depositor = broker, .id = vaultKeylet.key, .amount = asset(1'000)}));
3316 env.close();
3317
3318 auto const brokerKeylet =
3319 keylet::loanBroker(broker.id(), SeqProxy::rawSequence(env.seq(broker)));
3320 env(loan_broker::set(broker, vaultKeylet.key));
3321 env.close();
3322
3323 env(loan_broker::coverDeposit(broker, brokerKeylet.key, asset(500)));
3324 env.close();
3325
3326 auto const coverWithdrawToDest = [&] {
3327 return loan_broker::coverWithdraw(broker, brokerKeylet.key, asset(10));
3328 };
3329
3330 // Without any preauth, coverWithdraw to dest fails
3331 env(coverWithdrawToDest(), loan_broker::kDestination(dest), Ter{tecNO_PERMISSION});
3332 env.close();
3333
3334 // Issue and accept a credential for the broker (with expiration)
3335 auto jv = credentials::create(broker, credIssuer, credType);
3336 std::uint32_t const expiration =
3337 env.current()->header().parentCloseTime.time_since_epoch().count() + 100;
3338 jv[sfExpiration.jsonName] = expiration;
3339 env(jv);
3340 env(credentials::accept(broker, credIssuer, credType));
3341 env.close();
3342
3343 auto const credKeylet = credentials::keylet(broker, credIssuer, credType);
3344 auto const credIdx =
3345 credentials::ledgerEntry(env, broker, credIssuer, credType)[jss::result][jss::index]
3346 .asString();
3347
3348 // dest authorizes deposits from holders of credentials issued by credIssuer
3349 env(deposit::authCredentials(dest, {{.issuer = credIssuer, .credType = credType}}));
3350 env.close();
3351
3352 // Without supplying credentials, still fails
3353 env(coverWithdrawToDest(), loan_broker::kDestination(dest), Ter{tecNO_PERMISSION});
3354 env.close();
3355
3356 if (!fix340Enabled)
3357 {
3358 // Pre-fix: sfCredentialIDs in LoanBrokerCoverWithdraw is disabled
3359 env(coverWithdrawToDest(),
3361 credentials::Ids({credIdx}),
3362 Ter{temDISABLED});
3363 env.close();
3364 return;
3365 }
3366
3367 // With credentials, succeeds
3368 env(coverWithdrawToDest(), loan_broker::kDestination(dest), credentials::Ids({credIdx}));
3369 env.close();
3370
3371 // Bad credential id is rejected
3372 std::string const invalidIdx =
3373 "0E0B04ED60588A758B67E21FBBE95AC5A63598BA951761DC0EC9C08D7E01E034";
3374 env(coverWithdrawToDest(),
3376 credentials::Ids({invalidIdx}),
3378 env.close();
3379
3380 // Malformed credential array (duplicates) is rejected by checkFields
3381 env(coverWithdrawToDest(),
3383 credentials::Ids({credIdx, credIdx}),
3384 Ter{temMALFORMED});
3385 env.close();
3386
3387 // Valid credential not authorized by dest hits authorizedDepositPreauth error path
3388 char const credType2[] = "fghij";
3389 env(credentials::create(broker, credIssuer, credType2));
3390 env(credentials::accept(broker, credIssuer, credType2));
3391 env.close();
3392 auto const credIdx2 =
3393 credentials::ledgerEntry(env, broker, credIssuer, credType2)[jss::result][jss::index]
3394 .asString();
3395 env(coverWithdrawToDest(),
3397 credentials::Ids({credIdx2}),
3399 env.close();
3400
3401 // Advance time past expiration: credentials yield tecEXPIRED and are deleted
3402 env.close(150s);
3403 BEAST_EXPECT(env.le(credKeylet));
3404 env(coverWithdrawToDest(),
3406 credentials::Ids({credIdx}),
3407 Ter{tecEXPIRED});
3408 env.close();
3409 BEAST_EXPECT(!env.le(credKeylet));
3410 }
3411
3412 void
3414 {
3415 using namespace jtx;
3416 using namespace loan_broker;
3417
3418 testcase("FixedPrecision LoanBroker cover and DebtMaximum grid");
3419
3420 FeatureBitset const v12{all_ | featureLendingProtocolV1_1 | featureLendingProtocolV1_2};
3421 Account const issuer{"issuer"};
3422 Account const alice{"alice"};
3423 Env env{*this, v12};
3424 env.fund(XRP(100'000), issuer, alice);
3425 env.close();
3426 env(fset(issuer, asfAllowTrustLineClawback));
3427 env.close();
3428
3429 PrettyAsset const iou = issuer["IOU"];
3430 env(trust(alice, iou(Number{10, 10})));
3431 env(pay(issuer, alice, iou(Number{10, 9})));
3432
3433 Vault const vault{env};
3434 [[maybe_unused]] auto [createTx, vaultKeylet, subscriptionDate] =
3435 vault.createClosedEnded({.owner = alice, .asset = iou});
3436 createTx[sfScale] = 6;
3437 env(createTx);
3438 env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = iou(100)}));
3439 vault.closePastSubscription(subscriptionDate);
3440
3441 env(set(alice, vaultKeylet.key), kDebtMaximum(Number{15, -7}), Ter(tecPRECISION_LOSS));
3442
3443 auto const brokerKeylet =
3444 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
3445 env(set(alice, vaultKeylet.key), kDebtMaximum(Number{1, -6}));
3446
3447 // The grid check runs on update too, not just create.
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}));
3458
3459 auto const coverAvailable = [&] {
3460 auto const broker = env.le(brokerKeylet);
3461 BEAST_EXPECT(broker);
3462 return broker ? broker->at(sfCoverAvailable) : Number{0};
3463 };
3464 auto const pseudoBalance = [&] {
3465 auto const broker = env.le(brokerKeylet);
3466 BEAST_EXPECT(broker);
3467 return broker
3468 ? Number(env.balance(Account{"pseudo", broker->at(sfAccount)}, iou).value())
3469 : Number{0};
3470 };
3471 auto const aliceBalance = [&] { return Number(env.balance(alice, iou).value()); };
3472
3473 env(coverDeposit(alice, brokerKeylet.key, iou(Number{1, -7})), Ter(tecPRECISION_LOSS));
3474
3475 Number const openLimit{9, 9};
3476 {
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);
3485 }
3486 env(coverDeposit(alice, brokerKeylet.key, iou(openLimit - Number{1, -6})));
3487 env(coverDeposit(alice, brokerKeylet.key, iou(Number{1, -6})), Ter(tecLIMIT_EXCEEDED));
3488
3489 BEAST_EXPECT(coverAvailable() == openLimit);
3490
3491 {
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);
3500 }
3501
3502 // A third-party destination is checked against the rounded amount
3503 // actually sent: 1.8e-6 rounds to 1e-6, which fits bob's 1.5e-6 limit
3504 // even though the requested amount does not.
3505 {
3506 Account const bob{"bob"};
3507 env.fund(XRP(1'000), bob);
3508 env(trust(bob, iou(Number{15, -7})));
3509 env.close();
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}));
3513 BEAST_EXPECT(Number(env.balance(bob, iou).value()) == (Number{1, -6}));
3514 // Undo, so the clawback expectations below stay unchanged.
3515 env(coverDeposit(alice, brokerKeylet.key, iou(Number{1, -6})));
3516 }
3517
3518 {
3519 Number const coverBefore = coverAvailable();
3520 Number const pseudoBefore = pseudoBalance();
3521 env(coverClawback(issuer),
3522 kLoanBrokerId(brokerKeylet.key),
3523 kAmount(iou(Number{18, -7})));
3524 Number const debited = coverBefore - coverAvailable();
3525 BEAST_EXPECT((coverAvailable() == openLimit - Number{2, -6}));
3526 BEAST_EXPECT(pseudoBefore - pseudoBalance() == debited);
3527 }
3528
3529 env(coverWithdraw(alice, brokerKeylet.key, iou(Number{1, -7})), Ter(tecPRECISION_LOSS));
3530 env(coverClawback(issuer),
3531 kLoanBrokerId(brokerKeylet.key),
3532 kAmount(iou(Number{1, -7})),
3534
3535 env(coverClawback(issuer), kLoanBrokerId(brokerKeylet.key));
3536 BEAST_EXPECT((coverAvailable() == Number{0}));
3537 BEAST_EXPECT(pseudoBalance() == Number{0});
3538
3539 {
3540 testcase("FixedPrecision LoanBroker cover: XRP");
3541 [[maybe_unused]] auto [xrpTx, xrpVault, xrpSub] =
3542 vault.createClosedEnded({.owner = alice, .asset = xrpIssue()});
3543 env(xrpTx);
3544 auto const xrpBroker =
3545 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
3546 env(set(alice, xrpVault.key));
3547 // Integral asset: a fractional-drop DebtMaximum is off the base
3548 // grid (scale 0) on the update path too.
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)));
3555 }
3556
3557 {
3558 testcase("FixedPrecision LoanBroker cover: MPT");
3559 MPTTester mptt{env, issuer, kMptInitNoFund};
3560 mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
3561 PrettyAsset const mpt = mptt["MPT"];
3562 mptt.authorize({.account = alice});
3563 env(pay(issuer, alice, mpt(100)));
3564 [[maybe_unused]] auto [mptTx, mptVault, mptSub] =
3565 vault.createClosedEnded({.owner = alice, .asset = mpt});
3566 env(mptTx);
3567 auto const mptBroker =
3568 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
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)));
3573 }
3574 }
3575
3576 // Cover credit and debit stay exact at the 16-digit grid boundary and at
3577 // the Open-limit cusp. None of these cases coarsens the live grid: the
3578 // first two land one base unit (10^-Scale) below a power of ten, the
3579 // third lands one base unit below the Open limit (9 * 10^(15 - Scale),
3580 // not a power of ten). Since liveScale floors at the base exponent for
3581 // any representable value, the posterior grid never actually gets finer
3582 // for these cases; this test only pins exactness of the round trip.
3583 void
3585 {
3586 using namespace jtx;
3587 using namespace loan_broker;
3588
3589 testcase("FixedPrecision LoanBroker cover: exact round trip at grid boundaries");
3590
3591 FeatureBitset const v12{all_ | featureLendingProtocolV1_1 | featureLendingProtocolV1_2};
3592
3593 struct Case
3594 {
3595 std::uint8_t scale = 0;
3596 Number before;
3597 };
3598 std::array<Case, 3> const cases{
3599 {
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}},
3603 },
3604 };
3605
3606 for (auto const& c : cases)
3607 {
3608 Account const issuer{"issuer"};
3609 Account const alice{"alice"};
3610 Env env{*this, v12};
3611 env.fund(XRP(100'000), issuer, alice);
3612 env.close();
3613
3614 PrettyAsset const iou = issuer["IOU"];
3615 env(trust(alice, iou(Number{1, 20})));
3616 env(pay(issuer, alice, iou(Number{1, 19})));
3617 env.close();
3618
3619 Vault const vault{env};
3620 [[maybe_unused]] auto [createTx, vaultKeylet, subscriptionDate] =
3621 vault.createClosedEnded({.owner = alice, .asset = iou});
3622 createTx[sfScale] = c.scale;
3623 env(createTx);
3624 env.close();
3625
3626 auto const brokerKeylet =
3627 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
3628 env(set(alice, vaultKeylet.key));
3629 env.close();
3630
3631 Number const unit{1, -static_cast<int>(c.scale)};
3632
3633 auto const coverAvailable = [&] {
3634 auto const broker = env.le(brokerKeylet);
3635 BEAST_EXPECT(broker);
3636 return broker ? Number(broker->at(sfCoverAvailable)) : Number{0};
3637 };
3638 auto const pseudoBalance = [&] {
3639 auto const broker = env.le(brokerKeylet);
3640 BEAST_EXPECT(broker);
3641 return broker
3642 ? Number(env.balance(Account{"pseudo", broker->at(sfAccount)}, iou).value())
3643 : Number{0};
3644 };
3645
3646 env(coverDeposit(alice, brokerKeylet.key, iou(c.before)));
3647 env.close();
3648 BEAST_EXPECT(coverAvailable() == c.before);
3649 BEAST_EXPECT(pseudoBalance() == c.before);
3650
3651 // Crosses the power of ten.
3652 env(coverDeposit(alice, brokerKeylet.key, iou(unit)));
3653 env.close();
3654 BEAST_EXPECT(coverAvailable() == c.before + unit);
3655 BEAST_EXPECT(pseudoBalance() == c.before + unit);
3656
3657 // The same unit comes back out, and both balances return exactly.
3658 env(coverWithdraw(alice, brokerKeylet.key, iou(unit)));
3659 env.close();
3660 BEAST_EXPECT(coverAvailable() == c.before);
3661 BEAST_EXPECT(pseudoBalance() == c.before);
3662 }
3663 }
3664
3665 // Exercises canApplyToBrokerCover (fixCleanup3_2_0): a deposit, withdraw,
3666 // or clawback whose amount rounds to zero at sfCoverAvailable's precision
3667 // scale must be rejected with tecPRECISION_LOSS once the amendment is on,
3668 // and must silently succeed without changing sfCoverAvailable when off.
3669 void
3671 {
3672 using namespace jtx;
3673 using namespace loan_broker;
3674
3675 Account const issuer{"issuer"};
3676 Account const alice{"alice"};
3677
3678 // sfCoverAvailable = 10 IOU → STAmount exponent = -14.
3679 // Anything < 5e-15 rounds to zero at that scale.
3680 // 1e-16 is the representative sub-ULP probe amount.
3681
3682 // Shared setup: funds accounts, creates a vault + broker with 10 IOU
3683 // cover, and returns {brokerKeylet, iou}.
3684 auto const setup = [&](Env& env) -> std::pair<Keylet, PrettyAsset> {
3685 Vault const vault{env};
3686
3687 env.fund(XRP(100'000), issuer, alice);
3688 env.close();
3689 env(fset(issuer, asfAllowTrustLineClawback));
3690 env.close();
3691
3692 PrettyAsset const iou = issuer["IOU"];
3693 env(trust(alice, iou(1'000'000)));
3694 env.close();
3695 env(pay(issuer, alice, iou(1'000)));
3696 env.close();
3697
3698 auto [createTx, vaultKeylet] = vault.create({.owner = alice, .asset = iou});
3699 env(createTx);
3700 env.close();
3701
3702 auto const brokerKeylet =
3703 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
3704 env(set(alice, vaultKeylet.key));
3705 env.close();
3706
3707 env(coverDeposit(alice, brokerKeylet.key, iou(10)));
3708 env.close();
3709
3710 return {brokerKeylet, iou};
3711 };
3712
3713 auto const runTestCases = [&](FeatureBitset features) {
3714 TER const expected =
3715 features[fixCleanup3_2_0] ? TER{tecPRECISION_LOSS} : TER{tesSUCCESS};
3716
3717 {
3718 testcase("Cover precision guard: Deposit zero-at-scale");
3719 Env env{*this, features};
3720 auto const [brokerKeylet, iou] = setup(env);
3721 PrettyAmount const subUlpAmt = iou(Number{1, -16});
3722 auto const coverBefore = env.le(brokerKeylet)->at(sfCoverAvailable);
3723 env(coverDeposit(alice, brokerKeylet.key, subUlpAmt), Ter(expected));
3724 env.close();
3725 if (expected == tesSUCCESS)
3726 {
3727 if (auto const broker = env.le(brokerKeylet); BEAST_EXPECT(broker))
3728 BEAST_EXPECT(broker->at(sfCoverAvailable) == coverBefore);
3729 }
3730 }
3731
3732 {
3733 testcase("Cover precision guard: Deposit rounds down");
3734 // Both cases succeed; post-fix the amount is rounded DOWN to
3735 // cover scale first, so the delta differs from pre-fix
3736 // Input: 1.8e-14 IOU (sub-scale at cover scale -14)
3737 // Pre-fix: 10 + 1.8e-14 → round-to-nearest →
3738 // 10.00000000000002 → delta 2e-14
3739 // Post-fix: roundToScale(1.8e-14, -14, Downward) = 1e-14;
3740 // 10 + 1e-14 = 10.00000000000001 → delta 1e-14
3741 Env env{*this, features};
3742 auto const [brokerKeylet, iou] = setup(env);
3743 PrettyAmount const subUlpAmt = iou(Number{18, -15});
3744 auto const coverBefore = env.le(brokerKeylet)->at(sfCoverAvailable);
3745 env(coverDeposit(alice, brokerKeylet.key, subUlpAmt), Ter(tesSUCCESS));
3746 env.close();
3747 auto const brokerAfter = env.le(brokerKeylet);
3748 if (!BEAST_EXPECT(brokerAfter))
3749 return;
3750
3751 Number const delta = features[fixCleanup3_2_0] ? Number{1, -14} : Number{2, -14};
3752 BEAST_EXPECT(brokerAfter->at(sfCoverAvailable) - coverBefore == delta);
3753 }
3754
3755 // Property: post-fix, when the user deposits `x` and cover
3756 // gains `x'`, we always have 0 <= x - x' < 1 ULP at cover
3757 // scale (cover holds 10 IOU → ULP = 1e-14). Pre-fix uses
3758 // STAmount's default round-to-nearest during `+=`, which can
3759 // over-deposit (x' > x), so the property only holds with
3760 // fixCleanup3_2_0 enabled.
3761 if (features[fixCleanup3_2_0])
3762 {
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};
3767 // Each requested amount lies strictly between 1·ULP and
3768 // 2·ULP at cover scale; post-fix `roundDown` credits
3769 // exactly `oneUlp` and leaves a strictly-positive,
3770 // strictly-sub-ULP residual.
3771 for (Number const requested : {Number{11, -15}, Number{15, -15}, Number{19, -15}})
3772 {
3773 auto const broker = env.le(brokerKeylet);
3774 if (!BEAST_EXPECT(broker))
3775 return;
3776 Number const coverBefore = broker->at(sfCoverAvailable);
3777 env(coverDeposit(alice, brokerKeylet.key, iou(requested)), Ter(tesSUCCESS));
3778 env.close();
3779 auto const brokerAfter = env.le(brokerKeylet);
3780 if (!BEAST_EXPECT(brokerAfter))
3781 return;
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);
3787 }
3788 }
3789
3790 {
3791 testcase("Cover precision guard: Withdraw");
3792 Env env{*this, features};
3793 auto const [brokerKeylet, iou] = setup(env);
3794 PrettyAmount const subUlpAmt = iou(Number{1, -16});
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));
3798 env.close();
3799 if (expected == tesSUCCESS)
3800 {
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);
3804 }
3805 }
3806
3807 {
3808 testcase("Cover precision guard: Clawback");
3809 Env env{*this, features};
3810 auto const [brokerKeylet, iou] = setup(env);
3811 PrettyAmount const subUlpAmt = iou(Number{1, -16});
3812 auto const coverBefore = env.le(brokerKeylet)->at(sfCoverAvailable);
3813 env(coverClawback(issuer),
3814 kLoanBrokerId(brokerKeylet.key),
3815 kAmount(subUlpAmt),
3816 Ter(expected));
3817 env.close();
3818 if (expected == tesSUCCESS)
3819 {
3820 if (auto const broker = env.le(brokerKeylet); BEAST_EXPECT(broker))
3821 BEAST_EXPECT(broker->at(sfCoverAvailable) == coverBefore);
3822 }
3823 }
3824
3825 // MPT amounts are integers; scale is 0; the guard never rejects a
3826 // positive integer amount. Verify all three callsites pass with amendment on.
3827 {
3828 testcase("Cover precision guard: MPT min amount passes");
3829 Env env{*this, all_};
3830
3831 env.fund(XRP(100'000), issuer, alice);
3832 env.close();
3833
3834 MPTTester mptt{env, issuer, kMptInitNoFund};
3835 mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
3836 env.close();
3837
3838 PrettyAsset const mptAsset = mptt["MPT"];
3839 mptt.authorize({.account = alice});
3840 env.close();
3841
3842 env(pay(issuer, alice, mptAsset(100)));
3843 env.close();
3844
3845 Vault const vault{env};
3846 auto [createTx, vaultKeylet] = vault.create({.owner = alice, .asset = mptAsset});
3847 env(createTx);
3848 env.close();
3849
3850 auto const brokerKeylet =
3851 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
3852 env(set(alice, vaultKeylet.key));
3853 env.close();
3854
3855 env(coverDeposit(alice, brokerKeylet.key, mptAsset(10)));
3856 env.close();
3857
3858 env(coverDeposit(alice, brokerKeylet.key, mptAsset(1)), Ter(tesSUCCESS));
3859 env.close();
3860
3861 env(coverWithdraw(alice, brokerKeylet.key, mptAsset(1)), Ter(tesSUCCESS));
3862 env.close();
3863
3864 env(coverClawback(issuer),
3865 kLoanBrokerId(brokerKeylet.key),
3866 kAmount(mptAsset(1)),
3867 Ter(tesSUCCESS));
3868 env.close();
3869 }
3870 };
3871
3872 runTestCases(all_);
3873 runTestCases(all_ - fixCleanup3_2_0);
3874 }
3875
3876 void
3878 {
3879 testcase("Private Loan Broker with Permissioned Domain");
3880 using namespace jtx;
3881 using namespace loan_broker;
3882
3883 Account const issuer{"issuer"};
3884 Account const alice{"alice"};
3885 Account const credIssuer{"credIssuer"};
3886 std::string const credType = "LoanCredential";
3887
3888 // DomainID and private Loan Brokers require featureLendingProtocolV1_2.
3889 Env env{*this, all_ | featureLendingProtocolV1_2};
3890 Vault const vault{env};
3891
3892 env.fund(XRP(100'000), issuer, alice, credIssuer);
3893 env.close();
3894
3895 // Create an IOU asset and vault
3896 env(trust(alice, issuer["IOU"](1'000'000)));
3897 env.close();
3898 PrettyAsset const asset{issuer["IOU"]};
3899 env(pay(issuer, alice, asset(100'000)));
3900 env.close();
3901
3902 auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
3903 env(tx);
3904 env.close();
3905
3906 // Create a permissioned domain
3907 pdomain::Credentials const credentials{{.issuer = credIssuer, .credType = credType}};
3908 env(pdomain::setTx(credIssuer, credentials));
3909 env.close();
3910 auto const domainId = pdomain::getNewDomain(env.meta());
3911 BEAST_EXPECT(domainId != beast::kZero);
3912
3913 auto const brokerKeylet =
3914 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
3915 {
3916 testcase("Create a private loan broker with DomainID");
3917 env(set(alice, vaultKeylet.key, tfLoanBrokerPrivate), kDomainId(domainId));
3918 env.close();
3919 }
3920
3921 {
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))
3925 {
3926 return;
3927 }
3928 BEAST_EXPECT(sleBroker->isFlag(lsfLoanBrokerPrivate));
3929 BEAST_EXPECT(sleBroker->at(~sfDomainID) == domainId);
3930 }
3931
3932 {
3933 testcase("Cannot create public broker with DomainID");
3934 // Public broker (no tfLoanBrokerPrivate) with DomainID should fail
3935 env(set(alice, vaultKeylet.key), kDomainId(domainId), Ter(temINVALID));
3936 }
3937
3938 {
3939 testcase("Cannot create broker with zero DomainID");
3940 env(set(alice, vaultKeylet.key, tfLoanBrokerPrivate),
3941 kDomainId(beast::kZero),
3942 Ter(temMALFORMED));
3943 }
3944
3945 {
3946 testcase("Cannot create broker with non-existent DomainID");
3947 uint256 fakeDomainId;
3948 BEAST_EXPECT(fakeDomainId.parseHex(
3949 "1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF"));
3950 env(set(alice, vaultKeylet.key, tfLoanBrokerPrivate),
3951 kDomainId(fakeDomainId),
3953 }
3954 }
3955
3956 void
3958 {
3959 testcase("Modify Private Loan Broker DomainID");
3960 using namespace jtx;
3961 using namespace loan_broker;
3962
3963 Account const issuer{"issuer"};
3964 Account const alice{"alice"};
3965 Account const credIssuer{"credIssuer"};
3966 std::string const credType = "LoanCredential";
3967
3968 // DomainID and private Loan Brokers require featureLendingProtocolV1_2.
3969 Env env{*this, all_ | featureLendingProtocolV1_2};
3970 Vault const vault{env};
3971
3972 env.fund(XRP(100'000), issuer, alice, credIssuer);
3973 env.close();
3974
3975 // Create an IOU asset and vault
3976 env(trust(alice, issuer["IOU"](1'000'000)));
3977 env.close();
3978 PrettyAsset const asset{issuer["IOU"]};
3979 env(pay(issuer, alice, asset(100'000)));
3980 env.close();
3981
3982 auto [tx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
3983 env(tx);
3984 env.close();
3985
3986 // Create two permissioned domains
3987 pdomain::Credentials const credentials{{.issuer = credIssuer, .credType = credType}};
3988 env(pdomain::setTx(credIssuer, credentials));
3989 env.close();
3990 auto const domainId1 = pdomain::getNewDomain(env.meta());
3991
3992 env(pdomain::setTx(credIssuer, credentials));
3993 env.close();
3994 auto const domainId2 = pdomain::getNewDomain(env.meta());
3995
3996 // Create a private loan broker with DomainID
3997 auto const brokerKeylet =
3998 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
3999 env(set(alice, vaultKeylet.key, tfLoanBrokerPrivate), kDomainId(domainId1));
4000 env.close();
4001
4002 {
4003 testcase("Modify DomainID to a different domain");
4004 env(set(alice, vaultKeylet.key), kLoanBrokerId(brokerKeylet.key), kDomainId(domainId2));
4005 env.close();
4006 auto const sleBroker = env.le(brokerKeylet);
4007 if (!BEAST_EXPECT(sleBroker))
4008 {
4009 return;
4010 }
4011 BEAST_EXPECT(sleBroker->at(~sfDomainID) == domainId2);
4012 }
4013
4014 {
4015 testcase("Clear DomainID by setting to zero");
4016 env(set(alice, vaultKeylet.key),
4017 kLoanBrokerId(brokerKeylet.key),
4018 kDomainId(beast::kZero));
4019 env.close();
4020 auto const sleBroker = env.le(brokerKeylet);
4021 if (!BEAST_EXPECT(sleBroker))
4022 {
4023 return;
4024 }
4025 BEAST_EXPECT(!sleBroker->at(~sfDomainID));
4026 }
4027
4028 {
4029 testcase("Set DomainID back");
4030 env(set(alice, vaultKeylet.key), kLoanBrokerId(brokerKeylet.key), kDomainId(domainId1));
4031 env.close();
4032 auto const sleBroker = env.le(brokerKeylet);
4033 if (!BEAST_EXPECT(sleBroker))
4034 {
4035 return;
4036 }
4037 BEAST_EXPECT(sleBroker->at(~sfDomainID) == domainId1);
4038 }
4039
4040 uint256 fakeDomainId;
4041 BEAST_EXPECT(fakeDomainId.parseHex(
4042 "1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF"));
4043
4044 {
4045 testcase("Cannot modify DomainID to a non-existent domain");
4046 env(set(alice, vaultKeylet.key),
4047 kLoanBrokerId(brokerKeylet.key),
4048 kDomainId(fakeDomainId),
4050 env.close();
4051 auto const sleBroker = env.le(brokerKeylet);
4052 if (!BEAST_EXPECT(sleBroker))
4053 {
4054 return;
4055 }
4056
4057 // DomainID must be unchanged
4058 BEAST_EXPECT(sleBroker->at(~sfDomainID) == domainId1);
4059 }
4060
4061 {
4062 testcase("Updating other fields without specifying DomainID does not affect DomainID");
4063 env(set(alice, vaultKeylet.key),
4064 kLoanBrokerId(brokerKeylet.key),
4065 kData("test_data"),
4066 kDebtMaximum(Number(1000)));
4067 env.close();
4068 auto const sleBroker = env.le(brokerKeylet);
4069 if (!BEAST_EXPECT(sleBroker))
4070 {
4071 return;
4072 }
4073 // DomainID should be preserved
4074 BEAST_EXPECT(sleBroker->at(~sfDomainID) == domainId1);
4075 // Other fields should be updated
4076 BEAST_EXPECT(sleBroker->isFieldPresent(sfData));
4077 BEAST_EXPECT(sleBroker->at(~sfDebtMaximum) == Number(1000));
4078 }
4079
4080 {
4081 testcase("Updating only DomainID does not affect other fields");
4082 env(set(alice, vaultKeylet.key), kLoanBrokerId(brokerKeylet.key), kDomainId(domainId2));
4083 env.close();
4084 auto const sleBroker = env.le(brokerKeylet);
4085 if (!BEAST_EXPECT(sleBroker))
4086 {
4087 return;
4088 }
4089 // DomainID should be updated
4090 BEAST_EXPECT(sleBroker->at(~sfDomainID) == domainId2);
4091 // Other fields should be preserved
4092 BEAST_EXPECT(sleBroker->isFieldPresent(sfData));
4093 BEAST_EXPECT(sleBroker->at(~sfDebtMaximum) == Number(1000));
4094 }
4095
4096 {
4097 testcase("Cannot set tfLoanBrokerPrivate when modifying (flag is immutable)");
4098 env(set(alice, vaultKeylet.key, tfLoanBrokerPrivate),
4099 kLoanBrokerId(brokerKeylet.key),
4100 Ter(temINVALID));
4101 }
4102
4103 auto const publicBrokerKeylet =
4104 keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
4105 {
4106 testcase("Create a public broker and try to set DomainID on it");
4107 env(set(alice, vaultKeylet.key)); // No tfLoanBrokerPrivate = public
4108 env.close();
4109 auto const sleBroker = env.le(publicBrokerKeylet);
4110 if (!BEAST_EXPECT(sleBroker))
4111 {
4112 return;
4113 }
4114 BEAST_EXPECT(!sleBroker->isFlag(lsfLoanBrokerPrivate));
4115 }
4116
4117 // Cannot set DomainID on public broker
4118 env(set(alice, vaultKeylet.key),
4119 kLoanBrokerId(publicBrokerKeylet.key),
4120 kDomainId(domainId1),
4122
4123 // Cannot set DomainID to even zero on public broker
4124 env(set(alice, vaultKeylet.key),
4125 kLoanBrokerId(publicBrokerKeylet.key),
4126 kDomainId(beast::kZero),
4128 env.close();
4129
4130 // A non-existent domain on a public broker is rejected for being set on
4131 // a public broker first: the broker checks precede the domain check.
4132 env(set(alice, vaultKeylet.key),
4133 kLoanBrokerId(publicBrokerKeylet.key),
4134 kDomainId(fakeDomainId),
4136 env.close();
4137 }
4138
4139public:
4140 void
4142 {
4143 using namespace jtx;
4144 using namespace loan_broker;
4145
4146 bool const withFix = features[fixCleanup3_5_0];
4147 testcase(
4148 std::string("DebtMaximum out of range for the asset (") + (withFix ? "post" : "pre") +
4149 "-fixCleanup3_5_0)");
4150
4151 Env env(*this, features);
4152 Account const alice{"alice"};
4153 env.fund(XRP(100'000), alice);
4154 env.close();
4155
4156 Vault const vault{env};
4157 auto const [tx, keylet] = vault.create({.owner = alice, .asset = xrpIssue()});
4158 env(tx);
4159 env.close();
4160
4161 // Without the fix, the representability check in preclaim throws for
4162 // XRP above STAmount::kMaxNativeN.
4163 auto const ownerCount = env.ownerCount(alice);
4164 Number const maxXrp{static_cast<std::int64_t>(STAmount::kMaxNativeN)};
4165 env(set(alice, keylet.key),
4166 kDebtMaximum(maxXrp + 1),
4167 Ter(withFix ? TER{tecPRECISION_LOSS} : TER{tefEXCEPTION}));
4168 env.close();
4169 BEAST_EXPECT(env.ownerCount(alice) == ownerCount);
4170
4171 env(set(alice, keylet.key), kDebtMaximum(maxXrp));
4172 env.close();
4173 BEAST_EXPECT(env.ownerCount(alice) > ownerCount);
4174 }
4175
4176 void
4177 run() override
4178 {
4185
4189
4192
4193 testDisabled();
4194 testLifecycle();
4198
4199 testRIPD4323();
4201
4202 testRIPD4274();
4203
4206
4208 testLoanBrokerDeleteLockedMPT(all_ - fixCleanup3_2_0);
4209
4211 testLoanBrokerDeleteFrozenIOU(all_ - fixCleanup3_2_0);
4212
4215
4217
4219 testLoanBrokerDeleteConfidentialCOA(all_ - fixCleanup3_5_0);
4220
4222 testDebtMaximumOutOfRange(all_ - fixCleanup3_5_0);
4223
4224 // featureMPTokensV2 independently makes ValidMPTTransfer enforcing,
4225 // but it is not enabled on real networks. Exclude it so Cleanup3.4
4226 // alone determines whether the invariant rejects the transfer.
4227 testLoanBrokerDeleteRequireAuthMPT(all_ - featureMPTokensV2);
4228 testLoanBrokerDeleteRequireAuthMPT(all_ - featureMPTokensV2 - fixCleanup3_4_0);
4229
4231
4232 // TODO: Write clawback failure tests with an issuer / MPT that doesn't
4233 // have the right flags set.
4234 }
4235};
4236
4238
4239} // namespace xrpl::test
A generic endpoint for log messages.
Definition Journal.h:44
A testsuite class.
Definition suite.h:52
void fail(String const &reason, char const *file, int line)
Record a failure.
Definition suite.h:554
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
Represents a JSON value.
Definition json_value.h:121
static constexpr Int kMaxInt
Definition json_value.h:134
std::string asString() const
Returns the unquoted string value.
State information when applying a tx.
ApplyView & view()
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.
Definition base_uint.h:526
A currency issued by an account.
Definition Issue.h:18
static TER preclaim(PreclaimContext const &ctx)
Number is a floating point type that can represent a wide range of values.
Definition Number.h:351
static MantissaRange::MantissaScale getMantissaScale()
Returns which mantissa scale is currently in use for normalization.
Writable ledger view that accumulates state and tx changes.
Definition OpenView.h:59
static constexpr std::uint64_t kMaxNativeN
Definition STAmount.h:72
std::shared_ptr< STLedgerEntry const > const & ConstRef
void setFieldAmount(SField const &field, STAmount const &)
Definition STObject.cpp:803
void setAccountID(SField const &field, AccountID const &)
Definition STObject.cpp:785
void setFieldH256(SField const &field, UInt256 const &)
Definition STObject.cpp:767
static constexpr SeqProxy rawSequence(std::uint32_t v)
Factory function to return a sequence-based SeqProxy.
Definition SeqProxy.h:62
Slice slice() const noexcept
Definition Serializer.h:141
A step in a payment path.
Definition Steps.h:83
static std::vector< std::tuple< std::string, FeatureBitset, TER > > cleanupRuns(FeatureBitset features, ExpectedByCleanup const &expected)
void testLoanBrokerDeleteRequireAuthMPT(FeatureBitset features)
void testLoanBrokerDeleteFrozenIOU(FeatureBitset features)
void run() override
Runs the suite.
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)
static Keylet createBroker(jtx::Env &env, jtx::Account const &alice, jtx::PrettyAsset const &asset, std::int64_t cover)
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 testDebtMaximumOutOfRange(FeatureBitset features)
void deleteBrokerAndCheck(jtx::Env &env, jtx::Account const &alice, jtx::PrettyAsset const &asset, Keylet const &brokerKeylet, TER expected)
void testLoanBrokerDeleteConfidentialCOA(FeatureBitset features)
void testCoverWithdrawCredentialDepositPreauth(FeatureBitset features)
void testLoanBrokerDeleteLockedMPT(FeatureBitset features)
Immutable cryptographic account descriptor.
Definition jtx/Account.h:21
std::string const & human() const
Returns the human readable public key.
AccountID id() const
Returns the Account ID.
A balance matches.
Definition balance.h:24
A transaction testing environment.
Definition Env.h:161
Application & app()
Definition Env.h:300
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
Definition Env.cpp:133
TER ter() const
Return the TER for the last JTx.
Definition Env.h:844
json::Value json(JsonValue &&jv, FN const &... fN)
Create JSON from parameters.
Definition Env.h:752
SLE::const_pointer le(Account const &account) const
Return an account root.
Definition Env.cpp:311
std::uint32_t ownerCount(Account const &account) const
Return the number of objects owned by an account.
Definition Env.cpp:266
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
Definition Env.cpp:323
std::uint32_t seq(Account const &account) const
Returns the next sequence number on account.
Definition Env.cpp:302
json::Value rpc(unsigned apiVersion, std::unordered_map< std::string, std::string > const &headers, std::string const &cmd, Args &&... args)
Execute an RPC command.
Definition Env.h:1058
void setParseFailureExpected(bool b)
Definition Env.h:553
JTx jt(JsonValue &&jv, FN const &... fN)
Create a JTx from parameters.
Definition Env.h:723
PrettyAmount balance(Account const &account) const
Returns the XRP balance on an account.
Definition Env.cpp:201
void disableFeature(UInt256 const feature)
Definition Env.cpp:717
void enableFeature(UInt256 const feature)
Definition Env.cpp:709
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...
Definition Env.cpp:664
std::shared_ptr< STObject const > meta()
Return metadata for the last JTx.
Definition Env.cpp:538
beast::Journal const journal
Definition Env.h:204
void require(Args const &... args)
Check a set of requirements.
Definition Env.h:766
std::shared_ptr< OpenView const > current() const
Returns the current ledger.
Definition Env.h:377
Set the fee on a JTx.
Definition fee.h:20
Test helper for creating, mutating, and asserting MPT and confidential MPT ledger state.
Definition mpt.h:512
static constexpr auto holderEncryptedInbox
Definition mpt.h:533
std::optional< Buffer > getEncryptedBalance(Account const &account, EncryptedBalanceType option=holderEncryptedInbox) const
Definition mpt.cpp:1171
std::uint32_t generateKeyPair(Account const &account)
Definition mpt.cpp:1905
static constexpr auto issuerEncryptedBalance
Definition mpt.h:532
MPTID const & issuanceID() const
Definition mpt.h:777
static constexpr auto holderEncryptedSpending
Definition mpt.h:534
std::optional< Buffer > getPubKey(Account const &account, std::optional< std::uint32_t > epoch=std::nullopt) const
Definition mpt.cpp:1930
static constexpr auto auditorEncryptedBalance
Definition mpt.h:535
void create(MPTCreate const &arg=MPTCreate{}, std::source_location const &loc=std::source_location::current())
Definition mpt.cpp:346
void set(MPTSet const &set={}, std::source_location const &loc=std::source_location::current())
Definition mpt.cpp:581
std::int64_t getIssuanceConfidentialBalance() const
Definition mpt.cpp:974
void authorize(MPTAuthorize const &arg=MPTAuthorize{}, std::source_location const &loc=std::source_location::current())
Definition mpt.cpp:459
void convert(MPTConvert const &arg=MPTConvert{}, std::source_location const &loc=std::source_location::current())
Definition mpt.cpp:1301
Converts to MPT Issue or STAmount.
Set the regular signature on a JTx.
Definition sig.h:19
Set the expected result code for a JTx The test will fail if the code doesn't match.
Definition ter.h:18
Set the flags on a JTx.
Definition txflags.h:14
T emplace_back(T... args)
T make_tuple(T... args)
T make_unique(T... args)
constexpr Zero kZero
Definition Zero.h:30
Keylet computation functions.
Definition Indexes.h:39
Keylet vault(AccountID const &owner, SeqProxy const &seq) noexcept
Definition Indexes.cpp:565
Keylet mptoken(MPTID const &issuanceID, AccountID const &holder) noexcept
Definition Indexes.cpp:547
Keylet loanBroker(AccountID const &owner, SeqProxy const &seq) noexcept
Definition Indexes.cpp:571
Keylet account(AccountID const &id) noexcept
AccountID root.
Definition Indexes.cpp:233
Keylet loan(UInt256 const &loanBrokerID, SeqProxy const &loanSeq) noexcept
Definition Indexes.cpp:577
Keylet trustLine(AccountID const &id0, AccountID const &id1, Currency const &currency) noexcept
The index of a trust line for a given currency.
Definition Indexes.cpp:287
constexpr TenthBips32 kMaxCoverRate
The maximum coverage rate required of a loan broker in 1/10 bips.
Definition Protocol.h:159
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)
Definition creds.cpp:29
json::Value create(jtx::Account const &subject, jtx::Account const &issuer, std::string_view credType)
Definition creds.cpp:16
json::Value ledgerEntry(jtx::Env &env, jtx::Account const &subject, jtx::Account const &issuer, std::string_view credType)
Definition creds.cpp:56
Keylet keylet(test::jtx::Account const &subject, test::jtx::Account const &issuer, std::string_view credType)
Definition credentials.h:21
Deposit preauthorize operations.
Definition deposit.h:16
json::Value authCredentials(jtx::Account const &account, std::vector< AuthorizeCredentials > const &auth)
Definition deposit.cpp:38
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)
static NoneT const kNone
Definition tags.h:9
auto const kMptDexFlags
Definition mpt.h:47
json::Value pay(AccountID const &account, AccountID const &to, AnyAmount amount)
Create a payment.
Definition pay.cpp:14
XrpT const XRP
Converts to XRP Issue or STAmount.
Definition amount.cpp:92
json::Value noop(Account const &account)
The null transaction.
Definition noop.h:14
std::uint32_t ownerCount(Env const &env, Account const &account)
json::Value fclear(Account const &account, std::uint32_t off)
Remove account flag.
Definition flags.h:110
FeatureBitset testableAmendments()
Definition Env.h:92
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.
Definition Env.h:86
json::Value trust(Account const &account, STAmount const &amount, std::uint32_t flags)
Modify a trust line.
Definition trust.cpp:18
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.
Definition flags.cpp:15
static MPTInit const kMptInitNoFund
Definition mpt.h:201
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.
Definition algorithm.h:5
@ terNO_RIPPLE
Definition TER.h:226
bool set(T &target, std::string const &name, Section const &section)
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.
Definition Issue.h:108
std::string strHex(FwdIt begin, FwdIt end)
Definition strHex.h:13
int scale(Number const &number, Asset const &asset)
Get the scale of a Number for a given asset.
Definition STAmount.h:819
@ tefEXCEPTION
Definition TER.h:166
std::string toBase58(AccountID const &v)
Convert AccountID to base58 checked string.
Definition AccountID.cpp:95
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
Definition Units.h:454
TenthBips< std::uint16_t > TenthBips16
Definition Units.h:453
constexpr FlagValue tfUniversal
Definition TxFlags.h:45
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
constexpr std::size_t kMaxDataPayloadLength
The maximum length of Data payload.
Definition Protocol.h:303
BaseUInt< 256 > UInt256
Definition base_uint.h:581
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.
Definition STAmount.h:745
@ TapNone
Definition ApplyView.h:28
BaseUInt< 160, detail::AccountIDTag > AccountID
A 160-bit unsigned that uniquely identifies an account.
Definition AccountID.h:34
@ temINVALID
Definition TER.h:98
@ temINVALID_FLAG
Definition TER.h:99
@ temMALFORMED
Definition TER.h:75
@ temDISABLED
Definition TER.h:102
@ temBAD_AMOUNT
Definition TER.h:77
bool isTesSuccess(TER x) noexcept
Definition TER.h:686
TERSubset< CanCvtToTER > TER
Definition TER.h:657
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.
@ tecWRONG_ASSET
Definition TER.h:371
@ tecPSEUDO_ACCOUNT
Definition TER.h:373
@ tecLOCKED
Definition TER.h:369
@ tecNO_LINE_INSUF_RESERVE
Definition TER.h:303
@ tecNO_ENTRY
Definition TER.h:317
@ tecOBJECT_NOT_FOUND
Definition TER.h:337
@ tecNO_AUTH
Definition TER.h:311
@ tecBAD_CREDENTIALS
Definition TER.h:370
@ tecINVARIANT_FAILED
Definition TER.h:324
@ tecFROZEN
Definition TER.h:314
@ tecINSUFFICIENT_FUNDS
Definition TER.h:336
@ tecEXPIRED
Definition TER.h:325
@ tecNO_LINE
Definition TER.h:312
@ tecPRECISION_LOSS
Definition TER.h:374
@ tecINSUFFICIENT_RESERVE
Definition TER.h:318
@ tecLIMIT_EXCEEDED
Definition TER.h:372
@ tecNO_PERMISSION
Definition TER.h:316
@ tecDST_TAG_NEEDED
Definition TER.h:320
@ tecHAS_OBLIGATIONS
Definition TER.h:328
@ tecNO_DST
Definition TER.h:301
constexpr std::uint64_t kMaxMpTokenAmount
The maximum amount of MPTokenIssuance.
Definition Protocol.h:297
@ tesSUCCESS
Definition TER.h:253
UInt256 uint256
Definition base_uint.h:587
constexpr FlagValue tfFullyCanonicalSig
Definition TxFlags.h:43
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.
Definition Keylet.h:20
UInt256 key
Definition Keylet.h:21
State information when determining if a tx is likely to claim a fee.
Definition Transactor.h:92
VaultInfo(jtx::PrettyAsset const &asset, UInt256 const &vaultId, AccountID const &pseudo)
Set the destination tag on a JTx.
Definition tag.h:14
Execution context for applying a JSON transaction.
Definition JTx.h:27
Represents an XRP, IOU, or MPT quantity This customizes the string conversion and supports XRP conver...
STAmount const & value() const
Set the sequence number on a JTx.
Definition seq.h:16
T what(T... args)