xrpld
Loading...
Searching...
No Matches
AccountLines_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/credentials.h>
7#include <test/jtx/deposit.h>
8#include <test/jtx/escrow.h>
9#include <test/jtx/flags.h>
10#include <test/jtx/multisign.h>
11#include <test/jtx/offer.h>
12#include <test/jtx/owners.h> // IWYU pragma: keep
13#include <test/jtx/pay.h>
14#include <test/jtx/ticket.h>
15#include <test/jtx/token.h>
16#include <test/jtx/trust.h>
17#include <test/jtx/txflags.h>
18
19#include <xrpl/basics/base_uint.h>
20#include <xrpl/basics/chrono.h>
21#include <xrpl/basics/strHex.h>
22#include <xrpl/beast/unit_test/suite.h>
23#include <xrpl/json/json_value.h>
24#include <xrpl/json/to_string.h>
25#include <xrpl/protocol/ErrorCodes.h>
26#include <xrpl/protocol/LedgerHeader.h>
27#include <xrpl/protocol/PublicKey.h>
28#include <xrpl/protocol/SField.h>
29#include <xrpl/protocol/STAmount.h>
30#include <xrpl/protocol/TxFlags.h>
31#include <xrpl/protocol/jss.h>
32
33#include <cstddef>
34#include <optional>
35#include <string>
36#include <utility>
37#include <vector>
38
39namespace xrpl::rpc {
40
42{
43public:
44 void
46 {
47 testcase("account_lines");
48
49 using namespace test::jtx;
50 Env env(*this);
51
52 static constexpr std::size_t kLinesPerGateway = 26;
53 static constexpr std::size_t kAllLines = 2 * kLinesPerGateway;
54
55 {
56 // account_lines with no account.
57 auto const lines = env.rpc("json", "account_lines", "{ }");
58 BEAST_EXPECT(lines[jss::result][jss::error] == "invalidParams");
59 BEAST_EXPECT(lines[jss::result][jss::error_code] == RpcInvalidParams);
60 BEAST_EXPECT(
61 lines[jss::result][jss::error_message] ==
62 rpc::missingFieldError(jss::account)[jss::error_message]);
63 }
64 {
65 // account_lines with a malformed account.
66 json::Value params;
67 params[jss::account] = "n9MJkEKHDhy5eTLuHUQeAAjo382frHNbFK4C8hcwN4nwM2SrLdBj";
68 auto const lines = env.rpc("json", "account_lines", to_string(params));
69 BEAST_EXPECT(lines[jss::result][jss::error] == "actMalformed");
70 BEAST_EXPECT(lines[jss::result][jss::error_code] == RpcActMalformed);
71 BEAST_EXPECT(
72 lines[jss::result][jss::error_message] ==
73 rpc::makeError(RpcActMalformed)[jss::error_message]);
74 BEAST_EXPECT(lines[jss::result].isMember(jss::ledger_current_index));
75 BEAST_EXPECT(lines[jss::result][jss::validated] == false);
76 }
77 {
78 // An invalid ledger is reported before a missing account.
79 json::Value params;
80 params[jss::ledger_hash] = 1;
81 auto const lines = env.rpc("json", "account_lines", to_string(params))[jss::result];
82 BEAST_EXPECT(lines[jss::error] == "invalidParams");
83 BEAST_EXPECT(lines[jss::error_code] == RpcInvalidParams);
84 BEAST_EXPECT(
85 lines[jss::error_message] == "Invalid field 'ledger_hash', not hex string.");
86 }
87 {
88 // A bad limit is reported before an account that is not found.
89 json::Value params;
90 params[jss::account] = Account{"bogie"}.human();
91 params[jss::limit] = -1;
92 auto const lines = env.rpc("json", "account_lines", to_string(params))[jss::result];
93 BEAST_EXPECT(lines[jss::error] == "invalidParams");
94 BEAST_EXPECT(lines[jss::error_code] == RpcInvalidParams);
95 BEAST_EXPECT(
96 lines[jss::error_message] ==
97 rpc::expectedFieldMessage(jss::limit, "unsigned integer"));
98 }
99 {
100 // test account non-string
101 auto const testInvalidAccountParam = [&](auto const& param) {
102 json::Value params;
103 params[jss::account] = param;
104 auto jrr = env.rpc("json", "account_lines", to_string(params))[jss::result];
105 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
106 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
107 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'account'.");
108 };
109
110 testInvalidAccountParam(1);
111 testInvalidAccountParam(1.1);
112 testInvalidAccountParam(true);
113 testInvalidAccountParam(json::Value(json::ValueType::Null));
114 testInvalidAccountParam(json::Value(json::ValueType::Object));
115 testInvalidAccountParam(json::Value(json::ValueType::Array));
116 }
117 Account const alice{"alice"};
118 {
119 // account_lines on an unfunded account.
120 json::Value params;
121 params[jss::account] = alice.human();
122 auto const lines = env.rpc("json", "account_lines", to_string(params));
123 BEAST_EXPECT(lines[jss::result][jss::error] == "actNotFound");
124 BEAST_EXPECT(lines[jss::result][jss::error_code] == RpcActNotFound);
125 BEAST_EXPECT(
126 lines[jss::result][jss::error_message] ==
127 rpc::makeError(RpcActNotFound)[jss::error_message]);
128 }
129 env.fund(XRP(10000), alice);
130 env.close();
131 LedgerHeader const ledger3Info = env.closed()->header();
132 BEAST_EXPECT(ledger3Info.seq == 3);
133
134 {
135 // test peer non-string
136 auto const testInvalidPeerParam = [&](auto const& param) {
137 json::Value params;
138 params[jss::account] = alice.human();
139 params[jss::peer] = param;
140 auto jrr = env.rpc("json", "account_lines", to_string(params))[jss::result];
141 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
142 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
143 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'peer'.");
144 };
145
146 testInvalidPeerParam(1);
147 testInvalidPeerParam(1.1);
148 testInvalidPeerParam(true);
149 testInvalidPeerParam(json::Value(json::ValueType::Null));
150 testInvalidPeerParam(json::Value(json::ValueType::Object));
151 testInvalidPeerParam(json::Value(json::ValueType::Array));
152 }
153 {
154 // alice is funded but has no lines. An empty array is returned.
155 json::Value params;
156 params[jss::account] = alice.human();
157 auto const lines = env.rpc("json", "account_lines", to_string(params));
158 BEAST_EXPECT(lines[jss::result][jss::lines].isArray());
159 BEAST_EXPECT(lines[jss::result][jss::lines].size() == 0);
160 }
161 {
162 // Specify a ledger that doesn't exist.
163 json::Value params;
164 params[jss::account] = alice.human();
165 params[jss::ledger_index] = "nonsense";
166 auto const lines = env.rpc("json", "account_lines", to_string(params));
167 BEAST_EXPECT(lines[jss::result][jss::error] == "invalidParams");
168 BEAST_EXPECT(lines[jss::result][jss::error_code] == RpcInvalidParams);
169 BEAST_EXPECT(
170 lines[jss::result][jss::error_message] ==
171 "Invalid field 'ledger_index', not string or number.");
172 }
173 {
174 // Specify a different ledger that doesn't exist.
175 json::Value params;
176 params[jss::account] = alice.human();
177 params[jss::ledger_index] = 50000;
178 auto const lines = env.rpc("json", "account_lines", to_string(params));
179 BEAST_EXPECT(lines[jss::result][jss::error] == "lgrNotFound");
180 BEAST_EXPECT(lines[jss::result][jss::error_code] == RpcLgrNotFound);
181 BEAST_EXPECT(lines[jss::result][jss::error_message] == "ledgerNotFound");
182 }
183 // Create trust lines to share with alice.
184 Account const gw1{"gw1"};
185 env.fund(XRP(10000), gw1);
186 std::vector<IOU> gw1Currencies;
187
188 for (char c = 0; c <= ('Z' - 'A'); ++c)
189 {
190 // gw1 currencies have names "YAA" -> "YAZ".
191 gw1Currencies.push_back(gw1[std::string("YA") + static_cast<char>('A' + c)]);
192 IOU const& gw1Currency = gw1Currencies.back();
193
194 // Establish trust lines.
195 env(trust(alice, gw1Currency(100 + c)));
196 env(pay(gw1, alice, gw1Currency(50 + c)));
197 }
198 env.close();
199 LedgerHeader const ledger4Info = env.closed()->header();
200 BEAST_EXPECT(ledger4Info.seq == 4);
201
202 // Add another set of trust lines in another ledger so we can see
203 // differences in historic ledgers.
204 Account const gw2{"gw2"};
205 env.fund(XRP(10000), gw2);
206
207 // gw2 requires authorization.
208 env(fset(gw2, asfRequireAuth));
209 env.close();
210 std::vector<IOU> gw2Currencies;
211
212 for (char c = 0; c <= ('Z' - 'A'); ++c)
213 {
214 // gw2 currencies have names "ZAA" -> "ZAZ".
215 gw2Currencies.push_back(gw2[std::string("ZA") + static_cast<char>('A' + c)]);
216 IOU const& gw2Currency = gw2Currencies.back();
217
218 // Establish trust lines.
219 env(trust(alice, gw2Currency(200 + c)));
220 env(trust(gw2, gw2Currency(0), alice, tfSetfAuth));
221 env.close();
222 env(pay(gw2, alice, gw2Currency(100 + c)));
223 env.close();
224
225 // Set flags on gw2 trust lines so we can look for them.
226 env(trust(alice, gw2Currency(0), gw2, tfSetNoRipple | tfSetFreeze | tfSetDeepFreeze));
227 }
228 env.close();
229 LedgerHeader const ledger58Info = env.closed()->header();
230 BEAST_EXPECT(ledger58Info.seq == 58);
231
232 // A re-usable test for historic ledgers.
233 auto const testAccountLinesHistory =
234 [this, &env](Account const& account, LedgerHeader const& info, std::size_t count) {
235 // Get account_lines by ledger index.
236 json::Value paramsSeq;
237 paramsSeq[jss::account] = account.human();
238 paramsSeq[jss::ledger_index] = info.seq;
239 auto const linesSeq = env.rpc("json", "account_lines", to_string(paramsSeq));
240 BEAST_EXPECT(linesSeq[jss::result][jss::lines].isArray());
241 BEAST_EXPECT(linesSeq[jss::result][jss::lines].size() == count);
242
243 // Get account_lines by ledger hash.
244 json::Value paramsHash;
245 paramsHash[jss::account] = account.human();
246 paramsHash[jss::ledger_hash] = to_string(info.hash);
247 auto const linesHash = env.rpc("json", "account_lines", to_string(paramsHash));
248 BEAST_EXPECT(linesHash[jss::result][jss::lines].isArray());
249 BEAST_EXPECT(linesHash[jss::result][jss::lines].size() == count);
250 };
251
252 // Alice should have no trust lines in ledger 3.
253 testAccountLinesHistory(alice, ledger3Info, 0);
254
255 // Alice should have 26 trust lines in ledger 4.
256 testAccountLinesHistory(alice, ledger4Info, kLinesPerGateway);
257
258 // Alice should have 52 trust lines in ledger 58.
259 testAccountLinesHistory(alice, ledger58Info, kAllLines);
260
261 {
262 // Invalid to specify both index and hash
263 json::Value params;
264 params[jss::account] = alice.human();
265 params[jss::ledger_hash] = to_string(ledger4Info.hash);
266 params[jss::ledger_index] = ledger58Info.seq;
267 auto const lines = env.rpc("json", "account_lines", to_string(params))[jss::result];
268 BEAST_EXPECT(lines[jss::error] == "invalidParams");
269 BEAST_EXPECT(lines[jss::error_code] == RpcInvalidParams);
270 BEAST_EXPECT(
271 lines[jss::error_message] ==
272 "Exactly one of 'ledger_hash' or 'ledger_index' can be "
273 "specified.");
274 }
275 {
276 // Invalid index
277 json::Value params;
278 params[jss::account] = alice.human();
279 params[jss::ledger_index] = json::ValueType::Object;
280 auto const lines = env.rpc("json", "account_lines", to_string(params))[jss::result];
281 BEAST_EXPECT(lines[jss::error] == "invalidParams");
282 BEAST_EXPECT(lines[jss::error_code] == RpcInvalidParams);
283 BEAST_EXPECT(
284 lines[jss::error_message] == "Invalid field 'ledger_index', not string or number.");
285 }
286 {
287 // alice should have 52 trust lines in the current ledger.
288 json::Value params;
289 params[jss::account] = alice.human();
290 auto const lines = env.rpc("json", "account_lines", to_string(params));
291 BEAST_EXPECT(lines[jss::result][jss::lines].isArray());
292 BEAST_EXPECT(lines[jss::result][jss::lines].size() == kAllLines);
293 }
294 {
295 // alice should have 26 trust lines with gw1.
296 json::Value params;
297 params[jss::account] = alice.human();
298 params[jss::peer] = gw1.human();
299 auto const lines = env.rpc("json", "account_lines", to_string(params));
300 BEAST_EXPECT(lines[jss::result][jss::lines].isArray());
301 BEAST_EXPECT(lines[jss::result][jss::lines].size() == kLinesPerGateway);
302
303 // Check no ripple is not set for trustlines between alice and gw1
304 auto const& line = lines[jss::result][jss::lines][0u];
305 BEAST_EXPECT(!line[jss::no_ripple].isMember(jss::no_ripple));
306 }
307 {
308 // Use a malformed peer.
309 json::Value params;
310 params[jss::account] = alice.human();
311 params[jss::peer] = "n9MJkEKHDhy5eTLuHUQeAAjo382frHNbFK4C8hcwN4nwM2SrLdBj";
312 auto const lines = env.rpc("json", "account_lines", to_string(params));
313 BEAST_EXPECT(lines[jss::result][jss::error] == "actMalformed");
314 BEAST_EXPECT(lines[jss::result][jss::error_code] == RpcActMalformed);
315 BEAST_EXPECT(
316 lines[jss::result][jss::error_message] ==
317 rpc::makeError(RpcActMalformed)[jss::error_message]);
318 BEAST_EXPECT(lines[jss::result].isMember(jss::ledger_current_index));
319 BEAST_EXPECT(lines[jss::result][jss::validated] == false);
320 }
321 {
322 // An empty peer is no peer at all.
323 json::Value params;
324 params[jss::account] = alice.human();
325 params[jss::peer] = "";
326 auto const lines = env.rpc("json", "account_lines", to_string(params));
327 params.removeMember(jss::peer);
328 auto const all = env.rpc("json", "account_lines", to_string(params));
329 BEAST_EXPECT(lines[jss::result][jss::lines].isArray());
330 BEAST_EXPECT(lines[jss::result][jss::lines].size() == kAllLines);
331 BEAST_EXPECT(lines[jss::result][jss::lines] == all[jss::result][jss::lines]);
332 }
333 {
334 // ignore_default is read as a bool, so any non-empty string sets it.
335 json::Value params;
336 params[jss::account] = gw1.human();
337 auto const all = env.rpc("json", "account_lines", to_string(params));
338 params[jss::ignore_default] = true;
339 auto const asBool = env.rpc("json", "account_lines", to_string(params));
340 params[jss::ignore_default] = "false";
341 auto const asString = env.rpc("json", "account_lines", to_string(params));
342 BEAST_EXPECT(all[jss::result][jss::lines].size() == kLinesPerGateway);
343 BEAST_EXPECT(asBool[jss::result][jss::lines].size() == 0);
344 BEAST_EXPECT(!asString[jss::result].isMember(jss::error));
345 BEAST_EXPECT(asString[jss::result][jss::lines] == asBool[jss::result][jss::lines]);
346 }
347 {
348 // A negative limit should fail.
349 json::Value params;
350 params[jss::account] = alice.human();
351 params[jss::limit] = -1;
352 auto const lines = env.rpc("json", "account_lines", to_string(params));
353 BEAST_EXPECT(lines[jss::result][jss::error] == "invalidParams");
354 BEAST_EXPECT(lines[jss::result][jss::error_code] == RpcInvalidParams);
355 BEAST_EXPECT(
356 lines[jss::result][jss::error_message] ==
357 rpc::expectedFieldMessage(jss::limit, "unsigned integer"));
358 }
359 {
360 // Limit the response to 1 trust line.
361 json::Value paramsA;
362 paramsA[jss::account] = alice.human();
363 paramsA[jss::limit] = 1;
364 auto const linesA = env.rpc("json", "account_lines", to_string(paramsA));
365 BEAST_EXPECT(linesA[jss::result][jss::lines].isArray());
366 BEAST_EXPECT(linesA[jss::result][jss::lines].size() == 1);
367
368 // Pick up from where the marker left off. We should get 51.
369 auto marker = linesA[jss::result][jss::marker].asString();
370 json::Value paramsB;
371 paramsB[jss::account] = alice.human();
372 paramsB[jss::marker] = marker;
373 auto const linesB = env.rpc("json", "account_lines", to_string(paramsB));
374 BEAST_EXPECT(linesB[jss::result][jss::lines].isArray());
375 BEAST_EXPECT(linesB[jss::result][jss::lines].size() == kAllLines - 1);
376
377 // Go again from where the marker left off, but set a limit of 3.
378 json::Value paramsC;
379 paramsC[jss::account] = alice.human();
380 paramsC[jss::limit] = 3;
381 paramsC[jss::marker] = marker;
382 auto const linesC = env.rpc("json", "account_lines", to_string(paramsC));
383 BEAST_EXPECT(linesC[jss::result][jss::lines].isArray());
384 BEAST_EXPECT(linesC[jss::result][jss::lines].size() == 3);
385
386 // Mess with the marker so it becomes bad and check for the error.
387 marker[5] = marker[5] == '7' ? '8' : '7';
388 json::Value paramsD;
389 paramsD[jss::account] = alice.human();
390 paramsD[jss::marker] = marker;
391 auto const linesD = env.rpc("json", "account_lines", to_string(paramsD));
392 BEAST_EXPECT(linesD[jss::result][jss::error] == "invalidParams");
393 BEAST_EXPECT(linesD[jss::result][jss::error_code] == RpcInvalidParams);
394 BEAST_EXPECT(
395 linesD[jss::result][jss::error_message] ==
396 rpc::makeError(RpcInvalidParams)[jss::error_message]);
397 }
398 {
399 // A non-string marker should also fail.
400 json::Value params;
401 params[jss::account] = alice.human();
402 params[jss::marker] = true;
403 auto const lines = env.rpc("json", "account_lines", to_string(params));
404 BEAST_EXPECT(lines[jss::result][jss::error] == "invalidParams");
405 BEAST_EXPECT(lines[jss::result][jss::error_code] == RpcInvalidParams);
406 BEAST_EXPECT(
407 lines[jss::result][jss::error_message] ==
408 rpc::expectedFieldMessage(jss::marker, "string"));
409 }
410 {
411 // A marker that does not parse is reported without naming the field.
412 json::Value params;
413 params[jss::account] = alice.human();
414 params[jss::marker] = "NOT_A_MARKER";
415 auto const lines = env.rpc("json", "account_lines", to_string(params));
416 BEAST_EXPECT(lines[jss::result][jss::error] == "invalidParams");
417 BEAST_EXPECT(lines[jss::result][jss::error_code] == RpcInvalidParams);
418 BEAST_EXPECT(
419 lines[jss::result][jss::error_message] ==
420 rpc::makeError(RpcInvalidParams)[jss::error_message]);
421 }
422 {
423 // The marker's start hint may have a leading '+', and anything after a second
424 // comma is ignored.
425 json::Value params;
426 params[jss::account] = alice.human();
427 params[jss::limit] = 1;
428 auto const first = env.rpc("json", "account_lines", to_string(params));
429 auto const marker = first[jss::result][jss::marker].asString();
430 auto const comma = marker.find(',');
431 BEAST_EXPECT(comma != std::string::npos);
432
433 json::Value next;
434 next[jss::account] = alice.human();
435 next[jss::marker] = marker;
436 auto const plain = env.rpc("json", "account_lines", to_string(next));
437 next[jss::marker] =
438 marker.substr(0, comma) + ",+" + marker.substr(comma + 1) + ",ignored";
439 auto const lines = env.rpc("json", "account_lines", to_string(next));
440 BEAST_EXPECT(lines[jss::result][jss::lines].isArray());
441 BEAST_EXPECT(lines[jss::result][jss::lines].size() == kAllLines - 1);
442 BEAST_EXPECT(lines[jss::result][jss::lines] == plain[jss::result][jss::lines]);
443 }
444 {
445 // Check that the flags we expect from alice to gw2 are present.
446 json::Value params;
447 params[jss::account] = alice.human();
448 params[jss::limit] = 10;
449 params[jss::peer] = gw2.human();
450 auto const lines = env.rpc("json", "account_lines", to_string(params));
451 auto const& line = lines[jss::result][jss::lines][0u];
452 BEAST_EXPECT(line[jss::freeze].asBool() == true);
453 BEAST_EXPECT(line[jss::deep_freeze].asBool() == true);
454 BEAST_EXPECT(line[jss::no_ripple].asBool() == true);
455 BEAST_EXPECT(line[jss::peer_authorized].asBool() == true);
456 }
457 {
458 // Check that the flags we expect from gw2 to alice are present.
459 json::Value paramsA;
460 paramsA[jss::account] = gw2.human();
461 paramsA[jss::limit] = 1;
462 paramsA[jss::peer] = alice.human();
463 auto const linesA = env.rpc("json", "account_lines", to_string(paramsA));
464 auto const& lineA = linesA[jss::result][jss::lines][0u];
465 BEAST_EXPECT(lineA[jss::freeze_peer].asBool() == true);
466 BEAST_EXPECT(lineA[jss::deep_freeze_peer].asBool() == true);
467 BEAST_EXPECT(lineA[jss::no_ripple_peer].asBool() == true);
468 BEAST_EXPECT(lineA[jss::authorized].asBool() == true);
469
470 // Continue from the returned marker to make sure that works.
471 BEAST_EXPECT(linesA[jss::result].isMember(jss::marker));
472 auto const marker = linesA[jss::result][jss::marker].asString();
473 json::Value paramsB;
474 paramsB[jss::account] = gw2.human();
475 paramsB[jss::limit] = 25;
476 paramsB[jss::marker] = marker;
477 paramsB[jss::peer] = alice.human();
478 auto const linesB = env.rpc("json", "account_lines", to_string(paramsB));
479 BEAST_EXPECT(linesB[jss::result][jss::lines].isArray());
480 BEAST_EXPECT(linesB[jss::result][jss::lines].size() == 25);
481 BEAST_EXPECT(!linesB[jss::result].isMember(jss::marker));
482 }
483 }
484
485 void
487 {
488 testcase("Entry pointed to by marker is not owned by account");
489 using namespace test::jtx;
490 Env env(*this);
491
492 // The goal of this test is observe account_lines RPC calls return an
493 // error message when the SLE pointed to by the marker is not owned by
494 // the Account being traversed.
495 //
496 // To start, we'll create an environment with some trust lines, offers
497 // and a signers list.
498 Account const alice{"alice"};
499 Account const becky{"becky"};
500 Account const gw1{"gw1"};
501 env.fund(XRP(10000), alice, becky, gw1);
502 env.close();
503
504 // Give alice a SignerList.
505 Account const bogie{"bogie"};
506 env(signers(alice, 2, {{bogie, 3}}));
507 env.close();
508
509 auto const eur = gw1["EUR"];
510 env(trust(alice, eur(200)));
511 env(trust(becky, eur(200)));
512 env.close();
513
514 // Get all account objects for alice and verify that her
515 // signerlist is first. This is only a (reliable) coincidence of
516 // object naming. So if any of alice's objects are renamed this
517 // may fail.
518 json::Value aliceObjectsParams;
519 aliceObjectsParams[jss::account] = alice.human();
520 aliceObjectsParams[jss::limit] = 10;
521 json::Value const aliceObjects =
522 env.rpc("json", "account_objects", to_string(aliceObjectsParams));
523 json::Value const& aliceSignerList = aliceObjects[jss::result][jss::account_objects][0u];
524 if (!(aliceSignerList[sfLedgerEntryType.jsonName] == jss::SignerList))
525 {
526 fail(
527 "alice's account objects are misordered. "
528 "Please reorder the objects so the SignerList is first.",
529 __FILE__,
530 __LINE__);
531 return;
532 }
533
534 // Get account_lines for alice. Limit at 1, so we get a marker
535 // pointing to her SignerList.
536 json::Value aliceLines1Params;
537 aliceLines1Params[jss::account] = alice.human();
538 aliceLines1Params[jss::limit] = 1;
539 auto const aliceLines1 = env.rpc("json", "account_lines", to_string(aliceLines1Params));
540 BEAST_EXPECT(aliceLines1[jss::result].isMember(jss::marker));
541
542 // Verify that the marker points at the signer list.
543 std::string const aliceMarker = aliceLines1[jss::result][jss::marker].asString();
544 std::string const markerIndex = aliceMarker.substr(0, aliceMarker.find(','));
545 BEAST_EXPECT(markerIndex == aliceSignerList[jss::index].asString());
546
547 // When we fetch Alice's remaining lines we should find one and no more.
548 json::Value aliceLines2Params;
549 aliceLines2Params[jss::account] = alice.human();
550 aliceLines2Params[jss::marker] = aliceMarker;
551 auto const aliceLines2 = env.rpc("json", "account_lines", to_string(aliceLines2Params));
552 BEAST_EXPECT(aliceLines2[jss::result][jss::lines].size() == 1);
553 BEAST_EXPECT(!aliceLines2[jss::result].isMember(jss::marker));
554
555 // Get account lines for becky's account, using alice's SignerList as a
556 // marker. This should cause an error.
557 json::Value beckyLinesParams;
558 beckyLinesParams[jss::account] = becky.human();
559 beckyLinesParams[jss::marker] = aliceMarker;
560 auto const beckyLines = env.rpc("json", "account_lines", to_string(beckyLinesParams));
561 BEAST_EXPECT(beckyLines[jss::result][jss::error] == "invalidParams");
562 BEAST_EXPECT(beckyLines[jss::result][jss::error_code] == RpcInvalidParams);
563 BEAST_EXPECT(
564 beckyLines[jss::result][jss::error_message] ==
565 rpc::makeError(RpcInvalidParams)[jss::error_message]);
566 }
567
568 void
570 {
571 testcase("Entry pointed to by marker is removed");
572 using namespace test::jtx;
573 Env env(*this);
574
575 // The goal here is to observe account_lines marker behavior if the
576 // entry pointed at by a returned marker is removed from the ledger.
577 //
578 // It isn't easy to explicitly delete a trust line, so we do so in a
579 // round-about fashion. It takes 4 actors:
580 // o Gateway gw1 issues USD
581 // o alice offers to buy 100 USD for 100 XRP.
582 // o becky offers to sell 100 USD for 100 XRP.
583 // There will now be an inferred trustline between alice and gw1.
584 // o alice pays her 100 USD to cheri.
585 // alice should now have no USD and no trustline to gw1.
586 Account const alice{"alice"};
587 Account const becky{"becky"};
588 Account const cheri{"cheri"};
589 Account const gw1{"gw1"};
590 Account const gw2{"gw2"};
591 env.fund(XRP(10000), alice, becky, cheri, gw1, gw2);
592 env.close();
593
594 auto const usd = gw1["USD"];
595 auto const aud = gw1["AUD"];
596 auto const eur = gw2["EUR"];
597 env(trust(alice, usd(200)));
598 env(trust(alice, aud(200)));
599 env(trust(becky, eur(200)));
600 env(trust(cheri, eur(200)));
601 env.close();
602
603 // becky gets 100 USD from gw1.
604 env(pay(gw2, becky, eur(100)));
605 env.close();
606
607 // alice offers to buy 100 EUR for 100 XRP.
608 env(offer(alice, eur(100), XRP(100)));
609 env.close();
610
611 // becky offers to buy 100 XRP for 100 EUR.
612 env(offer(becky, XRP(100), eur(100)));
613 env.close();
614
615 // Get account_lines for alice. Limit at 1, so we get a marker.
616 json::Value linesBegParams;
617 linesBegParams[jss::account] = alice.human();
618 linesBegParams[jss::limit] = 2;
619 auto const linesBeg = env.rpc("json", "account_lines", to_string(linesBegParams));
620 BEAST_EXPECT(linesBeg[jss::result][jss::lines][0u][jss::currency] == "USD");
621 BEAST_EXPECT(linesBeg[jss::result].isMember(jss::marker));
622
623 // alice pays 100 EUR to cheri.
624 env(pay(alice, cheri, eur(100)));
625 env.close();
626
627 // Since alice paid all her EUR to cheri, alice should no longer
628 // have a trust line to gw1. So the old marker should now be invalid.
629 json::Value linesEndParams;
630 linesEndParams[jss::account] = alice.human();
631 linesEndParams[jss::marker] = linesBeg[jss::result][jss::marker];
632 auto const linesEnd = env.rpc("json", "account_lines", to_string(linesEndParams));
633 BEAST_EXPECT(linesEnd[jss::result][jss::error] == "invalidParams");
634 BEAST_EXPECT(linesEnd[jss::result][jss::error_code] == RpcInvalidParams);
635 BEAST_EXPECT(
636 linesEnd[jss::result][jss::error_message] ==
637 rpc::makeError(RpcInvalidParams)[jss::error_message]);
638 }
639
640 void
642 {
643 // Regression: pagination across account_lines / account_offers /
644 // account_channels must not reject a marker whose SLE is a
645 // Credential (or any post-2023 owner-directory entry).
646 testcase("Marker on new owner-directory entry types (Credential)");
647
648 using namespace test::jtx;
649
650 // Walk the owner directory via `rpcMethod` at limit=1 and return
651 // the total number of paged calls plus whether the RPC ever
652 // returned "invalidParams" during pagination.
653 auto const walkPages = [](Env& env, Account const& account, char const* rpcMethod) {
655 int iterations = 0;
656 bool hitInvalidParams = false;
657 for (int guard = 0; guard < 20; ++guard)
658 {
659 json::Value params;
660 params[jss::account] = account.human();
661 params[jss::limit] = 1;
662 if (marker)
663 params[jss::marker] = *marker;
664 auto const resp = env.rpc("json", rpcMethod, to_string(params))[jss::result];
665 ++iterations;
666 if (resp.isMember(jss::error))
667 {
668 hitInvalidParams = resp[jss::error].asString() == "invalidParams";
669 break;
670 }
671 if (!resp.isMember(jss::marker))
672 break;
673 marker = resp[jss::marker].asString();
674 }
675 return std::pair{iterations, hitInvalidParams};
676 };
677
678 for (char const* rpcMethod : {"account_lines", "account_offers", "account_channels"})
679 {
680 Env env(*this);
681
682 Account const alice{"alice"};
683 Account const issuer{"issuer"};
684 env.fund(XRP(10000), alice, issuer);
685 env.close();
686
687 auto const usd = issuer["USD"];
688 env(trust(alice, usd(200)));
689
690 for (int i = 0; i < 4; ++i)
691 {
692 env(credentials::create(alice, issuer, std::string("Cred") + std::to_string(i)));
693 }
694 env.close();
695
696 auto const [iterations, hitInvalidParams] = walkPages(env, alice, rpcMethod);
697 BEAST_EXPECTS(!hitInvalidParams, rpcMethod);
698 // 1 trust line + 4 credentials — pagination walks all owner-dir
699 // entries regardless of which the RPC includes in its results.
700 BEAST_EXPECTS(
701 iterations == 5, std::string(rpcMethod) + ": " + std::to_string(iterations));
702 }
703 }
704
705 void
707 {
708 testcase("Marker can point to any appropriate ledger entry type");
709 using namespace test::jtx;
710 using namespace std::chrono_literals;
711 Env env(*this);
712
713 // The goal of this test is observe account_lines RPC calls return an
714 // error message when the SLE pointed to by the marker is not owned by
715 // the Account being traversed.
716 //
717 // To start, we'll create an environment with some trust lines, offers
718 // and a signers list.
719 Account const alice{"alice"};
720 Account const becky{"becky"};
721 Account const gw1{"gw1"};
722 env.fund(XRP(10000), alice, becky, gw1);
723 env.close();
724
725 auto const payChan = [](Account const& account,
726 Account const& to,
727 STAmount const& amount,
728 NetClock::duration const& settleDelay,
729 PublicKey const& pk) {
730 json::Value jv;
731 jv[jss::TransactionType] = jss::PaymentChannelCreate;
732 jv[jss::Account] = account.human();
733 jv[jss::Destination] = to.human();
734 jv[jss::Amount] = amount.getJson(JsonOptions::Values::None);
735 jv["SettleDelay"] = settleDelay.count();
736 jv["PublicKey"] = strHex(pk.slice());
737 return jv;
738 };
739
740 // Test all available object types. Not all of these objects will be
741 // included in the search, nor found by `account_objects`. If that ever
742 // changes for any reason, this test will help catch that.
743 //
744 // SignerList, for alice
745 Account const bogie{"bogie"};
746 env(signers(alice, 2, {{bogie, 3}}));
747 env.close();
748
749 // SignerList, includes alice
750 env(signers(becky, 2, {{alice, 3}}));
751 env.close();
752
753 // Trust lines
754 auto const eur = gw1["EUR"];
755 env(trust(alice, eur(200)));
756 env(trust(becky, eur(200)));
757 env.close();
758
759 // Escrow, in each direction
760 env(escrow::create(alice, becky, XRP(1000)), escrow::kFinishTime(env.now() + 1s));
761 env(escrow::create(becky, alice, XRP(1000)), escrow::kFinishTime(env.now() + 1s));
762
763 // Pay channels, in each direction
764 env(payChan(alice, becky, XRP(1000), 100s, alice.pk()));
765 env(payChan(becky, alice, XRP(1000), 100s, becky.pk()));
766
767 // Mint NFTs, for each account
768 UInt256 const aliceNFtokenID = token::getNextID(env, alice, 0, tfTransferable);
769 env(token::mint(alice, 0), Txflags(tfTransferable));
770
771 UInt256 const beckyNFtokenID = token::getNextID(env, becky, 0, tfTransferable);
772 env(token::mint(becky, 0), Txflags(tfTransferable));
773
774 // NFT Offers, for each other's NFTs
775 env(token::createOffer(alice, beckyNFtokenID, drops(1)), token::Owner(becky));
776 env(token::createOffer(becky, aliceNFtokenID, drops(1)), token::Owner(alice));
777
778 env(token::createOffer(becky, beckyNFtokenID, drops(1)),
779 Txflags(tfSellNFToken),
780 token::Destination(alice));
781 env(token::createOffer(alice, aliceNFtokenID, drops(1)),
782 Txflags(tfSellNFToken),
783 token::Destination(becky));
784
785 env(token::createOffer(gw1, beckyNFtokenID, drops(1)),
786 token::Owner(becky),
787 token::Destination(alice));
788 env(token::createOffer(gw1, aliceNFtokenID, drops(1)),
789 token::Owner(alice),
790 token::Destination(becky));
791
792 env(token::createOffer(becky, beckyNFtokenID, drops(1)), Txflags(tfSellNFToken));
793 env(token::createOffer(alice, aliceNFtokenID, drops(1)), Txflags(tfSellNFToken));
794
795 // Checks, in each direction
796 env(check::create(alice, becky, XRP(50)));
797 env(check::create(becky, alice, XRP(50)));
798
799 // Deposit preauth, in each direction
800 env(deposit::auth(alice, becky));
801 env(deposit::auth(becky, alice));
802
803 // Offers, one where alice is the owner, and one where alice is the
804 // issuer
805 auto const usDalice = alice["USD"];
806 env(offer(alice, eur(10), XRP(100)));
807 env(offer(becky, usDalice(10), XRP(100)));
808
809 // Tickets
810 env(ticket::create(alice, 2));
811
812 // Add another trustline for good measure
813 auto const btcBecky = becky["BTC"];
814 env(trust(alice, btcBecky(200)));
815
816 env.close();
817
818 {
819 // Now make repeated calls to `account_lines` with a limit of 1.
820 // That should iterate all of alice's relevant objects, even though
821 // the list will be empty for most calls.
822 auto const getNextLine =
823 [](Env& env, Account const& alice, std::optional<std::string> const marker) {
825 params[jss::account] = alice.human();
826 params[jss::limit] = 1;
827 if (marker)
828 params[jss::marker] = *marker;
829
830 return env.rpc("json", "account_lines", to_string(params));
831 };
832
833 auto aliceLines = getNextLine(env, alice, std::nullopt);
834 static constexpr std::size_t kExpectedIterations = 16;
835 static constexpr std::size_t kExpectedLines = 2;
836 static constexpr std::size_t kExpectedNfTs = 1;
837 std::size_t foundLines = 0;
838
839 auto const hasMarker = [](auto const& aliceLines) {
840 return aliceLines[jss::result].isMember(jss::marker);
841 };
842 auto const marker = [](auto const& aliceLines) {
843 return aliceLines[jss::result][jss::marker].asString();
844 };
845 auto const checkLines = [](auto const& aliceLines) {
846 return aliceLines.isMember(jss::result) &&
847 !aliceLines[jss::result].isMember(jss::error_message) &&
848 aliceLines[jss::result].isMember(jss::lines) &&
849 aliceLines[jss::result][jss::lines].isArray() &&
850 aliceLines[jss::result][jss::lines].size() <= 1;
851 };
852
853 BEAST_EXPECT(hasMarker(aliceLines));
854 BEAST_EXPECT(checkLines(aliceLines));
855 BEAST_EXPECT(aliceLines[jss::result][jss::lines].size() == 0);
856
857 int iterations = 1;
858
859 while (hasMarker(aliceLines))
860 {
861 // Iterate through the markers
862 aliceLines = getNextLine(env, alice, marker(aliceLines));
863 BEAST_EXPECT(checkLines(aliceLines));
864 foundLines += aliceLines[jss::result][jss::lines].size();
865 ++iterations;
866 }
867 BEAST_EXPECT(kExpectedLines == foundLines);
868
869 json::Value aliceObjectsParams2;
870 aliceObjectsParams2[jss::account] = alice.human();
871 aliceObjectsParams2[jss::limit] = 200;
872 json::Value const aliceObjects =
873 env.rpc("json", "account_objects", to_string(aliceObjectsParams2));
874 BEAST_EXPECT(aliceObjects.isMember(jss::result));
875 BEAST_EXPECT(!aliceObjects[jss::result].isMember(jss::error_message));
876 BEAST_EXPECT(aliceObjects[jss::result].isMember(jss::account_objects));
877 BEAST_EXPECT(aliceObjects[jss::result][jss::account_objects].isArray());
878 // account_objects does not currently return NFTPages. If
879 // that ever changes, without also changing account_lines,
880 // this test will need to be updated.
881 BEAST_EXPECT(
882 aliceObjects[jss::result][jss::account_objects].size() ==
883 iterations + kExpectedNfTs);
884 // If ledger object association ever changes, for whatever
885 // reason, this test will need to be updated.
886 BEAST_EXPECTS(iterations == kExpectedIterations, std::to_string(iterations));
887
888 // Get becky's objects just to confirm that they're symmetrical
889 json::Value beckyObjectsParams;
890 beckyObjectsParams[jss::account] = becky.human();
891 beckyObjectsParams[jss::limit] = 200;
892 json::Value const beckyObjects =
893 env.rpc("json", "account_objects", to_string(beckyObjectsParams));
894 BEAST_EXPECT(beckyObjects.isMember(jss::result));
895 BEAST_EXPECT(!beckyObjects[jss::result].isMember(jss::error_message));
896 BEAST_EXPECT(beckyObjects[jss::result].isMember(jss::account_objects));
897 BEAST_EXPECT(beckyObjects[jss::result][jss::account_objects].isArray());
898 // becky should have the same number of objects as alice, except the
899 // 2 tickets that only alice created.
900 BEAST_EXPECT(
901 beckyObjects[jss::result][jss::account_objects].size() ==
902 aliceObjects[jss::result][jss::account_objects].size() - 2);
903 }
904 }
905
906 // test API V2
907 void
909 {
910 testcase("V2: account_lines");
911
912 using namespace test::jtx;
913 Env env(*this);
914 {
915 // account_lines with mal-formed json2 (missing id field).
916 json::Value request;
917 request[jss::method] = "account_lines";
918 setEnvelope2(request);
919 auto const lines = env.rpc("json2", to_string(request));
920 BEAST_EXPECT(hasEnvelope2(lines));
921 }
922 {
923 // account_lines with no account.
924 json::Value request;
925 request[jss::method] = "account_lines";
926 setEnvelope2(request);
927 request[jss::id] = 5;
928 auto const lines = env.rpc("json2", to_string(request));
929 BEAST_EXPECT(lines[jss::error][jss::error] == "invalidParams");
930 BEAST_EXPECT(lines[jss::error][jss::error_code] == RpcInvalidParams);
931 BEAST_EXPECT(
932 lines[jss::error][jss::message] ==
933 rpc::missingFieldError(jss::account)[jss::error_message]);
934 BEAST_EXPECT(hasEnvelope2(lines));
935 BEAST_EXPECT(lines.isMember(jss::id) && lines[jss::id] == 5);
936 }
937 {
938 // account_lines with a malformed account.
939 json::Value params;
940 params[jss::account] = "n9MJkEKHDhy5eTLuHUQeAAjo382frHNbFK4C8hcwN4nwM2SrLdBj";
941 json::Value request;
942 request[jss::method] = "account_lines";
943 setEnvelope2(request);
944 request[jss::id] = 5;
945 request[jss::params] = params;
946 auto const lines = env.rpc("json2", to_string(request));
947 BEAST_EXPECT(lines[jss::error][jss::error] == "actMalformed");
948 BEAST_EXPECT(lines[jss::error][jss::error_code] == RpcActMalformed);
949 BEAST_EXPECT(
950 lines[jss::error][jss::message] ==
951 rpc::makeError(RpcActMalformed)[jss::error_message]);
952 BEAST_EXPECT(hasEnvelope2(lines));
953 BEAST_EXPECT(lines.isMember(jss::id) && lines[jss::id] == 5);
954 }
955 Account const alice{"alice"};
956 {
957 // account_lines on an unfunded account.
958 json::Value params;
959 params[jss::account] = alice.human();
960 json::Value request;
961 request[jss::method] = "account_lines";
962 setEnvelope2(request);
963 request[jss::id] = 5;
964 request[jss::params] = params;
965 auto const lines = env.rpc("json2", to_string(request));
966 BEAST_EXPECT(lines[jss::error][jss::error] == "actNotFound");
967 BEAST_EXPECT(lines[jss::error][jss::error_code] == RpcActNotFound);
968 BEAST_EXPECT(
969 lines[jss::error][jss::message] ==
970 rpc::makeError(RpcActNotFound)[jss::error_message]);
971 BEAST_EXPECT(hasEnvelope2(lines));
972 BEAST_EXPECT(lines.isMember(jss::id) && lines[jss::id] == 5);
973 }
974 env.fund(XRP(10000), alice);
975 env.close();
976 LedgerHeader const ledger3Info = env.closed()->header();
977 BEAST_EXPECT(ledger3Info.seq == 3);
978
979 {
980 // test peer non-string
981 auto const testInvalidPeerParam = [&](auto const& param) {
982 json::Value params;
983 params[jss::account] = alice.human();
984 params[jss::peer] = param;
985
986 json::Value request;
987 request[jss::method] = "account_lines";
988 setEnvelope2(request);
989 request[jss::id] = 5;
990 request[jss::params] = params;
991
992 auto const lines = env.rpc("json2", to_string(request));
993 BEAST_EXPECT(lines[jss::error][jss::error] == "invalidParams");
994 BEAST_EXPECT(lines[jss::error][jss::error_code] == RpcInvalidParams);
995 BEAST_EXPECT(lines[jss::error][jss::message] == "Invalid field 'peer'.");
996 BEAST_EXPECT(hasEnvelope2(lines));
997 BEAST_EXPECT(lines.isMember(jss::id) && lines[jss::id] == 5);
998 };
999
1000 testInvalidPeerParam(1);
1001 testInvalidPeerParam(1.1);
1002 testInvalidPeerParam(true);
1003 testInvalidPeerParam(json::Value(json::ValueType::Null));
1004 testInvalidPeerParam(json::Value(json::ValueType::Object));
1005 testInvalidPeerParam(json::Value(json::ValueType::Array));
1006 }
1007 {
1008 // alice is funded but has no lines. An empty array is returned.
1009 json::Value params;
1010 params[jss::account] = alice.human();
1011 json::Value request;
1012 request[jss::method] = "account_lines";
1013 setEnvelope2(request);
1014 request[jss::id] = 5;
1015 request[jss::params] = params;
1016 auto const lines = env.rpc("json2", to_string(request));
1017 BEAST_EXPECT(lines[jss::result][jss::lines].isArray());
1018 BEAST_EXPECT(lines[jss::result][jss::lines].size() == 0);
1019 BEAST_EXPECT(hasEnvelope2(lines));
1020 BEAST_EXPECT(lines.isMember(jss::id) && lines[jss::id] == 5);
1021 }
1022 {
1023 // Specify a ledger that doesn't exist.
1024 json::Value params;
1025 params[jss::account] = alice.human();
1026 params[jss::ledger_index] = "nonsense";
1027 json::Value request;
1028 request[jss::method] = "account_lines";
1029 setEnvelope2(request);
1030 request[jss::id] = 5;
1031 request[jss::params] = params;
1032 auto const lines = env.rpc("json2", to_string(request));
1033 BEAST_EXPECT(lines[jss::error][jss::error] == "invalidParams");
1034 BEAST_EXPECT(lines[jss::error][jss::error_code] == RpcInvalidParams);
1035 BEAST_EXPECT(
1036 lines[jss::error][jss::message] ==
1037 "Invalid field 'ledger_index', not string or number.");
1038 BEAST_EXPECT(hasEnvelope2(lines));
1039 BEAST_EXPECT(lines.isMember(jss::id) && lines[jss::id] == 5);
1040 }
1041 {
1042 // Specify a different ledger that doesn't exist.
1043 json::Value params;
1044 params[jss::account] = alice.human();
1045 params[jss::ledger_index] = 50000;
1046 json::Value request;
1047 request[jss::method] = "account_lines";
1048 setEnvelope2(request);
1049 request[jss::id] = 5;
1050 request[jss::params] = params;
1051 auto const lines = env.rpc("json2", to_string(request));
1052 BEAST_EXPECT(lines[jss::error][jss::error] == "lgrNotFound");
1053 BEAST_EXPECT(lines[jss::error][jss::error_code] == RpcLgrNotFound);
1054 BEAST_EXPECT(lines[jss::error][jss::message] == "ledgerNotFound");
1055 BEAST_EXPECT(hasEnvelope2(lines));
1056 BEAST_EXPECT(lines.isMember(jss::id) && lines[jss::id] == 5);
1057 }
1058 // Create trust lines to share with alice.
1059 Account const gw1{"gw1"};
1060 env.fund(XRP(10000), gw1);
1061 std::vector<IOU> gw1Currencies;
1062
1063 for (char c = 0; c <= ('Z' - 'A'); ++c)
1064 {
1065 // gw1 currencies have names "YAA" -> "YAZ".
1066 gw1Currencies.push_back(gw1[std::string("YA") + static_cast<char>('A' + c)]);
1067 IOU const& gw1Currency = gw1Currencies.back();
1068
1069 // Establish trust lines.
1070 env(trust(alice, gw1Currency(100 + c)));
1071 env(pay(gw1, alice, gw1Currency(50 + c)));
1072 }
1073 env.close();
1074 LedgerHeader const ledger4Info = env.closed()->header();
1075 BEAST_EXPECT(ledger4Info.seq == 4);
1076
1077 // Add another set of trust lines in another ledger so we can see
1078 // differences in historic ledgers.
1079 Account const gw2{"gw2"};
1080 env.fund(XRP(10000), gw2);
1081
1082 // gw2 requires authorization.
1083 env(fset(gw2, asfRequireAuth));
1084 env.close();
1085 std::vector<IOU> gw2Currencies;
1086
1087 for (char c = 0; c <= ('Z' - 'A'); ++c)
1088 {
1089 // gw2 currencies have names "ZAA" -> "ZAZ".
1090 gw2Currencies.push_back(gw2[std::string("ZA") + static_cast<char>('A' + c)]);
1091 IOU const& gw2Currency = gw2Currencies.back();
1092
1093 // Establish trust lines.
1094 env(trust(alice, gw2Currency(200 + c)));
1095 env(trust(gw2, gw2Currency(0), alice, tfSetfAuth));
1096 env.close();
1097 env(pay(gw2, alice, gw2Currency(100 + c)));
1098 env.close();
1099
1100 // Set flags on gw2 trust lines so we can look for them.
1101 env(trust(alice, gw2Currency(0), gw2, tfSetNoRipple | tfSetFreeze | tfSetDeepFreeze));
1102 }
1103 env.close();
1104 LedgerHeader const ledger58Info = env.closed()->header();
1105 BEAST_EXPECT(ledger58Info.seq == 58);
1106
1107 // A re-usable test for historic ledgers.
1108 auto const testAccountLinesHistory =
1109 [this, &env](Account const& account, LedgerHeader const& info, int count) {
1110 // Get account_lines by ledger index.
1111 json::Value paramsSeq;
1112 paramsSeq[jss::account] = account.human();
1113 paramsSeq[jss::ledger_index] = info.seq;
1114 json::Value requestSeq;
1115 requestSeq[jss::method] = "account_lines";
1116 setEnvelope2(requestSeq);
1117 requestSeq[jss::id] = 5;
1118 requestSeq[jss::params] = paramsSeq;
1119 auto const linesSeq = env.rpc("json2", to_string(requestSeq));
1120 BEAST_EXPECT(linesSeq[jss::result][jss::lines].isArray());
1121 BEAST_EXPECT(linesSeq[jss::result][jss::lines].size() == count);
1122 BEAST_EXPECT(hasEnvelope2(linesSeq));
1123 BEAST_EXPECT(linesSeq.isMember(jss::id) && linesSeq[jss::id] == 5);
1124
1125 // Get account_lines by ledger hash.
1126 json::Value paramsHash;
1127 paramsHash[jss::account] = account.human();
1128 paramsHash[jss::ledger_hash] = to_string(info.hash);
1129 json::Value requestHash;
1130 requestHash[jss::method] = "account_lines";
1131 setEnvelope2(requestHash);
1132 requestHash[jss::id] = 5;
1133 requestHash[jss::params] = paramsHash;
1134 auto const linesHash = env.rpc("json2", to_string(requestHash));
1135 BEAST_EXPECT(linesHash[jss::result][jss::lines].isArray());
1136 BEAST_EXPECT(linesHash[jss::result][jss::lines].size() == count);
1137 BEAST_EXPECT(hasEnvelope2(linesHash));
1138 BEAST_EXPECT(linesHash.isMember(jss::id) && linesHash[jss::id] == 5);
1139 };
1140
1141 // Alice should have no trust lines in ledger 3.
1142 testAccountLinesHistory(alice, ledger3Info, 0);
1143
1144 // Alice should have 26 trust lines in ledger 4.
1145 testAccountLinesHistory(alice, ledger4Info, 26);
1146
1147 // Alice should have 52 trust lines in ledger 58.
1148 testAccountLinesHistory(alice, ledger58Info, 52);
1149
1150 {
1151 // Surprisingly, it's valid to specify both index and hash, in
1152 // which case the hash wins.
1153 json::Value params;
1154 params[jss::account] = alice.human();
1155 params[jss::ledger_hash] = to_string(ledger4Info.hash);
1156 params[jss::ledger_index] = ledger58Info.seq;
1157 json::Value request;
1158 request[jss::method] = "account_lines";
1159 setEnvelope2(request);
1160 request[jss::id] = 5;
1161 request[jss::params] = params;
1162 auto const lines = env.rpc("json2", to_string(request));
1163 BEAST_EXPECT(lines[jss::error][jss::error] == "invalidParams");
1164 BEAST_EXPECT(lines[jss::error][jss::error_code] == RpcInvalidParams);
1165 BEAST_EXPECT(
1166 lines[jss::error][jss::message] ==
1167 "Exactly one of 'ledger_hash' or 'ledger_index' can be "
1168 "specified.");
1169 BEAST_EXPECT(hasEnvelope2(lines));
1170 BEAST_EXPECT(lines.isMember(jss::id) && lines[jss::id] == 5);
1171 }
1172 {
1173 // alice should have 52 trust lines in the current ledger.
1174 json::Value params;
1175 params[jss::account] = alice.human();
1176 json::Value request;
1177 request[jss::method] = "account_lines";
1178 setEnvelope2(request);
1179 request[jss::id] = 5;
1180 request[jss::params] = params;
1181 auto const lines = env.rpc("json2", to_string(request));
1182 BEAST_EXPECT(lines[jss::result][jss::lines].isArray());
1183 BEAST_EXPECT(lines[jss::result][jss::lines].size() == 52);
1184 BEAST_EXPECT(hasEnvelope2(lines));
1185 BEAST_EXPECT(lines.isMember(jss::id) && lines[jss::id] == 5);
1186 }
1187 {
1188 // alice should have 26 trust lines with gw1.
1189 json::Value params;
1190 params[jss::account] = alice.human();
1191 params[jss::peer] = gw1.human();
1192 json::Value request;
1193 request[jss::method] = "account_lines";
1194 setEnvelope2(request);
1195 request[jss::id] = 5;
1196 request[jss::params] = params;
1197 auto const lines = env.rpc("json2", to_string(request));
1198 BEAST_EXPECT(lines[jss::result][jss::lines].isArray());
1199 BEAST_EXPECT(lines[jss::result][jss::lines].size() == 26);
1200 BEAST_EXPECT(hasEnvelope2(lines));
1201 BEAST_EXPECT(lines.isMember(jss::id) && lines[jss::id] == 5);
1202 }
1203 {
1204 // Use a malformed peer.
1205 json::Value params;
1206 params[jss::account] = alice.human();
1207 params[jss::peer] = "n9MJkEKHDhy5eTLuHUQeAAjo382frHNbFK4C8hcwN4nwM2SrLdBj";
1208 json::Value request;
1209 request[jss::method] = "account_lines";
1210 setEnvelope2(request);
1211 request[jss::id] = 5;
1212 request[jss::params] = params;
1213 auto const lines = env.rpc("json2", to_string(request));
1214 BEAST_EXPECT(lines[jss::error][jss::error] == "actMalformed");
1215 BEAST_EXPECT(lines[jss::error][jss::error_code] == RpcActMalformed);
1216 BEAST_EXPECT(
1217 lines[jss::error][jss::message] ==
1218 rpc::makeError(RpcActMalformed)[jss::error_message]);
1219 BEAST_EXPECT(hasEnvelope2(lines));
1220 BEAST_EXPECT(lines.isMember(jss::id) && lines[jss::id] == 5);
1221 }
1222 {
1223 // A negative limit should fail.
1224 json::Value params;
1225 params[jss::account] = alice.human();
1226 params[jss::limit] = -1;
1227 json::Value request;
1228 request[jss::method] = "account_lines";
1229 setEnvelope2(request);
1230 request[jss::id] = 5;
1231 request[jss::params] = params;
1232 auto const lines = env.rpc("json2", to_string(request));
1233 BEAST_EXPECT(lines[jss::error][jss::error] == "invalidParams");
1234 BEAST_EXPECT(lines[jss::error][jss::error_code] == RpcInvalidParams);
1235 BEAST_EXPECT(
1236 lines[jss::error][jss::message] ==
1237 rpc::expectedFieldMessage(jss::limit, "unsigned integer"));
1238 BEAST_EXPECT(hasEnvelope2(lines));
1239 BEAST_EXPECT(lines.isMember(jss::id) && lines[jss::id] == 5);
1240 }
1241 {
1242 // Limit the response to 1 trust line.
1243 json::Value paramsA;
1244 paramsA[jss::account] = alice.human();
1245 paramsA[jss::limit] = 1;
1246 json::Value requestA;
1247 requestA[jss::method] = "account_lines";
1248 setEnvelope2(requestA);
1249 requestA[jss::id] = 5;
1250 requestA[jss::params] = paramsA;
1251 auto const linesA = env.rpc("json2", to_string(requestA));
1252 BEAST_EXPECT(linesA[jss::result][jss::lines].isArray());
1253 BEAST_EXPECT(linesA[jss::result][jss::lines].size() == 1);
1254 BEAST_EXPECT(hasEnvelope2(linesA));
1255 BEAST_EXPECT(linesA.isMember(jss::id) && linesA[jss::id] == 5);
1256
1257 // Pick up from where the marker left off. We should get 51.
1258 auto marker = linesA[jss::result][jss::marker].asString();
1259 json::Value paramsB;
1260 paramsB[jss::account] = alice.human();
1261 paramsB[jss::marker] = marker;
1262 json::Value requestB;
1263 requestB[jss::method] = "account_lines";
1264 setEnvelope2(requestB);
1265 requestB[jss::id] = 5;
1266 requestB[jss::params] = paramsB;
1267 auto const linesB = env.rpc("json2", to_string(requestB));
1268 BEAST_EXPECT(linesB[jss::result][jss::lines].isArray());
1269 BEAST_EXPECT(linesB[jss::result][jss::lines].size() == 51);
1270 BEAST_EXPECT(hasEnvelope2(linesB));
1271 BEAST_EXPECT(linesB.isMember(jss::id) && linesB[jss::id] == 5);
1272
1273 // Go again from where the marker left off, but set a limit of 3.
1274 json::Value paramsC;
1275 paramsC[jss::account] = alice.human();
1276 paramsC[jss::limit] = 3;
1277 paramsC[jss::marker] = marker;
1278 json::Value requestC;
1279 requestC[jss::method] = "account_lines";
1280 setEnvelope2(requestC);
1281 requestC[jss::id] = 5;
1282 requestC[jss::params] = paramsC;
1283 auto const linesC = env.rpc("json2", to_string(requestC));
1284 BEAST_EXPECT(linesC[jss::result][jss::lines].isArray());
1285 BEAST_EXPECT(linesC[jss::result][jss::lines].size() == 3);
1286 BEAST_EXPECT(hasEnvelope2(linesC));
1287 BEAST_EXPECT(linesC.isMember(jss::id) && linesC[jss::id] == 5);
1288
1289 // Mess with the marker so it becomes bad and check for the error.
1290 marker[5] = marker[5] == '7' ? '8' : '7';
1291 json::Value paramsD;
1292 paramsD[jss::account] = alice.human();
1293 paramsD[jss::marker] = marker;
1294 json::Value requestD;
1295 requestD[jss::method] = "account_lines";
1296 setEnvelope2(requestD);
1297 requestD[jss::id] = 5;
1298 requestD[jss::params] = paramsD;
1299 auto const linesD = env.rpc("json2", to_string(requestD));
1300 BEAST_EXPECT(linesD[jss::error][jss::error] == "invalidParams");
1301 BEAST_EXPECT(linesD[jss::error][jss::error_code] == RpcInvalidParams);
1302 BEAST_EXPECT(
1303 linesD[jss::error][jss::message] ==
1304 rpc::makeError(RpcInvalidParams)[jss::error_message]);
1305 BEAST_EXPECT(hasEnvelope2(linesD));
1306 BEAST_EXPECT(linesD.isMember(jss::id) && linesD[jss::id] == 5);
1307 }
1308 {
1309 // A non-string marker should also fail.
1310 json::Value params;
1311 params[jss::account] = alice.human();
1312 params[jss::marker] = true;
1313 json::Value request;
1314 request[jss::method] = "account_lines";
1315 setEnvelope2(request);
1316 request[jss::id] = 5;
1317 request[jss::params] = params;
1318 auto const lines = env.rpc("json2", to_string(request));
1319 BEAST_EXPECT(lines[jss::error][jss::error] == "invalidParams");
1320 BEAST_EXPECT(lines[jss::error][jss::error_code] == RpcInvalidParams);
1321 BEAST_EXPECT(
1322 lines[jss::error][jss::message] ==
1323 rpc::expectedFieldMessage(jss::marker, "string"));
1324 BEAST_EXPECT(hasEnvelope2(lines));
1325 BEAST_EXPECT(lines.isMember(jss::id) && lines[jss::id] == 5);
1326 }
1327 {
1328 // Check that the flags we expect from alice to gw2 are present.
1329 json::Value params;
1330 params[jss::account] = alice.human();
1331 params[jss::limit] = 10;
1332 params[jss::peer] = gw2.human();
1333 json::Value request;
1334 request[jss::method] = "account_lines";
1335 setEnvelope2(request);
1336 request[jss::id] = 5;
1337 request[jss::params] = params;
1338 auto const lines = env.rpc("json2", to_string(request));
1339 auto const& line = lines[jss::result][jss::lines][0u];
1340 BEAST_EXPECT(line[jss::freeze].asBool() == true);
1341 BEAST_EXPECT(line[jss::deep_freeze].asBool() == true);
1342 BEAST_EXPECT(line[jss::no_ripple].asBool() == true);
1343 BEAST_EXPECT(line[jss::peer_authorized].asBool() == true);
1344 BEAST_EXPECT(hasEnvelope2(lines));
1345 BEAST_EXPECT(lines.isMember(jss::id) && lines[jss::id] == 5);
1346 }
1347 {
1348 // Check that the flags we expect from gw2 to alice are present.
1349 json::Value paramsA;
1350 paramsA[jss::account] = gw2.human();
1351 paramsA[jss::limit] = 1;
1352 paramsA[jss::peer] = alice.human();
1353 json::Value requestA;
1354 requestA[jss::method] = "account_lines";
1355 setEnvelope2(requestA);
1356 requestA[jss::id] = 5;
1357 requestA[jss::params] = paramsA;
1358 auto const linesA = env.rpc("json2", to_string(requestA));
1359 auto const& lineA = linesA[jss::result][jss::lines][0u];
1360 BEAST_EXPECT(lineA[jss::freeze_peer].asBool() == true);
1361 BEAST_EXPECT(lineA[jss::deep_freeze_peer].asBool() == true);
1362 BEAST_EXPECT(lineA[jss::no_ripple_peer].asBool() == true);
1363 BEAST_EXPECT(lineA[jss::authorized].asBool() == true);
1364 BEAST_EXPECT(hasEnvelope2(linesA));
1365 BEAST_EXPECT(linesA.isMember(jss::id) && linesA[jss::id] == 5);
1366
1367 // Continue from the returned marker to make sure that works.
1368 BEAST_EXPECT(linesA[jss::result].isMember(jss::marker));
1369 auto const marker = linesA[jss::result][jss::marker].asString();
1370 json::Value paramsB;
1371 paramsB[jss::account] = gw2.human();
1372 paramsB[jss::limit] = 25;
1373 paramsB[jss::marker] = marker;
1374 paramsB[jss::peer] = alice.human();
1375 json::Value requestB;
1376 requestB[jss::method] = "account_lines";
1377 setEnvelope2(requestB);
1378 requestB[jss::id] = 5;
1379 requestB[jss::params] = paramsB;
1380 auto const linesB = env.rpc("json2", to_string(requestB));
1381 BEAST_EXPECT(linesB[jss::result][jss::lines].isArray());
1382 BEAST_EXPECT(linesB[jss::result][jss::lines].size() == 25);
1383 BEAST_EXPECT(!linesB[jss::result].isMember(jss::marker));
1384 BEAST_EXPECT(hasEnvelope2(linesB));
1385 BEAST_EXPECT(linesB.isMember(jss::id) && linesB[jss::id] == 5);
1386 }
1387 }
1388
1389 // test API V2
1390 void
1392 {
1393 testcase("V2: account_lines with removed marker");
1394
1395 using namespace test::jtx;
1396 Env env(*this);
1397
1398 // The goal here is to observe account_lines marker behavior if the
1399 // entry pointed at by a returned marker is removed from the ledger.
1400 //
1401 // It isn't easy to explicitly delete a trust line, so we do so in a
1402 // round-about fashion. It takes 4 actors:
1403 // o Gateway gw1 issues EUR
1404 // o alice offers to buy 100 EUR for 100 XRP.
1405 // o becky offers to sell 100 EUR for 100 XRP.
1406 // There will now be an inferred trustline between alice and gw2.
1407 // o alice pays her 100 EUR to cheri.
1408 // alice should now have no EUR and no trustline to gw2.
1409 Account const alice{"alice"};
1410 Account const becky{"becky"};
1411 Account const cheri{"cheri"};
1412 Account const gw1{"gw1"};
1413 Account const gw2{"gw2"};
1414 env.fund(XRP(10000), alice, becky, cheri, gw1, gw2);
1415 env.close();
1416
1417 auto const usd = gw1["USD"];
1418 auto const aud = gw1["AUD"];
1419 auto const eur = gw2["EUR"];
1420 env(trust(alice, usd(200)));
1421 env(trust(alice, aud(200)));
1422 env(trust(becky, eur(200)));
1423 env(trust(cheri, eur(200)));
1424 env.close();
1425
1426 // becky gets 100 EUR from gw1.
1427 env(pay(gw2, becky, eur(100)));
1428 env.close();
1429
1430 // alice offers to buy 100 EUR for 100 XRP.
1431 env(offer(alice, eur(100), XRP(100)));
1432 env.close();
1433
1434 // becky offers to buy 100 XRP for 100 EUR.
1435 env(offer(becky, XRP(100), eur(100)));
1436 env.close();
1437
1438 // Get account_lines for alice. Limit at 1, so we get a marker.
1439 json::Value linesBegParams;
1440 linesBegParams[jss::account] = alice.human();
1441 linesBegParams[jss::limit] = 2;
1442 json::Value linesBegRequest;
1443 linesBegRequest[jss::method] = "account_lines";
1444 setEnvelope2(linesBegRequest);
1445 linesBegRequest[jss::id] = 5;
1446 linesBegRequest[jss::params] = linesBegParams;
1447 auto const linesBeg = env.rpc("json2", to_string(linesBegRequest));
1448 BEAST_EXPECT(linesBeg[jss::result][jss::lines][0u][jss::currency] == "USD");
1449 BEAST_EXPECT(linesBeg[jss::result].isMember(jss::marker));
1450 BEAST_EXPECT(hasEnvelope2(linesBeg));
1451 BEAST_EXPECT(linesBeg.isMember(jss::id) && linesBeg[jss::id] == 5);
1452
1453 // alice pays 100 USD to cheri.
1454 env(pay(alice, cheri, eur(100)));
1455 env.close();
1456
1457 // Since alice paid all her EUR to cheri, alice should no longer
1458 // have a trust line to gw1. So the old marker should now be invalid.
1459 json::Value linesEndParams;
1460 linesEndParams[jss::account] = alice.human();
1461 linesEndParams[jss::marker] = linesBeg[jss::result][jss::marker];
1462 json::Value linesEndRequest;
1463 linesEndRequest[jss::method] = "account_lines";
1464 setEnvelope2(linesEndRequest);
1465 linesEndRequest[jss::id] = 5;
1466 linesEndRequest[jss::params] = linesEndParams;
1467 auto const linesEnd = env.rpc("json2", to_string(linesEndRequest));
1468 BEAST_EXPECT(linesEnd[jss::error][jss::error] == "invalidParams");
1469 BEAST_EXPECT(linesEnd[jss::error][jss::error_code] == RpcInvalidParams);
1470 BEAST_EXPECT(
1471 linesEnd[jss::error][jss::message] ==
1472 rpc::makeError(RpcInvalidParams)[jss::error_message]);
1473 BEAST_EXPECT(hasEnvelope2(linesEnd));
1474 BEAST_EXPECT(linesEnd.isMember(jss::id) && linesEnd[jss::id] == 5);
1475 }
1476
1477 void
1488};
1489
1491
1492} // namespace xrpl::rpc
T back(T... args)
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
Value removeMember(char const *key)
Remove and return the named member.
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.
std::chrono::duration< rep, period > duration
Definition chrono.h:47
A public key.
Definition PublicKey.h:53
void run() override
Runs the suite.
T find(T... args)
@ Array
array value (ordered list)
Definition json_value.h:32
@ Object
object value (collection of name/value pairs).
Definition json_value.h:33
@ Null
'null' value
Definition json_value.h:26
The api_version numbers this server serves.
Definition ApiVersion.h:26
std::string expectedFieldMessage(std::string const &name, std::string const &type)
Definition ErrorCodes.h:297
BEAST_DEFINE_TESTSUITE(AccountLines, rpc, xrpl)
json::Value missingFieldError(std::string const &name)
Definition ErrorCodes.h:243
json::Value makeError(ErrorCodeI code)
Returns a new json object that reflects the error code.
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
@ RpcLgrNotFound
Definition ErrorCodes.h:55
@ RpcActNotFound
Definition ErrorCodes.h:53
@ RpcActMalformed
Definition ErrorCodes.h:73
@ RpcInvalidParams
Definition ErrorCodes.h:67
std::string strHex(FwdIt begin, FwdIt end)
Definition strHex.h:13
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
BaseUInt< 256 > UInt256
Definition base_uint.h:581
T push_back(T... args)
Information about the notional ledger backing the view.
T substr(T... args)
T to_string(T... args)