xrpld
Loading...
Searching...
No Matches
STIssue_test.cpp
1
2#include <test/jtx/Account.h>
3#include <test/jtx/Env.h>
4#include <test/jtx/amount.h> // IWYU pragma: keep
5#include <test/jtx/envconfig.h>
6
7#include <xrpld/core/Config.h>
8
9#include <xrpl/basics/base_uint.h>
10#include <xrpl/basics/strHex.h>
11#include <xrpl/beast/unit_test/suite.h>
12#include <xrpl/json/json_value.h>
13#include <xrpl/json/to_string.h>
14#include <xrpl/protocol/AccountID.h>
15#include <xrpl/protocol/ErrorCodes.h>
16#include <xrpl/protocol/Indexes.h>
17#include <xrpl/protocol/Issue.h>
18#include <xrpl/protocol/MPTIssue.h>
19#include <xrpl/protocol/SField.h>
20#include <xrpl/protocol/STIssue.h>
21#include <xrpl/protocol/Serializer.h>
22#include <xrpl/protocol/UintTypes.h>
23#include <xrpl/protocol/jss.h>
24
25#include <array>
26#include <cstdint>
27#include <memory>
28
29namespace xrpl::test {
30
32{
33public:
34 void
36 {
37 testcase("Constructor");
38 using namespace jtx;
39 Account const alice{"alice"};
40 auto const usd = alice["USD"];
41 Issue issue;
42
43 try
44 {
45 issue = xrpIssue();
46 issue.account = alice;
47 STIssue const stissue(sfAsset, Asset{issue});
48 fail("Inconsistent XRP Issue doesn't fail");
49 }
50 catch (...)
51 {
52 pass();
53 }
54
55 try
56 {
57 issue = usd;
58 issue.account = xrpAccount();
59 STIssue const stissue(sfAsset, Asset{issue});
60 fail("Inconsistent IOU Issue doesn't fail");
61 }
62 catch (...)
63 {
64 pass();
65 }
66
67 try
68 {
69 // Currency is USD but account is XRP
70 auto const data =
71 "00000000000000000000000055534400000000000000000000000000000000"
72 "000000000000000000";
73 BaseUInt<320> uint;
74 (void)uint.parseHex(data);
75 SerialIter iter(Slice(uint.data(), uint.size()));
76 STIssue const stissue(iter, sfAsset);
77 fail("Inconsistent IOU Issue doesn't fail on serializer");
78 }
79 catch (...)
80 {
81 pass();
82 }
83
84 try
85 {
86 STIssue const stissue(sfAsset, Asset{xrpIssue()});
87 }
88 catch (...)
89 {
90 fail("XRP issue failed");
91 }
92
93 try
94 {
95 STIssue const stissue(sfAsset, Asset{usd});
96 }
97 catch (...)
98 {
99 fail("USD issue failed");
100 }
101
102 try
103 {
104 auto const data =
105 "0000000000000000000000005553440000000000ae123a8556f3cf91154711"
106 "376afb0f894f832b3d";
107 BaseUInt<320> uint;
108 (void)uint.parseHex(data);
109 SerialIter iter(Slice(uint.data(), uint.size()));
110 STIssue const stissue(iter, sfAsset);
111 BEAST_EXPECT(stissue.value() == usd);
112 }
113 catch (...)
114 {
115 fail("USD Issue fails on serializer");
116 }
117
118 try
119 {
120 auto const data = "0000000000000000000000000000000000000000";
121 BaseUInt<160> uint;
122 (void)uint.parseHex(data);
123 SerialIter iter(Slice(uint.data(), uint.size()));
124 STIssue const stissue(iter, sfAsset);
125 BEAST_EXPECT(stissue.value() == xrpCurrency());
126 }
127 catch (...)
128 {
129 fail("XRP Issue fails on serializer");
130 }
131 }
132
133 void
135 {
136 testcase("Compare");
137 using namespace jtx;
138 Account const alice{"alice"};
139 auto const usd = alice["USD"];
140 Asset const asset1{xrpIssue()};
141 Asset const asset2{usd};
142 Asset const asset3{MPTID{2}};
143
144 BEAST_EXPECT(STIssue(sfAsset, asset1) != asset2);
145 BEAST_EXPECT(STIssue(sfAsset, asset1) != asset3);
146 BEAST_EXPECT(STIssue(sfAsset, asset1) == asset1);
147 BEAST_EXPECT(STIssue(sfAsset, asset1).getText() == "XRP");
148 BEAST_EXPECT(
149 STIssue(sfAsset, asset2).getText() == "USD/rG1QQv2nh2gr7RCZ1P8YYcBUKCCN633jCn");
150 BEAST_EXPECT(
151 STIssue(sfAsset, asset3).getText() ==
152 "000000000000000000000000000000000000000000000002");
153 }
154
155 void
157 {
158 testcase("noAccount issuer rejected via RPC sign");
159
160 using namespace jtx;
161 Env env{*this, envconfig([](std::unique_ptr<Config> cfg) {
162 cfg->loadFromString("[signing_support]\ntrue");
163 return cfg;
164 })};
165
166 Account const alice{"alice"};
167 env.fund(XRP(10000), alice);
168 env.close();
169
170 json::Value txJson;
171 txJson[jss::TransactionType] = "AMMDelete";
172 txJson[jss::Account] = alice.human();
173 txJson[jss::Asset][jss::currency] = "USD";
174 txJson[jss::Asset][jss::issuer] = to_string(noAccount());
175 txJson[jss::Asset2][jss::currency] = "XRP";
176
177 json::Value req;
178 req[jss::tx_json] = txJson;
179 req[jss::secret] = alice.name();
180
181 auto const result = env.rpc("json", "sign", to_string(req))[jss::result];
182
183 BEAST_EXPECT(result[jss::error] == "invalidParams");
184 BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
185 BEAST_EXPECT(result[jss::error_message] == "Field 'tx_json.Asset' has invalid data.");
186 }
187
188 void
190 {
191 testcase("noAccount issuer rejection");
192
193 {
194 json::Value jv;
195 jv[jss::currency] = "USD";
196 jv[jss::issuer] = to_string(noAccount());
197
198 try
199 {
200 issueFromJson(sfAsset, jv);
201 fail("issueFromJson accepted noAccount() as IOU issuer");
202 }
203 catch (...)
204 {
205 pass();
206 }
207 }
208
209 {
210 Serializer s;
211 s.addBitString(toCurrency("USD"));
213 SerialIter iter(s.slice());
214
215 try
216 {
217 STIssue const stissue(iter, sfAsset);
218 fail(
219 "STIssue deserialization of [USD][noAccount()] should "
220 "throw");
221 }
222 catch (...)
223 {
224 pass();
225 }
226 }
227 }
228
229 void
231 {
232 testcase("xrpAccount issuer rejected via RPC sign");
233
234 using namespace jtx;
235 Env env{*this, envconfig([](std::unique_ptr<Config> cfg) {
236 cfg->loadFromString("[signing_support]\ntrue");
237 return cfg;
238 })};
239
240 Account const alice{"alice"};
241 env.fund(XRP(10000), alice);
242 env.close();
243
244 json::Value txJson;
245 txJson[jss::TransactionType] = "AMMDelete";
246 txJson[jss::Account] = alice.human();
247 txJson[jss::Asset][jss::currency] = "USD";
248 txJson[jss::Asset][jss::issuer] = to_string(xrpAccount());
249 txJson[jss::Asset2][jss::currency] = "XRP";
250
251 json::Value req;
252 req[jss::tx_json] = txJson;
253 req[jss::secret] = alice.name();
254
255 auto const result = env.rpc("json", "sign", to_string(req))[jss::result];
256
257 BEAST_EXPECT(result[jss::error] == "invalidParams");
258 BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
259 BEAST_EXPECT(result[jss::error_message] == "Field 'tx_json.Asset' has invalid data.");
260 }
261
262 void
264 {
265 testcase("xrpAccount issuer rejection");
266
267 {
268 json::Value jv;
269 jv[jss::currency] = "USD";
270 jv[jss::issuer] = to_string(xrpAccount());
271
272 try
273 {
274 issueFromJson(sfAsset, jv);
275 fail("issueFromJson accepted xrpAccount() as IOU issuer");
276 }
277 catch (...)
278 {
279 pass();
280 }
281 }
282 }
283
284 void
286 {
287 testcase("MPT serialization");
288 using namespace jtx;
289 Account const alice{"alice"};
290
291 // 0x01020304 pins canonical MPTID bytes 01 02 03 04 and
292 // preserved STIssue wire bytes 04 03 02 01 on BE and LE.
293 auto const sequences = std::to_array<std::uint32_t>({0x00000001, 0x01020304, 0xa1b2c3d4});
294
295 for (auto const vector : sequences)
296 {
297 MPTID const mptID = makeMptID(vector, alice);
298 MPTIssue const issue{mptID};
299 STIssue const stIssue(sfAsset, Asset{issue});
300
301 Serializer actual;
302 stIssue.add(actual);
303
304 // STIssue preserves the existing little-endian validator ledger bytes.
305 Serializer expected;
306 expected.addBitString(alice.id());
307 expected.addBitString(noAccount());
308 {
310 static_cast<unsigned char>(vector),
311 static_cast<unsigned char>(vector >> 8),
312 static_cast<unsigned char>(vector >> 16),
313 static_cast<unsigned char>(vector >> 24),
314 };
315 expected.addRaw(bytes.data(), bytes.size());
316 }
317
318 BEAST_EXPECTS(strHex(actual) == strHex(expected), strHex(actual));
319
320 // Decoding the preserved wire format must recover the canonical MPTID.
321 SerialIter iter(expected.slice());
322 STIssue const decoded(iter, sfAsset);
323 BEAST_EXPECT(decoded.holds<MPTIssue>());
324 BEAST_EXPECT(decoded.value().get<MPTIssue>().getMptID() == mptID);
325
326 // A decoded ledger value must serialize back to the same bytes.
327 Serializer roundTrip;
328 decoded.add(roundTrip);
329 BEAST_EXPECTS(strHex(roundTrip) == strHex(expected), strHex(roundTrip));
330 }
331 }
332
333 void
334 run() override
335 {
336 // compliments other unit tests to ensure complete coverage
338 testCompare();
344 }
345};
346
348
349} // namespace xrpl::test
A testsuite class.
Definition suite.h:52
void pass()
Record a successful test condition.
Definition suite.h:532
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
constexpr TIss const & get() const
Integers of any length that is a multiple of 32-bits.
Definition base_uint.h:82
pointer data()
Definition base_uint.h:117
static constexpr std::size_t size()
Definition base_uint.h:549
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
AccountID account
Definition Issue.h:21
constexpr MPTID const & getMptID() const
Definition MPTIssue.h:43
void add(Serializer &s) const override
Definition STIssue.cpp:96
bool holds() const
Definition STIssue.h:105
value_type const & value() const noexcept
Definition STIssue.h:120
int addBitString(BaseUInt< Bits, Tag > const &v)
Definition Serializer.h:202
int addRaw(Blob const &vector)
Slice slice() const noexcept
Definition Serializer.h:141
An immutable linear range of bytes.
Definition Slice.h:28
void run() override
Runs the suite.
Immutable cryptographic account descriptor.
Definition jtx/Account.h:21
std::string const & human() const
Returns the human readable public key.
std::string const & name() const
Return the name.
Definition jtx/Account.h:75
AccountID id() const
Returns the Account ID.
A transaction testing environment.
Definition Env.h:161
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
Definition Env.cpp:133
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
Definition Env.cpp:323
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
T data(T... args)
XrpT const XRP
Converts to XRP Issue or STAmount.
Definition amount.cpp:92
std::unique_ptr< Config > envconfig()
creates and initializes a default configuration for jtx::Env
Definition envconfig.h:38
BEAST_DEFINE_TESTSUITE(AMMClawback, app, xrpl)
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
Issue issueFromJson(json::Value const &v)
Definition Issue.cpp:89
@ RpcInvalidParams
Definition ErrorCodes.h:67
std::string strHex(FwdIt begin, FwdIt end)
Definition strHex.h:13
bool toCurrency(Currency &, std::string const &)
Tries to convert a string to a Currency, returns true on success.
Definition UintTypes.cpp:65
Currency const & xrpCurrency()
XRP currency.
Definition UintTypes.cpp:99
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
BaseUInt< 192 > MPTID
MPTID is a 192-bit value representing MPT Issuance ID, which is a concatenation of a 32-bit sequence ...
Definition UintTypes.h:54
MPTID makeMptID(std::uint32_t const sequence, AccountID const &account)
Definition Indexes.cpp:219
AccountID const & noAccount()
A placeholder for empty accounts.
AccountID const & xrpAccount()
Compute AccountID from public key.
T size(T... args)