xrpld
Loading...
Searching...
No Matches
LedgerData_test.cpp
1
2#include <test/jtx/Account.h>
3#include <test/jtx/Env.h>
4#include <test/jtx/TestHelpers.h>
5#include <test/jtx/amount.h>
6#include <test/jtx/deposit.h>
7#include <test/jtx/envconfig.h>
8#include <test/jtx/multisign.h>
9#include <test/jtx/offer.h>
10#include <test/jtx/ticket.h>
11
12#include <xrpl/basics/StringUtilities.h>
13#include <xrpl/basics/base_uint.h>
14#include <xrpl/basics/chrono.h>
15#include <xrpl/basics/strHex.h>
16#include <xrpl/beast/unit_test/suite.h>
17#include <xrpl/json/json_value.h>
18#include <xrpl/json/to_string.h>
19#include <xrpl/ledger/View.h>
20#include <xrpl/protocol/ErrorCodes.h>
21#include <xrpl/protocol/Feature.h>
22#include <xrpl/protocol/SField.h>
23#include <xrpl/protocol/Serializer.h>
24#include <xrpl/protocol/jss.h>
25
26#include <chrono>
27#include <cstdint>
28#include <string>
29
30namespace xrpl {
31
33{
34public:
35 // test helper
36 static bool
38 {
39 return val.isMember(jss::marker) && val[jss::marker].isString() &&
40 !val[jss::marker].asString().empty();
41 }
42
43 void
45 {
46 using namespace test::jtx;
47 Env env{*this, asAdmin ? envconfig() : envconfig(noAdmin)};
48 Account const gw{"gateway"};
49 auto const usd = gw["USD"];
50 env.fund(XRP(100000), gw);
51
52 int const maxLimit = 256; // would be 2048 for binary requests, no
53 // need to test that here
54
55 for (auto i = 0; i < maxLimit + 10; i++)
56 {
57 Account const bob{std::string("bob") + std::to_string(i)};
58 env.fund(XRP(1000), bob);
59 }
60 // Note that calls to env.close() fail without admin permission.
61 if (asAdmin)
62 env.close();
63
64 // with no limit specified, we get the max_limit if the total number of
65 // accounts is greater than max, which it is here
66 json::Value jvParams;
67 jvParams[jss::ledger_index] = "current";
68 jvParams[jss::binary] = false;
69 {
70 auto const jrr = env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
71 BEAST_EXPECT(
72 jrr[jss::ledger_current_index].isIntegral() &&
73 jrr[jss::ledger_current_index].asInt() > 0);
74 BEAST_EXPECT(checkMarker(jrr));
75 BEAST_EXPECT(checkArraySize(jrr[jss::state], maxLimit));
76 }
77
78 // check limits values around the max_limit (+/- 1)
79 for (auto delta = -1; delta <= 1; delta++)
80 {
81 jvParams[jss::limit] = maxLimit + delta;
82 auto const jrr = env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
83 BEAST_EXPECT(checkArraySize(
84 jrr[jss::state], (delta > 0 && !asAdmin) ? maxLimit : maxLimit + delta));
85 }
86 }
87
88 void
90 {
91 using namespace test::jtx;
92 Env env{*this, envconfig(noAdmin)};
93 Account const gw{"gateway"};
94 auto const usd = gw["USD"];
95 env.fund(XRP(100000), gw);
96
97 int const numAccounts = 10;
98
99 for (auto i = 0; i < numAccounts; i++)
100 {
101 Account const bob{std::string("bob") + std::to_string(i)};
102 env.fund(XRP(1000), bob);
103 }
104
105 // with no limit specified, we should get all of our fund entries
106 // plus three more related to the gateway setup
107 json::Value jvParams;
108 jvParams[jss::ledger_index] = "current";
109 jvParams[jss::binary] = true;
110 auto const jrr = env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
111 BEAST_EXPECT(
112 jrr[jss::ledger_current_index].isIntegral() &&
113 jrr[jss::ledger_current_index].asInt() > 0);
114 BEAST_EXPECT(!jrr.isMember(jss::marker));
115 BEAST_EXPECT(checkArraySize(jrr[jss::state], numAccounts + 4));
116 }
117
118 void
120 {
121 using namespace test::jtx;
122 Env env{*this};
123 Account const gw{"gateway"};
124 auto const usd = gw["USD"];
125 Account const bob{"bob"};
126
127 env.fund(XRP(10000), gw, bob);
128 env.trust(usd(1000), bob);
129
130 {
131 // bad limit
132 json::Value jvParams;
133 jvParams[jss::limit] = "0"; // NOT an integer
134 auto const jrr = env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
135 BEAST_EXPECT(jrr[jss::status] == "error");
136 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
137 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
138 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'limit', not integer.");
139 }
140
141 {
142 // invalid marker
143 json::Value jvParams;
144 jvParams[jss::marker] = "NOT_A_MARKER";
145 auto const jrr = env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
146 BEAST_EXPECT(jrr[jss::status] == "error");
147 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
148 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
149 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'marker', not valid.");
150 }
151
152 {
153 // invalid marker - not a string
154 json::Value jvParams;
155 jvParams[jss::marker] = 1;
156 auto const jrr = env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
157 BEAST_EXPECT(jrr[jss::status] == "error");
158 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
159 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
160 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'marker', not valid.");
161 }
162
163 {
164 // ask for a bad ledger index
165 json::Value jvParams;
166 jvParams[jss::ledger_index] = 10u;
167 auto const jrr = env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
168 BEAST_EXPECT(jrr[jss::status] == "error");
169 BEAST_EXPECT(jrr[jss::error] == "lgrNotFound");
170 BEAST_EXPECT(jrr[jss::error_code] == RpcLgrNotFound);
171 BEAST_EXPECT(jrr[jss::error_message] == "ledgerNotFound");
172 }
173
174 {
175 // binary not a boolean
176 json::Value jvParams;
177 jvParams[jss::binary] = "true";
178 auto const jrr = env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
179 BEAST_EXPECT(jrr[jss::status] == "error");
180 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
181 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
182 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'binary', not boolean.");
183 }
184 }
185
186 void
188 {
189 using namespace test::jtx;
190 Env env{*this, envconfig(noAdmin)};
191 Account const gw{"gateway"};
192 auto const usd = gw["USD"];
193 env.fund(XRP(100000), gw);
194
195 int const numAccounts = 20;
196
197 for (auto i = 0; i < numAccounts; i++)
198 {
199 Account const bob{std::string("bob") + std::to_string(i)};
200 env.fund(XRP(1000), bob);
201 }
202
203 // with no limit specified, we should get all of our fund entries
204 // plus three more related to the gateway setup
205 json::Value jvParams;
206 jvParams[jss::ledger_index] = "current";
207 jvParams[jss::binary] = false;
208 auto jrr = env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
209 auto const totalCount = jrr[jss::state].size();
210
211 // now make request with a limit and loop until we get all
212 jvParams[jss::limit] = 5;
213 jrr = env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
214 BEAST_EXPECT(checkMarker(jrr));
215 auto runningTotal = jrr[jss::state].size();
216 while (jrr.isMember(jss::marker))
217 {
218 jvParams[jss::marker] = jrr[jss::marker];
219 jrr = env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
220 runningTotal += jrr[jss::state].size();
221 }
222 BEAST_EXPECT(runningTotal == totalCount);
223 }
224
225 void
227 {
228 using namespace test::jtx;
229 Env env{*this};
230 env.fund(XRP(100000), "alice");
231 env.close();
232
233 // Ledger header should be present in the first query
234 {
235 // Closed ledger with non binary form
236 json::Value jvParams;
237 jvParams[jss::ledger_index] = "closed";
238 auto jrr = env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
239 if (BEAST_EXPECT(jrr.isMember(jss::ledger)))
240 {
241 BEAST_EXPECT(
242 jrr[jss::ledger][jss::ledger_hash] == to_string(env.closed()->header().hash));
243 }
244 }
245 {
246 // Closed ledger with binary form
247 json::Value jvParams;
248 jvParams[jss::ledger_index] = "closed";
249 jvParams[jss::binary] = true;
250 auto jrr = env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
251 if (BEAST_EXPECT(jrr.isMember(jss::ledger)))
252 {
253 auto data = strUnHex(jrr[jss::ledger][jss::ledger_data].asString());
254 if (BEAST_EXPECT(data); data.has_value())
255 {
256 Serializer s(data->data(), data->size());
257 std::uint32_t seq = 0;
258 BEAST_EXPECT(s.getInteger<std::uint32_t>(seq, 0));
259 BEAST_EXPECT(seq == 3);
260 }
261 }
262 }
263 {
264 // Current ledger with binary form
265 json::Value jvParams;
266 jvParams[jss::binary] = true;
267 auto jrr = env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
268 BEAST_EXPECT(jrr.isMember(jss::ledger));
269 BEAST_EXPECT(!jrr[jss::ledger].isMember(jss::ledger_data));
270 }
271 }
272
273 void
275 {
276 // Put a bunch of different LedgerEntryTypes into a ledger
277 using namespace test::jtx;
278
279 // Make sure fixInnerObjTemplate2 doesn't break amendments.
280 for (FeatureBitset const& features : {
281 testableAmendments() - fixInnerObjTemplate2,
282 testableAmendments() | fixInnerObjTemplate2,
283 })
284 {
285 using namespace std::chrono;
286 Env env{*this, envconfig(validator, ""), features};
287
288 Account const gw{"gateway"};
289 auto const usd = gw["USD"];
290 env.fund(XRP(100000), gw);
291
292 auto const makeRequest = [&env](json::StaticString const& type) {
293 json::Value jvParams;
294 jvParams[jss::ledger_index] = "current";
295 jvParams[jss::type] = type;
296 return env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
297 };
298
299 // Assert that state is an empty array.
300 for (auto const& type : {
301 jss::amendments,
302 jss::check,
303 jss::directory,
304 jss::offer,
305 jss::signer_list,
306 jss::state,
307 jss::ticket,
308 jss::escrow,
309 jss::payment_channel,
310 jss::deposit_preauth,
311 })
312 {
313 auto const jrr = makeRequest(type);
314 BEAST_EXPECT(checkArraySize(jrr[jss::state], 0));
315 }
316
317 int const numAccounts = 10;
318
319 for (auto i = 0; i < numAccounts; i++)
320 {
321 Account const bob{std::string("bob") + std::to_string(i)};
322 env.fund(XRP(1000), bob);
323 }
324 env(offer(Account{"bob0"}, usd(100), XRP(100)));
325 env.trust(Account{"bob2"}["USD"](100), Account{"bob3"});
326
327 auto majorities = getMajorityAmendments(*env.closed());
328 for (int i = 0; i <= 256; ++i)
329 {
330 env.close();
331 majorities = getMajorityAmendments(*env.closed());
332 if (!majorities.empty())
333 break;
334 }
335
336 env(signers(Account{"bob0"}, 1, {{Account{"bob1"}, 1}, {Account{"bob2"}, 1}}));
337 env(ticket::create(env.master, 1));
338
339 {
340 json::Value jv;
341 jv[jss::TransactionType] = jss::EscrowCreate;
342 jv[jss::Account] = Account{"bob5"}.human();
343 jv[jss::Destination] = Account{"bob6"}.human();
344 jv[jss::Amount] = XRP(50).value().getJson(JsonOptions::Values::None);
345 jv[sfFinishAfter.fieldName] =
346 NetClock::time_point{env.now() + 10s}.time_since_epoch().count();
347 env(jv);
348 }
349
350 {
351 json::Value jv;
352 jv[jss::TransactionType] = jss::PaymentChannelCreate;
353 jv[jss::Account] = Account{"bob6"}.human();
354 jv[jss::Destination] = Account{"bob7"}.human();
355 jv[jss::Amount] = XRP(100).value().getJson(JsonOptions::Values::None);
356 jv[jss::SettleDelay] = NetClock::duration{10s}.count();
357 jv[sfPublicKey.fieldName] = strHex(Account{"bob6"}.pk().slice());
358 jv[sfCancelAfter.fieldName] =
359 NetClock::time_point{env.now() + 300s}.time_since_epoch().count();
360 env(jv);
361 }
362
363 env(check::create("bob6", "bob7", XRP(100)));
364
365 // bob9 DepositPreauths bob4 and bob8.
366 env(deposit::auth(Account{"bob9"}, Account{"bob4"}));
367 env(deposit::auth(Account{"bob9"}, Account{"bob8"}));
368 env.close();
369
370 // Now fetch each type
371
372 { // jvParams[jss::type] = "account";
373 auto const jrr = makeRequest(jss::account);
374 BEAST_EXPECT(checkArraySize(jrr[jss::state], 12));
375 for (auto const& j : jrr[jss::state])
376 BEAST_EXPECT(j["LedgerEntryType"] == jss::AccountRoot);
377 }
378
379 { // jvParams[jss::type] = "amendments";
380 auto const jrr = makeRequest(jss::amendments);
381 BEAST_EXPECT(checkArraySize(jrr[jss::state], 1));
382 for (auto const& j : jrr[jss::state])
383 BEAST_EXPECT(j["LedgerEntryType"] == jss::Amendments);
384 }
385
386 { // jvParams[jss::type] = "check";
387 auto const jrr = makeRequest(jss::check);
388 BEAST_EXPECT(checkArraySize(jrr[jss::state], 1));
389 for (auto const& j : jrr[jss::state])
390 BEAST_EXPECT(j["LedgerEntryType"] == jss::Check);
391 }
392
393 { // jvParams[jss::type] = "directory";
394 auto const jrr = makeRequest(jss::directory);
395 BEAST_EXPECT(checkArraySize(jrr[jss::state], 9));
396 for (auto const& j : jrr[jss::state])
397 BEAST_EXPECT(j["LedgerEntryType"] == jss::DirectoryNode);
398 }
399
400 { // jvParams[jss::type] = "fee";
401 auto const jrr = makeRequest(jss::fee);
402 BEAST_EXPECT(checkArraySize(jrr[jss::state], 1));
403 for (auto const& j : jrr[jss::state])
404 BEAST_EXPECT(j["LedgerEntryType"] == jss::FeeSettings);
405 }
406
407 { // jvParams[jss::type] = "hashes";
408 auto const jrr = makeRequest(jss::hashes);
409 BEAST_EXPECT(checkArraySize(jrr[jss::state], 2));
410 for (auto const& j : jrr[jss::state])
411 BEAST_EXPECT(j["LedgerEntryType"] == jss::LedgerHashes);
412 }
413
414 { // jvParams[jss::type] = "offer";
415 auto const jrr = makeRequest(jss::offer);
416 BEAST_EXPECT(checkArraySize(jrr[jss::state], 1));
417 for (auto const& j : jrr[jss::state])
418 BEAST_EXPECT(j["LedgerEntryType"] == jss::Offer);
419 }
420
421 { // jvParams[jss::type] = "signer_list";
422 auto const jrr = makeRequest(jss::signer_list);
423 BEAST_EXPECT(checkArraySize(jrr[jss::state], 1));
424 for (auto const& j : jrr[jss::state])
425 BEAST_EXPECT(j["LedgerEntryType"] == jss::SignerList);
426 }
427
428 { // jvParams[jss::type] = "state";
429 auto const jrr = makeRequest(jss::state);
430 BEAST_EXPECT(checkArraySize(jrr[jss::state], 1));
431 for (auto const& j : jrr[jss::state])
432 BEAST_EXPECT(j["LedgerEntryType"] == jss::RippleState);
433 }
434
435 { // jvParams[jss::type] = "ticket";
436 auto const jrr = makeRequest(jss::ticket);
437 BEAST_EXPECT(checkArraySize(jrr[jss::state], 1));
438 for (auto const& j : jrr[jss::state])
439 BEAST_EXPECT(j["LedgerEntryType"] == jss::Ticket);
440 }
441
442 { // jvParams[jss::type] = "escrow";
443 auto const jrr = makeRequest(jss::escrow);
444 BEAST_EXPECT(checkArraySize(jrr[jss::state], 1));
445 for (auto const& j : jrr[jss::state])
446 BEAST_EXPECT(j["LedgerEntryType"] == jss::Escrow);
447 }
448
449 { // jvParams[jss::type] = "payment_channel";
450 auto const jrr = makeRequest(jss::payment_channel);
451 BEAST_EXPECT(checkArraySize(jrr[jss::state], 1));
452 for (auto const& j : jrr[jss::state])
453 BEAST_EXPECT(j["LedgerEntryType"] == jss::PayChannel);
454 }
455
456 { // jvParams[jss::type] = "deposit_preauth";
457 auto const jrr = makeRequest(jss::deposit_preauth);
458 BEAST_EXPECT(checkArraySize(jrr[jss::state], 2));
459 for (auto const& j : jrr[jss::state])
460 BEAST_EXPECT(j["LedgerEntryType"] == jss::DepositPreauth);
461 }
462
463 { // jvParams[jss::type] = "misspelling";
464 json::Value jvParams;
465 jvParams[jss::ledger_index] = "current";
466 jvParams[jss::type] = "misspelling";
467 auto const jrr = env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
468 BEAST_EXPECT(jrr["error"] == "invalidParams");
469 BEAST_EXPECT(jrr["error_code"] == RpcInvalidParams);
470 BEAST_EXPECT(jrr["error_message"] == "Invalid field 'type'.");
471 }
472 }
473 }
474
475 void
486};
487
489
490} // namespace xrpl
A testsuite class.
Definition suite.h:52
Lightweight wrapper to tag static string.
Definition json_value.h:52
Represents a JSON value.
Definition json_value.h:121
bool isString() const
UInt size() const
Number of values in array or object.
std::string asString() const
Returns the unquoted string value.
bool isMember(char const *key) const
Return true if the object has a member named key.
void run() override
Runs the suite.
static bool checkMarker(json::Value const &val)
void testCurrentLedgerToLimits(bool asAdmin)
std::chrono::time_point< NetClock > time_point
Definition chrono.h:48
std::chrono::duration< rep, period > duration
Definition chrono.h:47
bool getInteger(Integer &number, int offset)
Definition Serializer.h:232
T empty(T... args)
The api_version numbers this server serves.
Definition ApiVersion.h:26
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
@ RpcLgrNotFound
Definition ErrorCodes.h:55
@ RpcInvalidParams
Definition ErrorCodes.h:67
std::string strHex(FwdIt begin, FwdIt end)
Definition strHex.h:13
auto makeRequest(bool crawlPublic, bool comprEnabled, bool ledgerReplayEnabled, bool txReduceRelayEnabled, bool vpReduceRelayEnabled) -> RequestType
Make outbound http request.
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
BEAST_DEFINE_TESTSUITE_PRIO(NFTokenBaseUtil, app, xrpl, 2)
std::optional< Blob > strUnHex(std::size_t strSize, Iterator begin, Iterator end)
MajorityAmendmentsT getMajorityAmendments(ReadView const &view)
Definition View.cpp:318
T to_string(T... args)