xrpld
Loading...
Searching...
No Matches
InvariantsTrustLine_test.cpp
1#include <test/app/invariants/InvariantsBase.h>
2#include <test/jtx/Account.h>
3#include <test/jtx/Env.h>
4#include <test/jtx/amount.h>
5#include <test/jtx/pay.h>
6#include <test/jtx/trust.h>
7#include <test/jtx/vault.h>
8
9#include <xrpl/beast/unit_test/suite.h>
10#include <xrpl/ledger/ApplyView.h>
11#include <xrpl/protocol/Indexes.h>
12#include <xrpl/protocol/Issue.h>
13#include <xrpl/protocol/LedgerFormats.h>
14#include <xrpl/protocol/SField.h>
15#include <xrpl/protocol/STLedgerEntry.h>
16#include <xrpl/protocol/STObject.h>
17#include <xrpl/protocol/STTx.h>
18#include <xrpl/protocol/TER.h>
19#include <xrpl/protocol/TxFlags.h>
20#include <xrpl/protocol/TxFormats.h>
21#include <xrpl/protocol/XRPAmount.h>
22#include <xrpl/tx/ApplyContext.h>
23#include <xrpl/tx/applySteps.h>
24
25#include <cstdint>
26#include <functional>
27#include <initializer_list>
28#include <memory>
29#include <string>
30#include <vector>
31
32namespace xrpl::test {
33
35{
36 void
38 {
39 using namespace test::jtx;
40 testcase << "trust lines with XRP not allowed";
42 {{"an XRP trust line was created"}},
43 [](Account const& a1, Account const& a2, ApplyContext& ac) {
44 // create simple trust SLE with xrp currency
45 auto const sleNew =
47 ac.view().insert(sleNew);
48 return true;
49 });
50 }
51
52 void
54 {
55 using namespace test::jtx;
56 testcase << "trust lines with deep freeze flag without freeze "
57 "not allowed";
59 {
60 {
61 "a trust line with deep freeze flag without normal freeze was "
62 "created",
63 },
64 },
65 [](Account const& a1, Account const& a2, ApplyContext& ac) {
66 auto const sleNew =
67 std::make_shared<SLE>(keylet::trustLine(a1, a2, a1["USD"].currency));
68 sleNew->setFieldAmount(sfLowLimit, a1["USD"](0));
69 sleNew->setFieldAmount(sfHighLimit, a1["USD"](0));
70
71 std::uint32_t uFlags = 0u;
72 uFlags |= lsfLowDeepFreeze;
73 sleNew->setFieldU32(sfFlags, uFlags);
74 ac.view().insert(sleNew);
75 return true;
76 });
77
79 {
80 {
81 "a trust line with deep freeze flag without normal freeze was "
82 "created",
83 },
84 },
85 [](Account const& a1, Account const& a2, ApplyContext& ac) {
86 auto const sleNew =
87 std::make_shared<SLE>(keylet::trustLine(a1, a2, a1["USD"].currency));
88 sleNew->setFieldAmount(sfLowLimit, a1["USD"](0));
89 sleNew->setFieldAmount(sfHighLimit, a1["USD"](0));
90 std::uint32_t uFlags = 0u;
91 uFlags |= lsfHighDeepFreeze;
92 sleNew->setFieldU32(sfFlags, uFlags);
93 ac.view().insert(sleNew);
94 return true;
95 });
96
98 {
99 {
100 "a trust line with deep freeze flag without normal freeze was "
101 "created",
102 },
103 },
104 [](Account const& a1, Account const& a2, ApplyContext& ac) {
105 auto const sleNew =
106 std::make_shared<SLE>(keylet::trustLine(a1, a2, a1["USD"].currency));
107 sleNew->setFieldAmount(sfLowLimit, a1["USD"](0));
108 sleNew->setFieldAmount(sfHighLimit, a1["USD"](0));
109 std::uint32_t uFlags = 0u;
110 uFlags |= lsfLowDeepFreeze | lsfHighDeepFreeze;
111 sleNew->setFieldU32(sfFlags, uFlags);
112 ac.view().insert(sleNew);
113 return true;
114 });
115
117 {
118 {
119 "a trust line with deep freeze flag without normal freeze was "
120 "created",
121 },
122 },
123 [](Account const& a1, Account const& a2, ApplyContext& ac) {
124 auto const sleNew =
125 std::make_shared<SLE>(keylet::trustLine(a1, a2, a1["USD"].currency));
126 sleNew->setFieldAmount(sfLowLimit, a1["USD"](0));
127 sleNew->setFieldAmount(sfHighLimit, a1["USD"](0));
128 std::uint32_t uFlags = 0u;
129 uFlags |= lsfLowDeepFreeze | lsfHighFreeze;
130 sleNew->setFieldU32(sfFlags, uFlags);
131 ac.view().insert(sleNew);
132 return true;
133 });
134
136 {
137 {
138 "a trust line with deep freeze flag without normal freeze was "
139 "created",
140 },
141 },
142 [](Account const& a1, Account const& a2, ApplyContext& ac) {
143 auto const sleNew =
144 std::make_shared<SLE>(keylet::trustLine(a1, a2, a1["USD"].currency));
145 sleNew->setFieldAmount(sfLowLimit, a1["USD"](0));
146 sleNew->setFieldAmount(sfHighLimit, a1["USD"](0));
147 std::uint32_t uFlags = 0u;
148 uFlags |= lsfLowFreeze | lsfHighDeepFreeze;
149 sleNew->setFieldU32(sfFlags, uFlags);
150 ac.view().insert(sleNew);
151 return true;
152 });
153 }
154
155 void
157 {
158 using namespace test::jtx;
159 testcase << "transfers when frozen";
160
161 Account const g1{"G1"};
162 // Helper function to establish the trustlines
163 auto const createTrustlines = [&](Account const& a1, Account const& a2, Env& env) {
164 // Preclose callback to establish trust lines with gateway
165 env.fund(XRP(1000), g1);
166
167 env.trust(g1["USD"](10000), a1);
168 env.trust(g1["USD"](10000), a2);
169 env.close();
170
171 env(pay(g1, a1, g1["USD"](1000)));
172 env(pay(g1, a2, g1["USD"](1000)));
173 env.close();
174
175 return true;
176 };
177
178 auto const a1FrozenByIssuer = [&](Account const& a1, Account const& a2, Env& env) {
179 createTrustlines(a1, a2, env);
180 env(trust(g1, a1["USD"](10000), tfSetFreeze));
181 env.close();
182
183 return true;
184 };
185
186 auto const a1DeepFrozenByIssuer = [&](Account const& a1, Account const& a2, Env& env) {
187 a1FrozenByIssuer(a1, a2, env);
188 env(trust(g1, a1["USD"](10000), tfSetDeepFreeze));
189 env.close();
190
191 return true;
192 };
193
194 auto const changeBalances = [&](Account const& a1,
195 Account const& a2,
196 ApplyContext& ac,
197 int a1Balance,
198 int a2Balance) {
199 auto const sleA1 = ac.view().peek(keylet::trustLine(a1, g1["USD"]));
200 auto const sleA2 = ac.view().peek(keylet::trustLine(a2, g1["USD"]));
201
202 sleA1->setFieldAmount(sfBalance, g1["USD"](a1Balance));
203 sleA2->setFieldAmount(sfBalance, g1["USD"](a2Balance));
204
205 ac.view().update(sleA1);
206 ac.view().update(sleA2);
207 };
208
209 // test: imitating frozen A1 making a payment to A2.
211 {{"Attempting to move frozen funds"}},
212 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
213 changeBalances(a1, a2, ac, -900, -1100);
214 return true;
215 },
216 XRPAmount{},
217 STTx{ttPAYMENT, [](STObject& tx) {}},
219 a1FrozenByIssuer);
220
221 // test: imitating deep frozen A1 making a payment to A2.
223 {{"Attempting to move frozen funds"}},
224 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
225 changeBalances(a1, a2, ac, -900, -1100);
226 return true;
227 },
228 XRPAmount{},
229 STTx{ttPAYMENT, [](STObject& tx) {}},
231 a1DeepFrozenByIssuer);
232
233 // test: imitating A2 making a payment to deep frozen A1.
235 {{"Attempting to move frozen funds"}},
236 [&](Account const& a1, Account const& a2, ApplyContext& ac) {
237 changeBalances(a1, a2, ac, -1100, -900);
238 return true;
239 },
240 XRPAmount{},
241 STTx{ttPAYMENT, [](STObject& tx) {}},
243 a1DeepFrozenByIssuer);
244 }
245
246 void
253};
254
255BEAST_DEFINE_TESTSUITE(InvariantsTrustLine, app, xrpl);
256
257} // namespace xrpl::test
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
State information when applying a tx.
void doInvariantCheck(std::vector< std::string > const &expectLogs, Precheck const &precheck, XRPAmount fee=XRPAmount{}, STTx tx=STTx{ttACCOUNT_SET, [](STObject &) {}}, std::initializer_list< TER > ters={tecINVARIANT_FAILED, tefINVARIANT_FAILED}, Preclose const &preclose={}, TxAccount setTxAccount=TxAccount::None, std::source_location const &loc=std::source_location::current(), TER initialResult=tesSUCCESS)
Run a specific test case to put the ledger into a state that will be detected by an invariant.
Immutable cryptographic account descriptor.
Definition jtx/Account.h:21
A transaction testing environment.
Definition Env.h:161
T make_shared(T... args)
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
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 trust(Account const &account, STAmount const &amount, std::uint32_t flags)
Modify a trust line.
Definition trust.cpp:18
BEAST_DEFINE_TESTSUITE(AMMClawback, app, xrpl)
constexpr XRPAmount
Convert XRP to drops (integral types).
Definition TxTest.h:53
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
Issue const & xrpIssue()
Returns an asset specifier that represents XRP.
Definition Issue.h:108
@ tefINVARIANT_FAILED
Definition TER.h:177
@ tecINVARIANT_FAILED
Definition TER.h:324