1#include <test/app/lending/LoanTestBase.h>
2#include <test/jtx/Account.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/batch.h>
8#include <test/jtx/fee.h>
9#include <test/jtx/flags.h>
10#include <test/jtx/offer.h>
11#include <test/jtx/owners.h>
12#include <test/jtx/pay.h>
13#include <test/jtx/seq.h>
14#include <test/jtx/sig.h>
15#include <test/jtx/tags.h>
16#include <test/jtx/ter.h>
17#include <test/jtx/trust.h>
18#include <test/jtx/vault.h>
20#include <xrpl/basics/Number.h>
21#include <xrpl/basics/base_uint.h>
22#include <xrpl/basics/chrono.h>
23#include <xrpl/basics/strHex.h>
24#include <xrpl/beast/unit_test/suite.h>
25#include <xrpl/json/json_value.h>
26#include <xrpl/protocol/Feature.h>
27#include <xrpl/protocol/Indexes.h>
28#include <xrpl/protocol/Issue.h>
29#include <xrpl/protocol/Keylet.h>
30#include <xrpl/protocol/LedgerFormats.h>
31#include <xrpl/protocol/Protocol.h>
32#include <xrpl/protocol/SField.h>
33#include <xrpl/protocol/STAmount.h>
34#include <xrpl/protocol/SeqProxy.h>
35#include <xrpl/protocol/TER.h>
36#include <xrpl/protocol/TxFlags.h>
37#include <xrpl/protocol/Units.h>
55 Keylet const& brokerKeylet,
60 if (
auto const loanSle = env.
le(loanKeylet); BEAST_EXPECT(loanSle))
62 BEAST_EXPECT(loanSle->at(sfPrincipalOutstanding) == 0);
63 BEAST_EXPECT(loanSle->at(sfTotalValueOutstanding) == 0);
64 BEAST_EXPECT(loanSle->at(sfPaymentRemaining) == 0);
66 if (
auto const brokerSle = env.
le(brokerKeylet); BEAST_EXPECT(brokerSle))
67 BEAST_EXPECT(brokerSle->at(sfDebtTotal) == 0);
68 if (
auto const vaultSle = env.
le(vaultKeylet); BEAST_EXPECT(vaultSle))
69 BEAST_EXPECT(vaultSle->at(sfAssetsAvailable) == depositValue);
90 set(account, brokerID, principal.
value()),
91 kCounterparty(counterparty.
id()),
92 kPaymentTotal(paymentTotal),
106 Vault const vault{env};
108 auto const seq = env.
seq(owner);
109 auto const balanceBefore = env.
balance(owner);
110 auto const ownerCountBefore = env.
ownerCount(owner);
115 auto const depositAmount =
XRP(1'000);
121 vault.deposit({.depositor = owner, .id = vaultKeylet.key, .amount = depositAmount}),
125 {.depositor = owner, .id = vaultKeylet.key, .amount = depositAmount}),
127 batch::Inner(vault.del({.owner = owner, .id = vaultKeylet.key}), seq + 4),
131 BEAST_EXPECT(!env.
le(vaultKeylet));
132 BEAST_EXPECT(env.
balance(owner) == balanceBefore - batchFee);
133 BEAST_EXPECT(env.
ownerCount(owner) == ownerCountBefore);
134 BEAST_EXPECT(env.
seq(owner) == seq + 5);
143 testcase(
"vault lifecycle in a batch");
147 Env env(*
this, features);
163 testcase(
"vault lifecycle in a batch, closed-ended vault, subscription phase");
167 Env env(*
this, features);
186 testcase(
"loan lifecycle in a batch, open-ended vault");
190 Env env(*
this, features);
192 Account const lender{
"lender"};
193 Account const borrower{
"borrower"};
194 env.
fund(
XRP(1'000'000), lender, borrower);
198 Vault const vault{env};
200 auto const lenderSeq = env.
seq(lender);
201 auto const borrowerSeq = env.
seq(borrower);
202 auto const lenderBalanceBefore = env.
balance(lender);
203 auto const borrowerBalanceBefore = env.
balance(borrower);
205 auto const depositAmount = asset(50'000);
206 auto const principal = asset(1'000);
209 auto const brokerKeylet =
213 auto const createTx = std::get<0>(vault.create({.owner = lender, .asset = xrpIssue()}));
218 auto const loanSetTx =
loanSetInner(env, lender, brokerKeylet.key, borrower, principal, 2);
219 auto const loanPayTx =
220 loan::pay(borrower, loanKeylet.key, principal.value(), tfLoanFullPayment);
223 env(
batch::outer(lender, lenderSeq, batchFee, tfAllOrNothing),
227 {.depositor = lender, .id = vaultKeylet.key, .amount = depositAmount.value()}),
241 BEAST_EXPECT(env.
balance(borrower) == borrowerBalanceBefore);
242 BEAST_EXPECT(env.
balance(lender) == lenderBalanceBefore - batchFee - depositAmount.
value());
252 testcase(
"loan lifecycle in a batch, closed-ended vault");
256 Env env(*
this, features);
258 Account const lender{
"lender"};
259 Account const borrower{
"borrower"};
260 env.
fund(
XRP(1'000'000), lender, borrower);
264 Vault const vault{env};
266 auto const lenderSeq1 = env.
seq(lender);
267 auto const depositAmount = asset(50'000);
270 auto const brokerKeylet =
273 auto const created = vault.createClosedEnded(
275 auto const createTx = std::get<0>(created);
276 auto const subscriptionDate = std::get<2>(created);
282 env(
batch::outer(lender, lenderSeq1, batch1Fee, tfAllOrNothing),
286 {.depositor = lender, .id = vaultKeylet.key, .amount = depositAmount.value()}),
292 if (
auto const vaultSle = env.
le(vaultKeylet); BEAST_EXPECT(vaultSle))
293 BEAST_EXPECT(vaultSle->at(sfAssetsAvailable) == depositAmount.value());
294 BEAST_EXPECT(env.
le(brokerKeylet));
296 vault.closePastSubscription(subscriptionDate);
299 auto const principal = asset(1'000);
301 auto const lenderSeq2 = env.
seq(lender);
302 auto const borrowerSeq = env.
seq(borrower);
303 auto const lenderBalanceBefore = env.
balance(lender);
304 auto const borrowerBalanceBefore = env.
balance(borrower);
306 auto const loanSetTx =
loanSetInner(env, lender, brokerKeylet.key, borrower, principal, 2);
307 auto const loanPayTx =
308 loan::pay(borrower, loanKeylet.key, principal.value(), tfLoanFullPayment);
311 env(
batch::outer(lender, lenderSeq2, batch2Fee, tfAllOrNothing),
320 BEAST_EXPECT(env.
balance(borrower) == borrowerBalanceBefore);
323 BEAST_EXPECT(env.
balance(lender) == lenderBalanceBefore - batch2Fee);
347 Account const issuer{
"issuer"};
348 Account const lender{
"lender"};
349 Account const borrower{
"borrower"};
352 env.
fund(
XRP(1'000'000), issuer, lender, borrower, mm1, mm2);
353 env(
fset(issuer, asfDefaultRipple));
357 STAmount const iouLimit = iou(1'000'000'000);
358 env(
trust(lender, iouLimit));
359 env(
trust(borrower, iouLimit));
360 env(
trust(mm1, iouLimit));
361 env(
trust(mm2, iouLimit));
372 env(
pay(issuer, mm2, iou(20'000)));
377 env(
offer(mm1, iou(1'000),
XRP(400)));
384 .borrower = borrower,
398 testcase(
"arbitrage across a loan and two crossing offers in a batch");
402 Env env(*
this, features);
404 auto const& iou = setup.iou;
405 auto const& lender = setup.lender;
406 auto const& borrower = setup.borrower;
407 auto const& broker = setup.broker;
408 auto const& mm2 = setup.mm2;
411 auto const principal = iou(1'000);
413 BEAST_EXPECT(env.
balance(borrower, iou) == iou(0));
415 auto const borrowerSeq = env.
seq(borrower);
416 auto const mm2Seq = env.
seq(mm2);
418 auto const loanSetTx =
loanSetInner(env, borrower, broker.brokerID, lender, principal, 2);
419 auto const loanPayTx =
420 loan::pay(borrower, loanKeylet.key, principal.value(), tfLoanFullPayment);
423 env(
batch::outer(borrower, borrowerSeq, batchFee, tfAllOrNothing),
426 offer(borrower,
XRP(400), principal.value(), tfFillOrKill), borrowerSeq + 2),
429 offer(borrower, iou(1'008).value(),
XRP(400), tfFillOrKill), borrowerSeq + 3),
435 if (
auto const loanSle = env.
le(loanKeylet); BEAST_EXPECT(loanSle))
436 BEAST_EXPECT(loanSle->at(sfPrincipalOutstanding) == 0);
437 BEAST_EXPECT(env.
balance(borrower, iou) == iou(8));
440 if (
auto const brokerSle = env.
le(broker.brokerKeylet()); BEAST_EXPECT(brokerSle))
441 BEAST_EXPECT(brokerSle->at(sfDebtTotal) == 0);
442 if (
auto const vaultSle = env.
le(broker.vaultKeylet()); BEAST_EXPECT(vaultSle))
445 vaultSle->at(sfAssetsAvailable) == iou(broker.params.vaultDeposit).value());
457 testcase(
"arbitrage batch rolls back when the sell offer cannot fill");
461 Env env(*
this, features);
463 auto const& iou = setup.iou;
464 auto const& lender = setup.lender;
465 auto const& borrower = setup.borrower;
466 auto const& broker = setup.broker;
468 auto const brokerSleBefore = env.
le(broker.brokerKeylet());
469 auto const vaultSleBefore = env.
le(broker.vaultKeylet());
470 if (!BEAST_EXPECT(brokerSleBefore) || !BEAST_EXPECT(vaultSleBefore))
472 auto const loanSequenceBefore = brokerSleBefore->at(sfLoanSequence);
473 auto const assetsAvailableBefore = vaultSleBefore->at(sfAssetsAvailable);
476 auto const principal = iou(1'000);
478 auto const borrowerSeq = env.
seq(borrower);
479 auto const borrowerBalanceBefore = env.
balance(borrower);
481 auto const loanSetTx =
loanSetInner(env, borrower, broker.brokerID, lender, principal, 2);
482 auto const loanPayTx =
483 loan::pay(borrower, loanKeylet.key, principal.value(), tfLoanFullPayment);
486 env(
batch::outer(borrower, borrowerSeq, batchFee, tfAllOrNothing),
489 offer(borrower,
XRP(400), principal.value(), tfFillOrKill), borrowerSeq + 2),
491 offer(borrower, iou(1'008).value(),
XRP(400), tfFillOrKill), borrowerSeq + 3),
497 BEAST_EXPECT(!env.
le(loanKeylet));
498 if (
auto const brokerSle = env.
le(broker.brokerKeylet()); BEAST_EXPECT(brokerSle))
500 BEAST_EXPECT(brokerSle->at(sfLoanSequence) == loanSequenceBefore);
501 BEAST_EXPECT(brokerSle->at(sfDebtTotal) == 0);
503 BEAST_EXPECT(env.
balance(borrower, iou) == iou(0));
504 BEAST_EXPECT(env.
balance(borrower) == borrowerBalanceBefore - batchFee);
506 if (
auto const vaultSle = env.
le(broker.vaultKeylet()); BEAST_EXPECT(vaultSle))
507 BEAST_EXPECT(vaultSle->at(sfAssetsAvailable) == assetsAvailableBefore);
525 kCounterparty(borrower.
id()),
527 kPaymentInterval(86400),
529 Sig(sfCounterpartySignature, borrower),
542 testcase(
"loan impairment and cover deposit in a batch");
546 Env env(*
this, features);
548 Account const lender{
"lender"};
549 Account const borrower{
"borrower"};
550 env.
fund(
XRP(100'000'000), lender, borrower);
557 originateLoan(env, broker, lender, borrower, asset(1'000).value());
559 auto const loanSleBefore = env.
le(loanKeylet);
560 if (!BEAST_EXPECT(loanSleBefore))
566 env.
close(Tp{D{loanSleBefore->at(sfNextPaymentDueDate) + 1}});
568 auto const brokerSleBefore = env.
le(broker.brokerKeylet());
569 auto const vaultSleBefore = env.
le(broker.vaultKeylet());
570 if (!BEAST_EXPECT(brokerSleBefore) || !BEAST_EXPECT(vaultSleBefore))
572 auto const coverAvailableBefore = brokerSleBefore->at(sfCoverAvailable);
573 auto const lossUnrealizedBefore = vaultSleBefore->at(sfLossUnrealized);
574 auto const additionalCover = asset(500).value();
576 auto const lenderSeq = env.
seq(lender);
578 env(
batch::outer(lender, lenderSeq, batchFee, tfAllOrNothing),
585 if (
auto const loanSle = env.
le(loanKeylet); BEAST_EXPECT(loanSle))
586 BEAST_EXPECT(loanSle->isFlag(lsfLoanImpaired));
589 if (
auto const vaultSle = env.
le(broker.vaultKeylet()); BEAST_EXPECT(vaultSle))
592 vaultSle->at(sfLossUnrealized) ==
593 lossUnrealizedBefore + loanSleBefore->at(sfPrincipalOutstanding));
595 if (
auto const brokerSle = env.
le(broker.brokerKeylet()); BEAST_EXPECT(brokerSle))
596 BEAST_EXPECT(brokerSle->at(sfCoverAvailable) == coverAvailableBefore + additionalCover);
607 testcase(
"loan default and cover withdraw in a batch");
611 Env env(*
this, features);
613 Account const lender{
"lender"};
614 Account const borrower{
"borrower"};
615 env.
fund(
XRP(100'000'000), lender, borrower);
622 originateLoan(env, broker, lender, borrower, asset(1'000).value());
624 auto const loanSleBefore = env.
le(loanKeylet);
625 if (!BEAST_EXPECT(loanSleBefore))
630 auto const dueDate = loanSleBefore->at(sfNextPaymentDueDate);
631 auto const gracePeriod = loanSleBefore->at(sfGracePeriod);
634 env.
close(Tp{D{dueDate + gracePeriod + 1}});
636 auto const brokerSleBefore = env.
le(broker.brokerKeylet());
637 auto const vaultSleBefore = env.
le(broker.vaultKeylet());
638 if (!BEAST_EXPECT(brokerSleBefore) || !BEAST_EXPECT(vaultSleBefore))
641 auto const coverAvailableBefore = brokerSleBefore->at(sfCoverAvailable);
642 auto const assetsAvailableBefore = vaultSleBefore->at(sfAssetsAvailable);
643 auto const assetsTotalBefore = vaultSleBefore->at(sfAssetsTotal);
645 TenthBips32 const coverRateMin{brokerSleBefore->at(sfCoverRateMinimum)};
646 TenthBips32 const coverRateLiquidation{brokerSleBefore->at(sfCoverRateLiquidation)};
647 Number const totalDefaultAmount{loanSleBefore->at(sfPrincipalOutstanding)};
657 auto const minimumCover =
664 loanSleBefore->at(sfLoanScale)),
665 Number{coverAvailableBefore});
667 auto const vaultDefaultAmount = totalDefaultAmount - defaultCovered;
669 auto const lenderSeq = env.
seq(lender);
670 auto const lenderBalanceBefore = env.
balance(lender);
671 auto const withdrawAmount =
STAmount{asset.
raw(), coverAvailableBefore - defaultCovered};
674 env(
batch::outer(lender, lenderSeq, batchFee, tfAllOrNothing),
681 if (
auto const loanSle = env.
le(loanKeylet); BEAST_EXPECT(loanSle))
683 BEAST_EXPECT(loanSle->isFlag(lsfLoanDefault));
684 BEAST_EXPECT(loanSle->at(sfPrincipalOutstanding) == 0);
686 if (
auto const brokerSle = env.
le(broker.brokerKeylet()); BEAST_EXPECT(brokerSle))
688 BEAST_EXPECT(brokerSle->at(sfCoverAvailable) == 0);
689 BEAST_EXPECT(brokerSle->at(sfDebtTotal) == 0);
691 BEAST_EXPECT(env.
balance(lender) == lenderBalanceBefore - batchFee + withdrawAmount);
695 if (
auto const vaultSle = env.
le(broker.vaultKeylet()); BEAST_EXPECT(vaultSle))
697 BEAST_EXPECT(vaultSle->at(sfAssetsAvailable) == assetsAvailableBefore + defaultCovered);
698 BEAST_EXPECT(vaultSle->at(sfAssetsTotal) == assetsTotalBefore - vaultDefaultAmount);
710 testcase(
"independent batch runs every inner despite failing inners");
714 Env env(*
this, features);
720 Vault const vault{env};
722 auto const seq = env.
seq(owner);
724 auto const createTx = std::get<0>(vault.create({.owner = owner, .asset = xrpIssue()}));
725 auto const amount =
XRP(1'000);
728 auto const batchTx = env.
jt(
732 vault.withdraw({.depositor = owner, .id = vaultKeylet.key, .amount = amount}),
735 vault.deposit({.depositor = owner, .id = vaultKeylet.key, .amount = amount}),
737 batch::Inner(vault.del({.owner = owner, .id = vaultKeylet.key}), seq + 4));
741 auto const batchID =
strHex(batchTx.stx->getTransactionID());
742 auto const& innerIDs = batchTx.stx->getBatchTransactionIDs();
743 if (!BEAST_EXPECT(innerIDs.size() == 4))
747 env, batchID,
strHex(innerIDs[1]),
"VaultWithdraw",
"tecPRECISION_LOSS");
750 env, batchID,
strHex(innerIDs[3]),
"VaultDelete",
"tecHAS_OBLIGATIONS");
752 if (
auto const vaultSle = env.
le(vaultKeylet); BEAST_EXPECT(vaultSle))
753 BEAST_EXPECT(vaultSle->at(sfAssetsTotal) == amount.value());
754 BEAST_EXPECT(env.
seq(owner) == seq + 5);
765 testcase(
"independent batch runs every loan inner despite a failing payment");
769 Env env(*
this, features);
771 Account const issuer{
"issuer"};
772 Account const lender{
"lender"};
773 Account const borrower{
"borrower"};
774 env.
fund(
XRP(1'000'000), issuer, lender, borrower);
775 env(
fset(issuer, asfDefaultRipple));
779 STAmount const iouLimit = iou(1'000'000'000);
780 env(
trust(lender, iouLimit));
781 env(
trust(borrower, iouLimit));
784 env(
pay(issuer, lender, iou(2'000'000)));
790 auto const principal = iou(1'000);
791 auto const brokerSleBefore = env.
le(broker.brokerKeylet());
792 if (!BEAST_EXPECT(brokerSleBefore))
794 auto const coverAvailableBefore = brokerSleBefore->at(sfCoverAvailable);
796 auto const lenderSeq = env.
seq(lender);
797 auto const borrowerSeq = env.
seq(borrower);
799 auto const loanSetTx =
loanSetInner(env, lender, broker.brokerID, borrower, principal, 2);
800 auto const loanPayTx =
801 loan::pay(borrower, loanKeylet.key, iou(2'000).value(), tfLoanFullPayment);
802 auto const additionalCover = iou(500);
805 auto const batchTx = env.
jt(
806 batch::outer(lender, lenderSeq, batchFee, tfIndependent),
815 auto const batchID =
strHex(batchTx.stx->getTransactionID());
816 auto const& innerIDs = batchTx.stx->getBatchTransactionIDs();
817 if (!BEAST_EXPECT(innerIDs.size() == 3))
821 env, batchID,
strHex(innerIDs[1]),
"LoanPay",
"tecINSUFFICIENT_FUNDS");
823 env, batchID,
strHex(innerIDs[2]),
"LoanBrokerCoverDeposit",
"tesSUCCESS");
825 if (
auto const loanSle = env.
le(loanKeylet); BEAST_EXPECT(loanSle))
826 BEAST_EXPECT(loanSle->at(sfPrincipalOutstanding) == principal.value());
827 if (
auto const brokerSle = env.
le(broker.brokerKeylet()); BEAST_EXPECT(brokerSle))
830 brokerSle->at(sfCoverAvailable) == coverAvailableBefore + additionalCover.value());
840 for (
auto const& features : {lendingBatch, lendingBatch | featureLendingProtocolV1_1})
TestcaseT testcase
Memberspace for declaring test cases.
std::chrono::time_point< NetClock > time_point
std::chrono::duration< rep, period > duration
Number is a floating point type that can represent a wide range of values.
STAmount const & value() const noexcept
static constexpr SeqProxy rawSequence(std::uint32_t v)
Factory function to return a sequence-based SeqProxy.
void testLoanLifecycleClosedEndedVault(FeatureBitset features)
void testVaultLifecycle(FeatureBitset features)
void assertLoanFullyRepaid(jtx::Env const &env, Keylet const &brokerKeylet, Keylet const &vaultKeylet, Keylet const &loanKeylet, STAmount const &depositValue)
void testLoanLifecycleOpenEndedVault(FeatureBitset features)
void testArbitrage(FeatureBitset features)
ArbitrageSetup setupArbitrage(jtx::Env &env)
void testIndependentLoanChain(FeatureBitset features)
void run() override
Runs the suite.
void testIndependentVaultChain(FeatureBitset features)
static void originateLoan(jtx::Env &env, BrokerInfo const &broker, jtx::Account const &lender, jtx::Account const &borrower, STAmount const &principal)
void testImpairAndCoverDeposit(FeatureBitset features)
void testClosedEndedVaultLifecycle(FeatureBitset features)
void testArbitrageRollback(FeatureBitset features)
void testDefaultAndCoverWithdraw(FeatureBitset features)
void runVaultLifecycleBatch(jtx::Env &env, jtx::Account const &owner, json::Value const &createTx)
static json::Value loanSetInner(jtx::Env &env, jtx::Account const &account, uint256 const &brokerID, jtx::Account const &counterparty, STAmount const &principal, std::uint32_t paymentTotal)
Shared base for the Loan*_test family under src/test/app/lending/.
BrokerInfo createVaultAndBroker(jtx::Env &env, jtx::PrettyAsset const &asset, jtx::Account const &lender, BrokerParameters const ¶ms=BrokerParameters::defaults())
Keylet nextLoanKeylet(jtx::Env const &env, BrokerInfo const &broker)
std::string const iouCurrency_
Immutable cryptographic account descriptor.
AccountID id() const
Returns the Account ID.
A transaction testing environment.
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
json::Value json(JsonValue &&jv, FN const &... fN)
Create JSON from parameters.
SLE::const_pointer le(Account const &account) const
Return an account root.
std::uint32_t ownerCount(Account const &account) const
Return the number of objects owned by an account.
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
std::uint32_t seq(Account const &account) const
Returns the next sequence number on account.
JTx jt(JsonValue &&jv, FN const &... fN)
Create a JTx from parameters.
PrettyAmount balance(Account const &account) const
Returns the XRP balance on an account.
void require(Args const &... args)
Check a set of requirements.
std::shared_ptr< OpenView const > current() const
Returns the current ledger.
Set the regular signature on a JTx.
Set the expected result code for a JTx The test will fail if the code doesn't match.
Adds an inner Batch transaction to a JTx and autofills it.
Sets the Batch transaction signers on a JTx.
Keylet vault(AccountID const &owner, SeqProxy const &seq) noexcept
Keylet loanBroker(AccountID const &owner, SeqProxy const &seq) noexcept
Keylet loan(UInt256 const &loanBrokerID, SeqProxy const &loanSeq) noexcept
void validateInnerTxn(Env &env, std::string const &batchID, std::string const &txHash, std::string const &txType, std::string const &result, std::source_location const &loc=std::source_location::current())
Expect an inner Batch transaction to be recorded with the given type and result, and with ParentBatch...
json::Value outer(jtx::Account const &account, uint32_t seq, STAmount const &fee, std::uint32_t flags)
Build an outer Batch transaction JSON object.
XRPAmount calcBatchFee(jtx::Env const &env, uint32_t const &numSigners, uint32_t const &txns=0)
Calculate the expected outer Batch transaction fee.
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 manage(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)
json::Value pay(AccountID const &account, AccountID const &to, AnyAmount amount)
Create a payment.
XrpT const XRP
Converts to XRP Issue or STAmount.
OwnerCount< ltOFFER > Offers
Match the number of offers in the account's owner directory.
json::Value offer(Account const &account, STAmount const &takerPays, STAmount const &takerGets, std::uint32_t flags)
Create an offer.
json::Value trust(Account const &account, STAmount const &amount, std::uint32_t flags)
Modify a trust line.
json::Value fset(Account const &account, std::uint32_t on, std::uint32_t off=0)
Add and/or remove flag.
BEAST_DEFINE_TESTSUITE(AMMClawback, app, xrpl)
STTx createTx(bool disabling, LedgerIndex seq, PublicKey const &txKey)
Create ttUNL_MODIFY Tx.
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
bool set(T &target, std::string const &name, Section const §ion)
Set a value from a configuration Section If the named value is not found or doesn't parse as a T,...
Issue const & xrpIssue()
Returns an asset specifier that represents XRP.
std::string strHex(FwdIt begin, FwdIt end)
constexpr T tenthBipsOfValue(T value, TenthBips< TBips > bips)
TenthBips< std::uint32_t > TenthBips32
void roundToAsset(A const &asset, Number &value)
Round an arbitrary precision Number IN PLACE to the precision of a given Asset.
A pair of SHAMap key and LedgerEntryType.
TenthBips32 coverRateLiquidation
STAmount const & value() const
Asset const & raw() const
Set the sequence number on a JTx.
std::tuple< json::Value, Keylet > create(CreateArgs const &args) const
Return a VaultCreate transaction and the Vault's expected keylet.
std::tuple< json::Value, Keylet, NetClock::time_point > createClosedEnded(CreateClosedEndedArgs const &args) const
Return a VaultCreate transaction for a closed-ended vault, its expected keylet, and the vault's Subsc...