xrpld
Loading...
Searching...
No Matches
Book_test.cpp
1#include <test/jtx/Env.h>
2#include <test/jtx/TestHelpers.h>
3#include <test/jtx/WSClient.h>
4#include <test/jtx/amount.h>
5#include <test/jtx/domain.h>
6#include <test/jtx/envconfig.h>
7#include <test/jtx/offer.h>
8#include <test/jtx/owners.h>
9#include <test/jtx/pay.h>
10#include <test/jtx/permissioned_dex.h>
11#include <test/jtx/rate.h>
12#include <test/jtx/require.h>
13#include <test/jtx/trust.h>
14#include <test/jtx/txflags.h>
15
16#include <xrpld/rpc/detail/Tuning.h>
17
18#include <xrpl/basics/base_uint.h>
19#include <xrpl/beast/unit_test/suite.h>
20#include <xrpl/json/json_value.h>
21#include <xrpl/json/to_string.h>
22#include <xrpl/ledger/helpers/DirectoryHelpers.h>
23#include <xrpl/protocol/AccountID.h>
24#include <xrpl/protocol/ErrorCodes.h>
25#include <xrpl/protocol/Feature.h>
26#include <xrpl/protocol/Indexes.h>
27#include <xrpl/protocol/Issue.h>
28#include <xrpl/protocol/LedgerFormats.h>
29#include <xrpl/protocol/SField.h>
30#include <xrpl/protocol/STAmount.h>
31#include <xrpl/protocol/TxFlags.h>
32#include <xrpl/protocol/XRPAmount.h>
33#include <xrpl/protocol/jss.h>
34
35#include <chrono>
36#include <cstdint>
37#include <memory>
38#include <optional>
39#include <string>
40
41namespace xrpl::test {
42
44{
45 static std::string
47 jtx::Env& env,
48 Issue const& in,
49 Issue const& out,
50 std::optional<UInt256> const& domain = std::nullopt)
51 {
52 std::string dir;
53 auto const uBookBase = getBookBase({in, out, domain});
54 auto uBookEnd = getQualityNext(uBookBase);
55 auto const view = env.closed();
56 auto key = view->succ(uBookBase, uBookEnd);
57 if (key)
58 {
59 auto sleOfferDir = view->read(keylet::page(key.value()));
60 UInt256 offerIndex;
61 unsigned int bookEntry = 0;
62 cdirFirst(*view, sleOfferDir->key(), sleOfferDir, bookEntry, offerIndex);
63 auto const sleOffer = view->read(keylet::offer(offerIndex));
64 dir = to_string(sleOffer->getFieldH256(sfBookDirectory));
65 }
66 return dir;
67 }
68
69public:
70 void
72 {
73 testcase("One Side Empty Book");
74 using namespace std::chrono_literals;
75 using namespace jtx;
76 Env env(*this);
77 env.fund(XRP(10000), "alice");
78 auto usd = Account("alice")["USD"];
79 auto wsc = makeWSClient(env.app().config());
80 json::Value books;
81
82 {
83 // RPC subscribe to books stream
84 books[jss::books] = json::ValueType::Array;
85 {
86 auto& j = books[jss::books].append(json::ValueType::Object);
87 j[jss::snapshot] = true;
88 j[jss::taker_gets][jss::currency] = "XRP";
89 j[jss::taker_pays][jss::currency] = "USD";
90 j[jss::taker_pays][jss::issuer] = Account("alice").human();
91 }
92
93 auto jv = wsc->invoke("subscribe", books);
94 if (wsc->version() == 2)
95 {
96 BEAST_EXPECT(hasEnvelope2(jv));
97 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
98 }
99 if (!BEAST_EXPECT(jv[jss::status] == "success"))
100 return;
101 BEAST_EXPECT(
102 jv[jss::result].isMember(jss::offers) && jv[jss::result][jss::offers].size() == 0);
103 BEAST_EXPECT(!jv[jss::result].isMember(jss::asks));
104 BEAST_EXPECT(!jv[jss::result].isMember(jss::bids));
105 }
106
107 {
108 // Create an ask: TakerPays 700, TakerGets 100/USD
109 env(offer("alice", XRP(700), usd(100)), Require(Owners("alice", 1)));
110 env.close();
111
112 // Check stream update
113 BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
114 auto const& t = jv[jss::transaction];
115 return t[jss::TransactionType] == jss::OfferCreate &&
116 t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::Values::None) &&
117 t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::Values::None);
118 }));
119 }
120
121 {
122 // Create a bid: TakerPays 100/USD, TakerGets 75
123 env(offer("alice", usd(100), XRP(75)), Require(Owners("alice", 2)));
124 env.close();
125 BEAST_EXPECT(!wsc->getMsg(10ms));
126 }
127
128 // RPC unsubscribe
129 auto jv = wsc->invoke("unsubscribe", books);
130 BEAST_EXPECT(jv[jss::status] == "success");
131 if (wsc->version() == 2)
132 {
133 BEAST_EXPECT(hasEnvelope2(jv));
134 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
135 }
136 }
137
138 void
140 {
141 testcase("One Side Offers In Book");
142 using namespace std::chrono_literals;
143 using namespace jtx;
144 Env env(*this);
145 env.fund(XRP(10000), "alice");
146 auto usd = Account("alice")["USD"];
147 auto wsc = makeWSClient(env.app().config());
148 json::Value books;
149
150 // Create an ask: TakerPays 500, TakerGets 100/USD
151 env(offer("alice", XRP(500), usd(100)), Require(Owners("alice", 1)));
152
153 // Create a bid: TakerPays 100/USD, TakerGets 200
154 env(offer("alice", usd(100), XRP(200)), Require(Owners("alice", 2)));
155 env.close();
156
157 {
158 // RPC subscribe to books stream
159 books[jss::books] = json::ValueType::Array;
160 {
161 auto& j = books[jss::books].append(json::ValueType::Object);
162 j[jss::snapshot] = true;
163 j[jss::taker_gets][jss::currency] = "XRP";
164 j[jss::taker_pays][jss::currency] = "USD";
165 j[jss::taker_pays][jss::issuer] = Account("alice").human();
166 }
167
168 auto jv = wsc->invoke("subscribe", books);
169 if (wsc->version() == 2)
170 {
171 BEAST_EXPECT(hasEnvelope2(jv));
172 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
173 }
174 if (!BEAST_EXPECT(jv[jss::status] == "success"))
175 return;
176 BEAST_EXPECT(
177 jv[jss::result].isMember(jss::offers) && jv[jss::result][jss::offers].size() == 1);
178 BEAST_EXPECT(
179 jv[jss::result][jss::offers][0u][jss::TakerGets] ==
181 BEAST_EXPECT(
182 jv[jss::result][jss::offers][0u][jss::TakerPays] ==
183 usd(100).value().getJson(JsonOptions::Values::None));
184 BEAST_EXPECT(!jv[jss::result].isMember(jss::asks));
185 BEAST_EXPECT(!jv[jss::result].isMember(jss::bids));
186 }
187
188 {
189 // Create an ask: TakerPays 700, TakerGets 100/USD
190 env(offer("alice", XRP(700), usd(100)), Require(Owners("alice", 3)));
191 env.close();
192
193 // Check stream update
194 BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
195 auto const& t = jv[jss::transaction];
196 return t[jss::TransactionType] == jss::OfferCreate &&
197 t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::Values::None) &&
198 t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::Values::None);
199 }));
200 }
201
202 {
203 // Create a bid: TakerPays 100/USD, TakerGets 75
204 env(offer("alice", usd(100), XRP(75)), Require(Owners("alice", 4)));
205 env.close();
206 BEAST_EXPECT(!wsc->getMsg(10ms));
207 }
208
209 // RPC unsubscribe
210 auto jv = wsc->invoke("unsubscribe", books);
211 BEAST_EXPECT(jv[jss::status] == "success");
212 if (wsc->version() == 2)
213 {
214 BEAST_EXPECT(hasEnvelope2(jv));
215 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
216 }
217 }
218
219 void
221 {
222 testcase("Both Sides Empty Book");
223 using namespace std::chrono_literals;
224 using namespace jtx;
225 Env env(*this);
226 env.fund(XRP(10000), "alice");
227 auto usd = Account("alice")["USD"];
228 auto wsc = makeWSClient(env.app().config());
229 json::Value books;
230
231 {
232 // RPC subscribe to books stream
233 books[jss::books] = json::ValueType::Array;
234 {
235 auto& j = books[jss::books].append(json::ValueType::Object);
236 j[jss::snapshot] = true;
237 j[jss::both] = true;
238 j[jss::taker_gets][jss::currency] = "XRP";
239 j[jss::taker_pays][jss::currency] = "USD";
240 j[jss::taker_pays][jss::issuer] = Account("alice").human();
241 }
242
243 auto jv = wsc->invoke("subscribe", books);
244 if (wsc->version() == 2)
245 {
246 BEAST_EXPECT(hasEnvelope2(jv));
247 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
248 }
249 if (!BEAST_EXPECT(jv[jss::status] == "success"))
250 return;
251 BEAST_EXPECT(
252 jv[jss::result].isMember(jss::asks) && jv[jss::result][jss::asks].size() == 0);
253 BEAST_EXPECT(
254 jv[jss::result].isMember(jss::bids) && jv[jss::result][jss::bids].size() == 0);
255 BEAST_EXPECT(!jv[jss::result].isMember(jss::offers));
256 }
257
258 {
259 // Create an ask: TakerPays 700, TakerGets 100/USD
260 env(offer("alice", XRP(700), usd(100)), Require(Owners("alice", 1)));
261 env.close();
262
263 // Check stream update
264 BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
265 auto const& t = jv[jss::transaction];
266 return t[jss::TransactionType] == jss::OfferCreate &&
267 t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::Values::None) &&
268 t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::Values::None);
269 }));
270 }
271
272 {
273 // Create a bid: TakerPays 100/USD, TakerGets 75
274 env(offer("alice", usd(100), XRP(75)), Require(Owners("alice", 2)));
275 env.close();
276
277 // Check stream update
278 BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
279 auto const& t = jv[jss::transaction];
280 return t[jss::TransactionType] == jss::OfferCreate &&
281 t[jss::TakerGets] == XRP(75).value().getJson(JsonOptions::Values::None) &&
282 t[jss::TakerPays] == usd(100).value().getJson(JsonOptions::Values::None);
283 }));
284 }
285
286 // RPC unsubscribe
287 auto jv = wsc->invoke("unsubscribe", books);
288 BEAST_EXPECT(jv[jss::status] == "success");
289 if (wsc->version() == 2)
290 {
291 BEAST_EXPECT(hasEnvelope2(jv));
292 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
293 }
294 }
295
296 void
298 {
299 testcase("Both Sides Offers In Book");
300 using namespace std::chrono_literals;
301 using namespace jtx;
302 Env env(*this);
303 env.fund(XRP(10000), "alice");
304 auto usd = Account("alice")["USD"];
305 auto wsc = makeWSClient(env.app().config());
306 json::Value books;
307
308 // Create an ask: TakerPays 500, TakerGets 100/USD
309 env(offer("alice", XRP(500), usd(100)), Require(Owners("alice", 1)));
310
311 // Create a bid: TakerPays 100/USD, TakerGets 200
312 env(offer("alice", usd(100), XRP(200)), Require(Owners("alice", 2)));
313 env.close();
314
315 {
316 // RPC subscribe to books stream
317 books[jss::books] = json::ValueType::Array;
318 {
319 auto& j = books[jss::books].append(json::ValueType::Object);
320 j[jss::snapshot] = true;
321 j[jss::both] = true;
322 j[jss::taker_gets][jss::currency] = "XRP";
323 j[jss::taker_pays][jss::currency] = "USD";
324 j[jss::taker_pays][jss::issuer] = Account("alice").human();
325 }
326
327 auto jv = wsc->invoke("subscribe", books);
328 if (wsc->version() == 2)
329 {
330 BEAST_EXPECT(hasEnvelope2(jv));
331 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
332 }
333 if (!BEAST_EXPECT(jv[jss::status] == "success"))
334 return;
335 BEAST_EXPECT(
336 jv[jss::result].isMember(jss::asks) && jv[jss::result][jss::asks].size() == 1);
337 BEAST_EXPECT(
338 jv[jss::result].isMember(jss::bids) && jv[jss::result][jss::bids].size() == 1);
339 BEAST_EXPECT(
340 jv[jss::result][jss::asks][0u][jss::TakerGets] ==
341 usd(100).value().getJson(JsonOptions::Values::None));
342 BEAST_EXPECT(
343 jv[jss::result][jss::asks][0u][jss::TakerPays] ==
345 BEAST_EXPECT(
346 jv[jss::result][jss::bids][0u][jss::TakerGets] ==
348 BEAST_EXPECT(
349 jv[jss::result][jss::bids][0u][jss::TakerPays] ==
350 usd(100).value().getJson(JsonOptions::Values::None));
351 BEAST_EXPECT(!jv[jss::result].isMember(jss::offers));
352 }
353
354 {
355 // Create an ask: TakerPays 700, TakerGets 100/USD
356 env(offer("alice", XRP(700), usd(100)), Require(Owners("alice", 3)));
357 env.close();
358
359 // Check stream update
360 BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
361 auto const& t = jv[jss::transaction];
362 return t[jss::TransactionType] == jss::OfferCreate &&
363 t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::Values::None) &&
364 t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::Values::None);
365 }));
366 }
367
368 {
369 // Create a bid: TakerPays 100/USD, TakerGets 75
370 env(offer("alice", usd(100), XRP(75)), Require(Owners("alice", 4)));
371 env.close();
372
373 // Check stream update
374 BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
375 auto const& t = jv[jss::transaction];
376 return t[jss::TransactionType] == jss::OfferCreate &&
377 t[jss::TakerGets] == XRP(75).value().getJson(JsonOptions::Values::None) &&
378 t[jss::TakerPays] == usd(100).value().getJson(JsonOptions::Values::None);
379 }));
380 }
381
382 // RPC unsubscribe
383 auto jv = wsc->invoke("unsubscribe", books);
384 BEAST_EXPECT(jv[jss::status] == "success");
385 if (wsc->version() == 2)
386 {
387 BEAST_EXPECT(hasEnvelope2(jv));
388 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
389 }
390 }
391
392 void
394 {
395 testcase("Multiple Books, One Side Empty");
396 using namespace std::chrono_literals;
397 using namespace jtx;
398 Env env(*this);
399 env.fund(XRP(10000), "alice");
400 auto usd = Account("alice")["USD"];
401 auto cny = Account("alice")["CNY"];
402 auto jpy = Account("alice")["JPY"];
403 auto wsc = makeWSClient(env.app().config());
404 json::Value books;
405
406 {
407 // RPC subscribe to books stream
408 books[jss::books] = json::ValueType::Array;
409 {
410 auto& j = books[jss::books].append(json::ValueType::Object);
411 j[jss::snapshot] = true;
412 j[jss::taker_gets][jss::currency] = "XRP";
413 j[jss::taker_pays][jss::currency] = "USD";
414 j[jss::taker_pays][jss::issuer] = Account("alice").human();
415 }
416 {
417 auto& j = books[jss::books].append(json::ValueType::Object);
418 j[jss::snapshot] = true;
419 j[jss::taker_gets][jss::currency] = "CNY";
420 j[jss::taker_gets][jss::issuer] = Account("alice").human();
421 j[jss::taker_pays][jss::currency] = "JPY";
422 j[jss::taker_pays][jss::issuer] = Account("alice").human();
423 }
424
425 auto jv = wsc->invoke("subscribe", books);
426 if (wsc->version() == 2)
427 {
428 BEAST_EXPECT(hasEnvelope2(jv));
429 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
430 }
431 if (!BEAST_EXPECT(jv[jss::status] == "success"))
432 return;
433 BEAST_EXPECT(
434 jv[jss::result].isMember(jss::offers) && jv[jss::result][jss::offers].size() == 0);
435 BEAST_EXPECT(!jv[jss::result].isMember(jss::asks));
436 BEAST_EXPECT(!jv[jss::result].isMember(jss::bids));
437 }
438
439 {
440 // Create an ask: TakerPays 700, TakerGets 100/USD
441 env(offer("alice", XRP(700), usd(100)), Require(Owners("alice", 1)));
442 env.close();
443
444 // Check stream update
445 BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
446 auto const& t = jv[jss::transaction];
447 return t[jss::TransactionType] == jss::OfferCreate &&
448 t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::Values::None) &&
449 t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::Values::None);
450 }));
451 }
452
453 {
454 // Create a bid: TakerPays 100/USD, TakerGets 75
455 env(offer("alice", usd(100), XRP(75)), Require(Owners("alice", 2)));
456 env.close();
457 BEAST_EXPECT(!wsc->getMsg(10ms));
458 }
459
460 {
461 // Create an ask: TakerPays 700/CNY, TakerGets 100/JPY
462 env(offer("alice", cny(700), jpy(100)), Require(Owners("alice", 3)));
463 env.close();
464
465 // Check stream update
466 BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
467 auto const& t = jv[jss::transaction];
468 return t[jss::TransactionType] == jss::OfferCreate &&
469 t[jss::TakerGets] == jpy(100).value().getJson(JsonOptions::Values::None) &&
470 t[jss::TakerPays] == cny(700).value().getJson(JsonOptions::Values::None);
471 }));
472 }
473
474 {
475 // Create a bid: TakerPays 100/JPY, TakerGets 75/CNY
476 env(offer("alice", jpy(100), cny(75)), Require(Owners("alice", 4)));
477 env.close();
478 BEAST_EXPECT(!wsc->getMsg(10ms));
479 }
480
481 // RPC unsubscribe
482 auto jv = wsc->invoke("unsubscribe", books);
483 BEAST_EXPECT(jv[jss::status] == "success");
484 if (wsc->version() == 2)
485 {
486 BEAST_EXPECT(hasEnvelope2(jv));
487 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
488 }
489 }
490
491 void
493 {
494 testcase("Multiple Books, One Side Offers In Book");
495 using namespace std::chrono_literals;
496 using namespace jtx;
497 Env env(*this);
498 env.fund(XRP(10000), "alice");
499 auto usd = Account("alice")["USD"];
500 auto cny = Account("alice")["CNY"];
501 auto jpy = Account("alice")["JPY"];
502 auto wsc = makeWSClient(env.app().config());
503 json::Value books;
504
505 // Create an ask: TakerPays 500, TakerGets 100/USD
506 env(offer("alice", XRP(500), usd(100)), Require(Owners("alice", 1)));
507
508 // Create an ask: TakerPays 500/CNY, TakerGets 100/JPY
509 env(offer("alice", cny(500), jpy(100)), Require(Owners("alice", 2)));
510
511 // Create a bid: TakerPays 100/USD, TakerGets 200
512 env(offer("alice", usd(100), XRP(200)), Require(Owners("alice", 3)));
513
514 // Create a bid: TakerPays 100/JPY, TakerGets 200/CNY
515 env(offer("alice", jpy(100), cny(200)), Require(Owners("alice", 4)));
516 env.close();
517
518 {
519 // RPC subscribe to books stream
520 books[jss::books] = json::ValueType::Array;
521 {
522 auto& j = books[jss::books].append(json::ValueType::Object);
523 j[jss::snapshot] = true;
524 j[jss::taker_gets][jss::currency] = "XRP";
525 j[jss::taker_pays][jss::currency] = "USD";
526 j[jss::taker_pays][jss::issuer] = Account("alice").human();
527 }
528 {
529 auto& j = books[jss::books].append(json::ValueType::Object);
530 j[jss::snapshot] = true;
531 j[jss::taker_gets][jss::currency] = "CNY";
532 j[jss::taker_gets][jss::issuer] = Account("alice").human();
533 j[jss::taker_pays][jss::currency] = "JPY";
534 j[jss::taker_pays][jss::issuer] = Account("alice").human();
535 }
536
537 auto jv = wsc->invoke("subscribe", books);
538 if (wsc->version() == 2)
539 {
540 BEAST_EXPECT(hasEnvelope2(jv));
541 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
542 }
543 if (!BEAST_EXPECT(jv[jss::status] == "success"))
544 return;
545 BEAST_EXPECT(
546 jv[jss::result].isMember(jss::offers) && jv[jss::result][jss::offers].size() == 2);
547 BEAST_EXPECT(
548 jv[jss::result][jss::offers][0u][jss::TakerGets] ==
550 BEAST_EXPECT(
551 jv[jss::result][jss::offers][0u][jss::TakerPays] ==
552 usd(100).value().getJson(JsonOptions::Values::None));
553 BEAST_EXPECT(
554 jv[jss::result][jss::offers][1u][jss::TakerGets] ==
555 cny(200).value().getJson(JsonOptions::Values::None));
556 BEAST_EXPECT(
557 jv[jss::result][jss::offers][1u][jss::TakerPays] ==
558 jpy(100).value().getJson(JsonOptions::Values::None));
559 BEAST_EXPECT(!jv[jss::result].isMember(jss::asks));
560 BEAST_EXPECT(!jv[jss::result].isMember(jss::bids));
561 }
562
563 {
564 // Create an ask: TakerPays 700, TakerGets 100/USD
565 env(offer("alice", XRP(700), usd(100)), Require(Owners("alice", 5)));
566 env.close();
567
568 // Check stream update
569 BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
570 auto const& t = jv[jss::transaction];
571 return t[jss::TransactionType] == jss::OfferCreate &&
572 t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::Values::None) &&
573 t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::Values::None);
574 }));
575 }
576
577 {
578 // Create a bid: TakerPays 100/USD, TakerGets 75
579 env(offer("alice", usd(100), XRP(75)), Require(Owners("alice", 6)));
580 env.close();
581 BEAST_EXPECT(!wsc->getMsg(10ms));
582 }
583
584 {
585 // Create an ask: TakerPays 700/CNY, TakerGets 100/JPY
586 env(offer("alice", cny(700), jpy(100)), Require(Owners("alice", 7)));
587 env.close();
588
589 // Check stream update
590 BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
591 auto const& t = jv[jss::transaction];
592 return t[jss::TransactionType] == jss::OfferCreate &&
593 t[jss::TakerGets] == jpy(100).value().getJson(JsonOptions::Values::None) &&
594 t[jss::TakerPays] == cny(700).value().getJson(JsonOptions::Values::None);
595 }));
596 }
597
598 {
599 // Create a bid: TakerPays 100/JPY, TakerGets 75/CNY
600 env(offer("alice", jpy(100), cny(75)), Require(Owners("alice", 8)));
601 env.close();
602 BEAST_EXPECT(!wsc->getMsg(10ms));
603 }
604
605 // RPC unsubscribe
606 auto jv = wsc->invoke("unsubscribe", books);
607 BEAST_EXPECT(jv[jss::status] == "success");
608 if (wsc->version() == 2)
609 {
610 BEAST_EXPECT(hasEnvelope2(jv));
611 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
612 }
613 }
614
615 void
617 {
618 testcase("Multiple Books, Both Sides Empty Book");
619 using namespace std::chrono_literals;
620 using namespace jtx;
621 Env env(*this);
622 env.fund(XRP(10000), "alice");
623 auto usd = Account("alice")["USD"];
624 auto cny = Account("alice")["CNY"];
625 auto jpy = Account("alice")["JPY"];
626 auto wsc = makeWSClient(env.app().config());
627 json::Value books;
628
629 {
630 // RPC subscribe to books stream
631 books[jss::books] = json::ValueType::Array;
632 {
633 auto& j = books[jss::books].append(json::ValueType::Object);
634 j[jss::snapshot] = true;
635 j[jss::both] = true;
636 j[jss::taker_gets][jss::currency] = "XRP";
637 j[jss::taker_pays][jss::currency] = "USD";
638 j[jss::taker_pays][jss::issuer] = Account("alice").human();
639 }
640 {
641 auto& j = books[jss::books].append(json::ValueType::Object);
642 j[jss::snapshot] = true;
643 j[jss::both] = true;
644 j[jss::taker_gets][jss::currency] = "CNY";
645 j[jss::taker_gets][jss::issuer] = Account("alice").human();
646 j[jss::taker_pays][jss::currency] = "JPY";
647 j[jss::taker_pays][jss::issuer] = Account("alice").human();
648 }
649
650 auto jv = wsc->invoke("subscribe", books);
651 if (wsc->version() == 2)
652 {
653 BEAST_EXPECT(hasEnvelope2(jv));
654 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
655 }
656 if (!BEAST_EXPECT(jv[jss::status] == "success"))
657 return;
658 BEAST_EXPECT(
659 jv[jss::result].isMember(jss::asks) && jv[jss::result][jss::asks].size() == 0);
660 BEAST_EXPECT(
661 jv[jss::result].isMember(jss::bids) && jv[jss::result][jss::bids].size() == 0);
662 BEAST_EXPECT(!jv[jss::result].isMember(jss::offers));
663 }
664
665 {
666 // Create an ask: TakerPays 700, TakerGets 100/USD
667 env(offer("alice", XRP(700), usd(100)), Require(Owners("alice", 1)));
668 env.close();
669
670 // Check stream update
671 BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
672 auto const& t = jv[jss::transaction];
673 return t[jss::TransactionType] == jss::OfferCreate &&
674 t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::Values::None) &&
675 t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::Values::None);
676 }));
677 }
678
679 {
680 // Create a bid: TakerPays 100/USD, TakerGets 75
681 env(offer("alice", usd(100), XRP(75)), Require(Owners("alice", 2)));
682 env.close();
683
684 // Check stream update
685 BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
686 auto const& t = jv[jss::transaction];
687 return t[jss::TransactionType] == jss::OfferCreate &&
688 t[jss::TakerGets] == XRP(75).value().getJson(JsonOptions::Values::None) &&
689 t[jss::TakerPays] == usd(100).value().getJson(JsonOptions::Values::None);
690 }));
691 }
692
693 {
694 // Create an ask: TakerPays 700/CNY, TakerGets 100/JPY
695 env(offer("alice", cny(700), jpy(100)), Require(Owners("alice", 3)));
696 env.close();
697
698 // Check stream update
699 BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
700 auto const& t = jv[jss::transaction];
701 return t[jss::TransactionType] == jss::OfferCreate &&
702 t[jss::TakerGets] == jpy(100).value().getJson(JsonOptions::Values::None) &&
703 t[jss::TakerPays] == cny(700).value().getJson(JsonOptions::Values::None);
704 }));
705 }
706
707 {
708 // Create a bid: TakerPays 100/JPY, TakerGets 75/CNY
709 env(offer("alice", jpy(100), cny(75)), Require(Owners("alice", 4)));
710 env.close();
711
712 // Check stream update
713 BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
714 auto const& t = jv[jss::transaction];
715 return t[jss::TransactionType] == jss::OfferCreate &&
716 t[jss::TakerGets] == cny(75).value().getJson(JsonOptions::Values::None) &&
717 t[jss::TakerPays] == jpy(100).value().getJson(JsonOptions::Values::None);
718 }));
719 }
720
721 // RPC unsubscribe
722 auto jv = wsc->invoke("unsubscribe", books);
723 BEAST_EXPECT(jv[jss::status] == "success");
724 if (wsc->version() == 2)
725 {
726 BEAST_EXPECT(hasEnvelope2(jv));
727 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
728 }
729 }
730
731 void
733 {
734 testcase("Multiple Books, Both Sides Offers In Book");
735 using namespace std::chrono_literals;
736 using namespace jtx;
737 Env env(*this);
738 env.fund(XRP(10000), "alice");
739 auto usd = Account("alice")["USD"];
740 auto cny = Account("alice")["CNY"];
741 auto jpy = Account("alice")["JPY"];
742 auto wsc = makeWSClient(env.app().config());
743 json::Value books;
744
745 // Create an ask: TakerPays 500, TakerGets 100/USD
746 env(offer("alice", XRP(500), usd(100)), Require(Owners("alice", 1)));
747
748 // Create an ask: TakerPays 500/CNY, TakerGets 100/JPY
749 env(offer("alice", cny(500), jpy(100)), Require(Owners("alice", 2)));
750
751 // Create a bid: TakerPays 100/USD, TakerGets 200
752 env(offer("alice", usd(100), XRP(200)), Require(Owners("alice", 3)));
753
754 // Create a bid: TakerPays 100/JPY, TakerGets 200/CNY
755 env(offer("alice", jpy(100), cny(200)), Require(Owners("alice", 4)));
756 env.close();
757
758 {
759 // RPC subscribe to books stream
760 books[jss::books] = json::ValueType::Array;
761 {
762 auto& j = books[jss::books].append(json::ValueType::Object);
763 j[jss::snapshot] = true;
764 j[jss::both] = true;
765 j[jss::taker_gets][jss::currency] = "XRP";
766 j[jss::taker_pays][jss::currency] = "USD";
767 j[jss::taker_pays][jss::issuer] = Account("alice").human();
768 }
769 // RPC subscribe to books stream
770 {
771 auto& j = books[jss::books].append(json::ValueType::Object);
772 j[jss::snapshot] = true;
773 j[jss::both] = true;
774 j[jss::taker_gets][jss::currency] = "CNY";
775 j[jss::taker_gets][jss::issuer] = Account("alice").human();
776 j[jss::taker_pays][jss::currency] = "JPY";
777 j[jss::taker_pays][jss::issuer] = Account("alice").human();
778 }
779
780 auto jv = wsc->invoke("subscribe", books);
781 if (wsc->version() == 2)
782 {
783 BEAST_EXPECT(hasEnvelope2(jv));
784 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
785 }
786 if (!BEAST_EXPECT(jv[jss::status] == "success"))
787 return;
788 BEAST_EXPECT(
789 jv[jss::result].isMember(jss::asks) && jv[jss::result][jss::asks].size() == 2);
790 BEAST_EXPECT(
791 jv[jss::result].isMember(jss::bids) && jv[jss::result][jss::bids].size() == 2);
792 BEAST_EXPECT(
793 jv[jss::result][jss::asks][0u][jss::TakerGets] ==
794 usd(100).value().getJson(JsonOptions::Values::None));
795 BEAST_EXPECT(
796 jv[jss::result][jss::asks][0u][jss::TakerPays] ==
798 BEAST_EXPECT(
799 jv[jss::result][jss::asks][1u][jss::TakerGets] ==
800 jpy(100).value().getJson(JsonOptions::Values::None));
801 BEAST_EXPECT(
802 jv[jss::result][jss::asks][1u][jss::TakerPays] ==
803 cny(500).value().getJson(JsonOptions::Values::None));
804 BEAST_EXPECT(
805 jv[jss::result][jss::bids][0u][jss::TakerGets] ==
807 BEAST_EXPECT(
808 jv[jss::result][jss::bids][0u][jss::TakerPays] ==
809 usd(100).value().getJson(JsonOptions::Values::None));
810 BEAST_EXPECT(
811 jv[jss::result][jss::bids][1u][jss::TakerGets] ==
812 cny(200).value().getJson(JsonOptions::Values::None));
813 BEAST_EXPECT(
814 jv[jss::result][jss::bids][1u][jss::TakerPays] ==
815 jpy(100).value().getJson(JsonOptions::Values::None));
816 BEAST_EXPECT(!jv[jss::result].isMember(jss::offers));
817 }
818
819 {
820 // Create an ask: TakerPays 700, TakerGets 100/USD
821 env(offer("alice", XRP(700), usd(100)), Require(Owners("alice", 5)));
822 env.close();
823
824 // Check stream update
825 BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
826 auto const& t = jv[jss::transaction];
827 return t[jss::TransactionType] == jss::OfferCreate &&
828 t[jss::TakerGets] == usd(100).value().getJson(JsonOptions::Values::None) &&
829 t[jss::TakerPays] == XRP(700).value().getJson(JsonOptions::Values::None);
830 }));
831 }
832
833 {
834 // Create a bid: TakerPays 100/USD, TakerGets 75
835 env(offer("alice", usd(100), XRP(75)), Require(Owners("alice", 6)));
836 env.close();
837
838 // Check stream update
839 BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
840 auto const& t = jv[jss::transaction];
841 return t[jss::TransactionType] == jss::OfferCreate &&
842 t[jss::TakerGets] == XRP(75).value().getJson(JsonOptions::Values::None) &&
843 t[jss::TakerPays] == usd(100).value().getJson(JsonOptions::Values::None);
844 }));
845 }
846
847 {
848 // Create an ask: TakerPays 700/CNY, TakerGets 100/JPY
849 env(offer("alice", cny(700), jpy(100)), Require(Owners("alice", 7)));
850 env.close();
851
852 // Check stream update
853 BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
854 auto const& t = jv[jss::transaction];
855 return t[jss::TransactionType] == jss::OfferCreate &&
856 t[jss::TakerGets] == jpy(100).value().getJson(JsonOptions::Values::None) &&
857 t[jss::TakerPays] == cny(700).value().getJson(JsonOptions::Values::None);
858 }));
859 }
860
861 {
862 // Create a bid: TakerPays 100/JPY, TakerGets 75/CNY
863 env(offer("alice", jpy(100), cny(75)), Require(Owners("alice", 8)));
864 env.close();
865
866 // Check stream update
867 BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
868 auto const& t = jv[jss::transaction];
869 return t[jss::TransactionType] == jss::OfferCreate &&
870 t[jss::TakerGets] == cny(75).value().getJson(JsonOptions::Values::None) &&
871 t[jss::TakerPays] == jpy(100).value().getJson(JsonOptions::Values::None);
872 }));
873 }
874
875 // RPC unsubscribe
876 auto jv = wsc->invoke("unsubscribe", books);
877 BEAST_EXPECT(jv[jss::status] == "success");
878 if (wsc->version() == 2)
879 {
880 BEAST_EXPECT(hasEnvelope2(jv));
881 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
882 }
883 }
884
885 void
887 {
888 testcase("TrackOffers");
889 using namespace jtx;
890 Env env(*this);
891 Account const gw{"gw"};
892 Account const alice{"alice"};
893 Account const bob{"bob"};
894 auto wsc = makeWSClient(env.app().config());
895 env.fund(XRP(20000), alice, bob, gw);
896 env.close();
897 auto usd = gw["USD"];
898
899 json::Value books;
900 {
901 books[jss::books] = json::ValueType::Array;
902 {
903 auto& j = books[jss::books].append(json::ValueType::Object);
904 j[jss::snapshot] = true;
905 j[jss::taker_gets][jss::currency] = "XRP";
906 j[jss::taker_pays][jss::currency] = "USD";
907 j[jss::taker_pays][jss::issuer] = gw.human();
908 }
909
910 auto jv = wsc->invoke("subscribe", books);
911 if (wsc->version() == 2)
912 {
913 BEAST_EXPECT(hasEnvelope2(jv));
914 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
915 }
916 if (!BEAST_EXPECT(jv[jss::status] == "success"))
917 return;
918 BEAST_EXPECT(
919 jv[jss::result].isMember(jss::offers) && jv[jss::result][jss::offers].size() == 0);
920 BEAST_EXPECT(!jv[jss::result].isMember(jss::asks));
921 BEAST_EXPECT(!jv[jss::result].isMember(jss::bids));
922 }
923
924 env(rate(gw, 1.1));
925 env.close();
926 env.trust(usd(1000), alice);
927 env.trust(usd(1000), bob);
928 env(pay(gw, alice, usd(100)));
929 env(pay(gw, bob, usd(50)));
930 env(offer(alice, XRP(4000), usd(10)));
931 env.close();
932
933 json::Value jvParams;
934 jvParams[jss::taker] = env.master.human();
935 jvParams[jss::taker_pays][jss::currency] = "XRP";
936 jvParams[jss::ledger_index] = "validated";
937 jvParams[jss::taker_gets][jss::currency] = "USD";
938 jvParams[jss::taker_gets][jss::issuer] = gw.human();
939
940 auto jv = wsc->invoke("book_offers", jvParams);
941 if (wsc->version() == 2)
942 {
943 BEAST_EXPECT(hasEnvelope2(jv));
944 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
945 }
946 auto jrr = jv[jss::result];
947
948 BEAST_EXPECT(jrr[jss::offers].isArray());
949 BEAST_EXPECT(jrr[jss::offers].size() == 1);
950 auto const jrOffer = jrr[jss::offers][0u];
951 BEAST_EXPECT(jrOffer[sfAccount.fieldName] == alice.human());
952 BEAST_EXPECT(jrOffer[sfBookDirectory.fieldName] == getBookDir(env, XRP, usd));
953 BEAST_EXPECT(jrOffer[sfBookNode.fieldName] == "0");
954 BEAST_EXPECT(jrOffer[jss::Flags] == 0);
955 BEAST_EXPECT(jrOffer[sfLedgerEntryType.fieldName] == jss::Offer);
956 BEAST_EXPECT(jrOffer[sfOwnerNode.fieldName] == "0");
957 BEAST_EXPECT(jrOffer[sfSequence.fieldName] == 5);
958 BEAST_EXPECT(jrOffer[jss::TakerGets] == usd(10).value().getJson(JsonOptions::Values::None));
959 BEAST_EXPECT(
960 jrOffer[jss::TakerPays] == XRP(4000).value().getJson(JsonOptions::Values::None));
961 BEAST_EXPECT(jrOffer[jss::owner_funds] == "100");
962 BEAST_EXPECT(jrOffer[jss::quality] == "400000000");
963
964 using namespace std::chrono_literals;
965 BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jval) {
966 auto const& t = jval[jss::transaction];
967 return t[jss::TransactionType] == jss::OfferCreate &&
968 t[jss::TakerGets] == usd(10).value().getJson(JsonOptions::Values::None) &&
969 t[jss::owner_funds] == "100" &&
970 t[jss::TakerPays] == XRP(4000).value().getJson(JsonOptions::Values::None);
971 }));
972
973 env(offer(bob, XRP(2000), usd(5)));
974 env.close();
975
976 BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jval) {
977 auto const& t = jval[jss::transaction];
978 return t[jss::TransactionType] == jss::OfferCreate &&
979 t[jss::TakerGets] == usd(5).value().getJson(JsonOptions::Values::None) &&
980 t[jss::owner_funds] == "50" &&
981 t[jss::TakerPays] == XRP(2000).value().getJson(JsonOptions::Values::None);
982 }));
983
984 jv = wsc->invoke("book_offers", jvParams);
985 if (wsc->version() == 2)
986 {
987 BEAST_EXPECT(hasEnvelope2(jv));
988 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
989 }
990 jrr = jv[jss::result];
991
992 BEAST_EXPECT(jrr[jss::offers].isArray());
993 BEAST_EXPECT(jrr[jss::offers].size() == 2);
994 auto const jrNextOffer = jrr[jss::offers][1u];
995 BEAST_EXPECT(jrNextOffer[sfAccount.fieldName] == bob.human());
996 BEAST_EXPECT(jrNextOffer[sfBookDirectory.fieldName] == getBookDir(env, XRP, usd));
997 BEAST_EXPECT(jrNextOffer[sfBookNode.fieldName] == "0");
998 BEAST_EXPECT(jrNextOffer[jss::Flags] == 0);
999 BEAST_EXPECT(jrNextOffer[sfLedgerEntryType.fieldName] == jss::Offer);
1000 BEAST_EXPECT(jrNextOffer[sfOwnerNode.fieldName] == "0");
1001 BEAST_EXPECT(jrNextOffer[sfSequence.fieldName] == 5);
1002 BEAST_EXPECT(
1003 jrNextOffer[jss::TakerGets] == usd(5).value().getJson(JsonOptions::Values::None));
1004 BEAST_EXPECT(
1005 jrNextOffer[jss::TakerPays] == XRP(2000).value().getJson(JsonOptions::Values::None));
1006 BEAST_EXPECT(jrNextOffer[jss::owner_funds] == "50");
1007 BEAST_EXPECT(jrNextOffer[jss::quality] == "400000000");
1008
1009 jv = wsc->invoke("unsubscribe", books);
1010 if (wsc->version() == 2)
1011 {
1012 BEAST_EXPECT(hasEnvelope2(jv));
1013 BEAST_EXPECT(jv.isMember(jss::id) && jv[jss::id] == 5);
1014 }
1015 BEAST_EXPECT(jv[jss::status] == "success");
1016 }
1017
1018 // Check that a stream only sees the given OfferCreate once
1019 static bool
1021 std::unique_ptr<WSClient> const& wsc,
1022 std::chrono::milliseconds const& timeout,
1023 jtx::PrettyAmount const& takerGets,
1024 jtx::PrettyAmount const& takerPays)
1025 {
1026 auto maybeJv = wsc->getMsg(timeout);
1027 // No message
1028 if (!maybeJv)
1029 return false;
1030 // wrong message
1031 if (!(*maybeJv).isMember(jss::transaction))
1032 return false;
1033 auto const& t = (*maybeJv)[jss::transaction];
1034 if (t[jss::TransactionType] != jss::OfferCreate ||
1035 t[jss::TakerGets] != takerGets.value().getJson(JsonOptions::Values::None) ||
1036 t[jss::TakerPays] != takerPays.value().getJson(JsonOptions::Values::None))
1037 return false;
1038 // Make sure no other message is waiting
1039 return wsc->getMsg(timeout) == std::nullopt;
1040 }
1041
1042 void
1044 {
1045 testcase("Crossing single book offer");
1046
1047 // This was added to check that an OfferCreate transaction is only
1048 // published once in a stream, even if it updates multiple offer
1049 // ledger entries
1050
1051 using namespace jtx;
1052 Env env(*this);
1053
1054 // Scenario is:
1055 // - Alice and Bob place identical offers for USD -> XRP
1056 // - Charlie places a crossing order that takes both Alice and Bob's
1057
1058 auto const gw = Account("gateway");
1059 auto const alice = Account("alice");
1060 auto const bob = Account("bob");
1061 auto const charlie = Account("charlie");
1062 auto const usd = gw["USD"];
1063
1064 env.fund(XRP(1000000), gw, alice, bob, charlie);
1065 env.close();
1066
1067 env(trust(alice, usd(500)));
1068 env(trust(bob, usd(500)));
1069 env.close();
1070
1071 env(pay(gw, alice, usd(500)));
1072 env(pay(gw, bob, usd(500)));
1073 env.close();
1074
1075 // Alice and Bob offer $500 for 500 XRP
1076 env(offer(alice, XRP(500), usd(500)));
1077 env(offer(bob, XRP(500), usd(500)));
1078 env.close();
1079
1080 auto wsc = makeWSClient(env.app().config());
1081 json::Value books;
1082 {
1083 // RPC subscribe to books stream
1084 books[jss::books] = json::ValueType::Array;
1085 {
1086 auto& j = books[jss::books].append(json::ValueType::Object);
1087 j[jss::snapshot] = false;
1088 j[jss::taker_gets][jss::currency] = "XRP";
1089 j[jss::taker_pays][jss::currency] = "USD";
1090 j[jss::taker_pays][jss::issuer] = gw.human();
1091 }
1092
1093 auto jv = wsc->invoke("subscribe", books);
1094 if (!BEAST_EXPECT(jv[jss::status] == "success"))
1095 return;
1096 }
1097
1098 // Charlie places an offer that crosses Alice and Charlie's offers
1099 env(offer(charlie, usd(1000), XRP(1000)));
1100 env.close();
1101 env.require(Offers(alice, 0), Offers(bob, 0), Offers(charlie, 0));
1102 using namespace std::chrono_literals;
1103 BEAST_EXPECT(offerOnlyOnceInStream(wsc, 1s, XRP(1000), usd(1000)));
1104
1105 // RPC unsubscribe
1106 auto jv = wsc->invoke("unsubscribe", books);
1107 BEAST_EXPECT(jv[jss::status] == "success");
1108 }
1109
1110 void
1112 {
1113 testcase("Crossing multi-book offer");
1114
1115 // This was added to check that an OfferCreate transaction is only
1116 // published once in a stream, even if it auto-bridges across several
1117 // books that are under subscription
1118
1119 using namespace jtx;
1120 Env env(*this);
1121
1122 // Scenario is:
1123 // - Alice has 1 USD and wants 100 XRP
1124 // - Bob has 100 XRP and wants 1 EUR
1125 // - Charlie has 1 EUR and wants 1 USD and should auto-bridge through
1126 // Alice and Bob
1127
1128 auto const gw = Account("gateway");
1129 auto const alice = Account("alice");
1130 auto const bob = Account("bob");
1131 auto const charlie = Account("charlie");
1132 auto const usd = gw["USD"];
1133 auto const eur = gw["EUR"];
1134
1135 env.fund(XRP(1000000), gw, alice, bob, charlie);
1136 env.close();
1137
1138 for (auto const& account : {alice, bob, charlie})
1139 {
1140 for (auto const& iou : {usd, eur})
1141 {
1142 env(trust(account, iou(1)));
1143 }
1144 }
1145 env.close();
1146
1147 env(pay(gw, alice, usd(1)));
1148 env(pay(gw, charlie, eur(1)));
1149 env.close();
1150
1151 env(offer(alice, XRP(100), usd(1)));
1152 env(offer(bob, eur(1), XRP(100)));
1153 env.close();
1154
1155 auto wsc = makeWSClient(env.app().config());
1156 json::Value books;
1157
1158 {
1159 // RPC subscribe to multiple book streams
1160 books[jss::books] = json::ValueType::Array;
1161 {
1162 auto& j = books[jss::books].append(json::ValueType::Object);
1163 j[jss::snapshot] = false;
1164 j[jss::taker_gets][jss::currency] = "XRP";
1165 j[jss::taker_pays][jss::currency] = "USD";
1166 j[jss::taker_pays][jss::issuer] = gw.human();
1167 }
1168
1169 {
1170 auto& j = books[jss::books].append(json::ValueType::Object);
1171 j[jss::snapshot] = false;
1172 j[jss::taker_gets][jss::currency] = "EUR";
1173 j[jss::taker_gets][jss::issuer] = gw.human();
1174 j[jss::taker_pays][jss::currency] = "XRP";
1175 }
1176
1177 auto jv = wsc->invoke("subscribe", books);
1178 if (!BEAST_EXPECT(jv[jss::status] == "success"))
1179 return;
1180 }
1181
1182 // Charlies places an on offer for EUR -> USD that should auto-bridge
1183 env(offer(charlie, usd(1), eur(1)));
1184 env.close();
1185 using namespace std::chrono_literals;
1186 BEAST_EXPECT(offerOnlyOnceInStream(wsc, 1s, eur(1), usd(1)));
1187
1188 // RPC unsubscribe
1189 auto jv = wsc->invoke("unsubscribe", books);
1190 BEAST_EXPECT(jv[jss::status] == "success");
1191 }
1192
1193 void
1195 {
1196 testcase("BookOffersRPC Errors");
1197 using namespace jtx;
1198 Env env(*this);
1199 Account const gw{"gw"};
1200 Account const alice{"alice"};
1201 env.fund(XRP(10000), alice, gw);
1202 env.close();
1203 auto const usd = gw["USD"];
1204
1205 {
1206 json::Value jvParams;
1207 jvParams[jss::ledger_index] = 10u;
1208 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1209 BEAST_EXPECT(jrr[jss::error] == "lgrNotFound");
1210 BEAST_EXPECT(jrr[jss::error_code] == RpcLgrNotFound);
1211 BEAST_EXPECT(jrr[jss::error_message] == "ledgerNotFound");
1212 }
1213
1214 {
1215 json::Value jvParams;
1216 jvParams[jss::ledger_index] = "validated";
1217 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1218 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
1219 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
1220 BEAST_EXPECT(jrr[jss::error_message] == "Missing field 'taker_pays'.");
1221 }
1222
1223 {
1224 json::Value jvParams;
1225 jvParams[jss::ledger_index] = "validated";
1226 jvParams[jss::taker_pays] = json::ValueType::Object;
1227 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1228 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
1229 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
1230 BEAST_EXPECT(jrr[jss::error_message] == "Missing field 'taker_gets'.");
1231 }
1232
1233 {
1234 json::Value jvParams;
1235 jvParams[jss::ledger_index] = "validated";
1236 jvParams[jss::taker_pays] = "not an object";
1237 jvParams[jss::taker_gets] = json::ValueType::Object;
1238 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1239 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
1240 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
1241 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'taker_pays', not object.");
1242 }
1243
1244 {
1245 json::Value jvParams;
1246 jvParams[jss::ledger_index] = "validated";
1247 jvParams[jss::taker_pays] = json::ValueType::Object;
1248 jvParams[jss::taker_gets] = "not an object";
1249 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1250 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
1251 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
1252 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'taker_gets', not object.");
1253 }
1254
1255 {
1256 json::Value jvParams;
1257 jvParams[jss::ledger_index] = "validated";
1258 jvParams[jss::taker_pays] = json::ValueType::Object;
1259 jvParams[jss::taker_gets] = json::ValueType::Object;
1260 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1261 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
1262 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
1263 BEAST_EXPECT(jrr[jss::error_message] == "Missing field 'taker_pays.currency'.");
1264 }
1265
1266 {
1267 json::Value jvParams;
1268 jvParams[jss::ledger_index] = "validated";
1269 jvParams[jss::taker_pays][jss::currency] = 1;
1270 jvParams[jss::taker_gets] = json::ValueType::Object;
1271 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1272 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
1273 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
1274 BEAST_EXPECT(
1275 jrr[jss::error_message] == "Invalid field 'taker_pays.currency', not string.");
1276 }
1277
1278 {
1279 json::Value jvParams;
1280 jvParams[jss::ledger_index] = "validated";
1281 jvParams[jss::taker_pays][jss::currency] = "XRP";
1282 jvParams[jss::taker_gets] = json::ValueType::Object;
1283 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1284 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
1285 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
1286 BEAST_EXPECT(jrr[jss::error_message] == "Missing field 'taker_gets.currency'.");
1287 }
1288
1289 {
1290 json::Value jvParams;
1291 jvParams[jss::ledger_index] = "validated";
1292 jvParams[jss::taker_pays][jss::currency] = "XRP";
1293 jvParams[jss::taker_gets][jss::currency] = 1;
1294 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1295 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
1296 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
1297 BEAST_EXPECT(
1298 jrr[jss::error_message] == "Invalid field 'taker_gets.currency', not string.");
1299 }
1300
1301 {
1302 json::Value jvParams;
1303 jvParams[jss::ledger_index] = "validated";
1304 jvParams[jss::taker_pays][jss::currency] = "NOT_VALID";
1305 jvParams[jss::taker_gets][jss::currency] = "XRP";
1306 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1307 BEAST_EXPECT(jrr[jss::error] == "srcCurMalformed");
1308 BEAST_EXPECT(jrr[jss::error_code] == RpcSrcCurMalformed);
1309 BEAST_EXPECT(
1310 jrr[jss::error_message] == "Invalid field 'taker_pays.currency', bad currency.");
1311 }
1312
1313 {
1314 json::Value jvParams;
1315 jvParams[jss::ledger_index] = "validated";
1316 jvParams[jss::taker_pays][jss::currency] = "XRP";
1317 jvParams[jss::taker_gets][jss::currency] = "NOT_VALID";
1318 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1319 BEAST_EXPECT(jrr[jss::error] == "dstAmtMalformed");
1320 BEAST_EXPECT(jrr[jss::error_code] == RpcDstAmtMalformed);
1321 BEAST_EXPECT(
1322 jrr[jss::error_message] == "Invalid field 'taker_gets.currency', bad currency.");
1323 }
1324
1325 {
1326 json::Value jvParams;
1327 jvParams[jss::ledger_index] = "validated";
1328 jvParams[jss::taker_pays][jss::currency] = "XRP";
1329 jvParams[jss::taker_gets][jss::currency] = "USD";
1330 jvParams[jss::taker_gets][jss::issuer] = 1;
1331 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1332 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
1333 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
1334 BEAST_EXPECT(
1335 jrr[jss::error_message] == "Invalid field 'taker_gets.issuer', not string.");
1336 }
1337
1338 {
1339 json::Value jvParams;
1340 jvParams[jss::ledger_index] = "validated";
1341 jvParams[jss::taker_pays][jss::currency] = "XRP";
1342 jvParams[jss::taker_pays][jss::issuer] = 1;
1343 jvParams[jss::taker_gets][jss::currency] = "USD";
1344 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1345 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
1346 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
1347 BEAST_EXPECT(
1348 jrr[jss::error_message] == "Invalid field 'taker_pays.issuer', not string.");
1349 }
1350
1351 {
1352 json::Value jvParams;
1353 jvParams[jss::ledger_index] = "validated";
1354 jvParams[jss::taker_pays][jss::currency] = "XRP";
1355 jvParams[jss::taker_pays][jss::issuer] = gw.human() + "DEAD";
1356 jvParams[jss::taker_gets][jss::currency] = "USD";
1357 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1358 BEAST_EXPECT(jrr[jss::error] == "srcIsrMalformed");
1359 BEAST_EXPECT(jrr[jss::error_code] == RpcSrcIsrMalformed);
1360 BEAST_EXPECT(
1361 jrr[jss::error_message] == "Invalid field 'taker_pays.issuer', bad issuer.");
1362 }
1363
1364 {
1365 json::Value jvParams;
1366 jvParams[jss::ledger_index] = "validated";
1367 jvParams[jss::taker_pays][jss::currency] = "XRP";
1368 jvParams[jss::taker_pays][jss::issuer] = toBase58(noAccount());
1369 jvParams[jss::taker_gets][jss::currency] = "USD";
1370 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1371 BEAST_EXPECT(jrr[jss::error] == "srcIsrMalformed");
1372 BEAST_EXPECT(jrr[jss::error_code] == RpcSrcIsrMalformed);
1373 BEAST_EXPECT(
1374 jrr[jss::error_message] ==
1375 "Invalid field 'taker_pays.issuer', bad issuer account one.");
1376 }
1377
1378 {
1379 json::Value jvParams;
1380 jvParams[jss::ledger_index] = "validated";
1381 jvParams[jss::taker_pays][jss::currency] = "XRP";
1382 jvParams[jss::taker_gets][jss::currency] = "USD";
1383 jvParams[jss::taker_gets][jss::issuer] = gw.human() + "DEAD";
1384 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1385 BEAST_EXPECT(jrr[jss::error] == "dstIsrMalformed");
1386 BEAST_EXPECT(jrr[jss::error_code] == RpcDstIsrMalformed);
1387 BEAST_EXPECT(
1388 jrr[jss::error_message] == "Invalid field 'taker_gets.issuer', bad issuer.");
1389 }
1390
1391 {
1392 json::Value jvParams;
1393 jvParams[jss::ledger_index] = "validated";
1394 jvParams[jss::taker_pays][jss::currency] = "XRP";
1395 jvParams[jss::taker_gets][jss::currency] = "USD";
1396 jvParams[jss::taker_gets][jss::issuer] = toBase58(noAccount());
1397 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1398 BEAST_EXPECT(jrr[jss::error] == "dstIsrMalformed");
1399 BEAST_EXPECT(jrr[jss::error_code] == RpcDstIsrMalformed);
1400 BEAST_EXPECT(
1401 jrr[jss::error_message] ==
1402 "Invalid field 'taker_gets.issuer', bad issuer account one.");
1403 }
1404
1405 {
1406 json::Value jvParams;
1407 jvParams[jss::ledger_index] = "validated";
1408 jvParams[jss::taker_pays][jss::currency] = "XRP";
1409 jvParams[jss::taker_pays][jss::issuer] = alice.human();
1410 jvParams[jss::taker_gets][jss::currency] = "USD";
1411 jvParams[jss::taker_gets][jss::issuer] = gw.human();
1412 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1413 BEAST_EXPECT(jrr[jss::error] == "srcIsrMalformed");
1414 BEAST_EXPECT(jrr[jss::error_code] == RpcSrcIsrMalformed);
1415 BEAST_EXPECT(
1416 jrr[jss::error_message] ==
1417 "Unneeded field 'taker_pays.issuer' "
1418 "for XRP currency specification.");
1419 }
1420
1421 {
1422 json::Value jvParams;
1423 jvParams[jss::ledger_index] = "validated";
1424 jvParams[jss::taker_pays][jss::currency] = "USD";
1425 jvParams[jss::taker_pays][jss::issuer] = toBase58(xrpAccount());
1426 jvParams[jss::taker_gets][jss::currency] = "USD";
1427 jvParams[jss::taker_gets][jss::issuer] = gw.human();
1428 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1429 BEAST_EXPECT(jrr[jss::error] == "srcIsrMalformed");
1430 BEAST_EXPECT(jrr[jss::error_code] == RpcSrcIsrMalformed);
1431 BEAST_EXPECT(
1432 jrr[jss::error_message] ==
1433 "Invalid field 'taker_pays.issuer', expected non-XRP issuer.");
1434 }
1435
1436 {
1437 json::Value jvParams;
1438 jvParams[jss::ledger_index] = "validated";
1439 jvParams[jss::taker] = 1;
1440 jvParams[jss::taker_pays][jss::currency] = "XRP";
1441 jvParams[jss::taker_gets][jss::currency] = "USD";
1442 jvParams[jss::taker_gets][jss::issuer] = gw.human();
1443 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1444 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
1445 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
1446 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'taker', not string.");
1447 }
1448
1449 {
1450 json::Value jvParams;
1451 jvParams[jss::ledger_index] = "validated";
1452 jvParams[jss::taker] = env.master.human() + "DEAD";
1453 jvParams[jss::taker_pays][jss::currency] = "XRP";
1454 jvParams[jss::taker_gets][jss::currency] = "USD";
1455 jvParams[jss::taker_gets][jss::issuer] = gw.human();
1456 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1457 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
1458 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
1459 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'taker'.");
1460 }
1461
1462 {
1463 json::Value jvParams;
1464 jvParams[jss::ledger_index] = "validated";
1465 jvParams[jss::taker] = env.master.human();
1466 jvParams[jss::taker_pays][jss::currency] = "USD";
1467 jvParams[jss::taker_pays][jss::issuer] = gw.human();
1468 jvParams[jss::taker_gets][jss::currency] = "USD";
1469 jvParams[jss::taker_gets][jss::issuer] = gw.human();
1470 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1471 BEAST_EXPECT(jrr[jss::error] == "badMarket");
1472 BEAST_EXPECT(jrr[jss::error_code] == RpcBadMarket);
1473 BEAST_EXPECT(jrr[jss::error_message] == "No such market.");
1474 }
1475
1476 {
1477 json::Value jvParams;
1478 jvParams[jss::ledger_index] = "validated";
1479 jvParams[jss::taker] = env.master.human();
1480 jvParams[jss::limit] = "0"; // NOT an integer
1481 jvParams[jss::taker_pays][jss::currency] = "XRP";
1482 jvParams[jss::taker_gets][jss::currency] = "USD";
1483 jvParams[jss::taker_gets][jss::issuer] = gw.human();
1484 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1485 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
1486 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
1487 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'limit', not unsigned integer.");
1488 }
1489
1490 {
1491 json::Value jvParams;
1492 jvParams[jss::ledger_index] = "validated";
1493 jvParams[jss::taker] = env.master.human();
1494 jvParams[jss::limit] = 0; // must be > 0
1495 jvParams[jss::taker_pays][jss::currency] = "XRP";
1496 jvParams[jss::taker_gets][jss::currency] = "USD";
1497 jvParams[jss::taker_gets][jss::issuer] = gw.human();
1498 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1499 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
1500 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
1501 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'limit'.");
1502 }
1503
1504 {
1505 json::Value jvParams;
1506 jvParams[jss::ledger_index] = "validated";
1507 jvParams[jss::taker_pays][jss::currency] = "USD";
1508 jvParams[jss::taker_pays][jss::issuer] = gw.human();
1509 jvParams[jss::taker_gets][jss::currency] = "USD";
1510 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1511 BEAST_EXPECT(jrr[jss::error] == "dstIsrMalformed");
1512 BEAST_EXPECT(jrr[jss::error_code] == RpcDstIsrMalformed);
1513 BEAST_EXPECT(
1514 jrr[jss::error_message] ==
1515 "Invalid field 'taker_gets.issuer', "
1516 "expected non-XRP issuer.");
1517 }
1518
1519 {
1520 json::Value jvParams;
1521 jvParams[jss::ledger_index] = "validated";
1522 jvParams[jss::taker_pays][jss::currency] = "USD";
1523 jvParams[jss::taker_pays][jss::issuer] = gw.human();
1524 jvParams[jss::taker_gets][jss::currency] = "XRP";
1525 jvParams[jss::taker_gets][jss::issuer] = gw.human();
1526 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1527 BEAST_EXPECT(jrr[jss::error] == "dstIsrMalformed");
1528 BEAST_EXPECT(jrr[jss::error_code] == RpcDstIsrMalformed);
1529 BEAST_EXPECT(
1530 jrr[jss::error_message] ==
1531 "Unneeded field 'taker_gets.issuer' "
1532 "for XRP currency specification.");
1533 }
1534 {
1535 json::Value jvParams;
1536 jvParams[jss::ledger_index] = "validated";
1537 jvParams[jss::taker_pays][jss::currency] = "USD";
1538 jvParams[jss::taker_pays][jss::issuer] = gw.human();
1539 jvParams[jss::taker_gets][jss::currency] = "EUR";
1540 jvParams[jss::taker_gets][jss::issuer] = gw.human();
1541 jvParams[jss::domain] = "badString";
1542 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1543 BEAST_EXPECT(jrr[jss::error] == "domainMalformed");
1544 BEAST_EXPECT(jrr[jss::error_code] == RpcDomainMalformed);
1545 BEAST_EXPECT(jrr[jss::error_message] == "Unable to parse domain.");
1546 }
1547 }
1548
1549 void
1551 {
1552 testcase("BookOffer Limits");
1553 using namespace jtx;
1554 Env env{*this, asAdmin ? envconfig() : envconfig(noAdmin)};
1555 Account const gw{"gw"};
1556 env.fund(XRP(200000), gw);
1557 // Note that calls to env.close() fail without admin permission.
1558 if (asAdmin)
1559 env.close();
1560
1561 auto const usd = gw["USD"];
1562
1563 for (auto i = 0; i <= rpc::tuning::kBookOffers.rmax; i++)
1564 env(offer(gw, XRP(50 + (1 * i)), usd(1.0 + (0.1 * i))));
1565
1566 if (asAdmin)
1567 env.close();
1568
1569 json::Value jvParams;
1570 jvParams[jss::limit] = 1;
1571 jvParams[jss::ledger_index] = "validated";
1572 jvParams[jss::taker_pays][jss::currency] = "XRP";
1573 jvParams[jss::taker_gets][jss::currency] = "USD";
1574 jvParams[jss::taker_gets][jss::issuer] = gw.human();
1575 auto jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1576 BEAST_EXPECT(jrr[jss::offers].isArray());
1577 BEAST_EXPECT(jrr[jss::offers].size() == (asAdmin ? 1u : 0u));
1578 // NOTE - a marker field is not returned for this method
1579
1580 jvParams[jss::limit] = rpc::tuning::kBookOffers.rmax + 1;
1581 jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1582 BEAST_EXPECT(jrr[jss::offers].isArray());
1583 BEAST_EXPECT(jrr[jss::offers].size() == (asAdmin ? rpc::tuning::kBookOffers.rmax + 1 : 0u));
1584
1585 jvParams[jss::limit] = json::ValueType::Null;
1586 jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1587 BEAST_EXPECT(jrr[jss::offers].isArray());
1588 BEAST_EXPECT(jrr[jss::offers].size() == (asAdmin ? rpc::tuning::kBookOffers.rDefault : 0u));
1589 }
1590
1591 void
1593 {
1594 testcase("BookOffer funded taker pays");
1595
1596 // Carol's offer is partially funded, and her funded TakerPays is
1597 // capped at TakerPays.
1598 using namespace jtx;
1599 Env env{*this};
1600 Account const gw{"gw"};
1601 Account const carol{"carol"};
1602 auto const usd = gw["USD"];
1603
1604 STAmount const carolPays{XRPAmount{static_cast<std::int64_t>(STAmount::kMaxNativeN)}};
1605 STAmount const carolGets{usd.issue(), UINT64_C(9'999'999'999'999'995), -15};
1606 STAmount const carolFunds{usd.issue(), UINT64_C(9'999'999'999'999'994), -15};
1607
1608 env.fund(XRP(10'000), gw, carol);
1609 env.close();
1610 env.trust(usd(1'000), carol);
1611 env.close();
1612 env(pay(gw, carol, carolFunds));
1613 env.close();
1614 env(offer(carol, carolPays, carolGets));
1615 env.close();
1616
1617 json::Value jvParams;
1618 jvParams[jss::ledger_index] = "validated";
1619 jvParams[jss::taker_pays][jss::currency] = "XRP";
1620 jvParams[jss::taker_gets][jss::currency] = "USD";
1621 jvParams[jss::taker_gets][jss::issuer] = gw.human();
1622 auto const jrr = env.rpc("json", "book_offers", to_string(jvParams))[jss::result];
1623 BEAST_EXPECT(!jrr.isMember(jss::error));
1624 if (!BEAST_EXPECT(jrr[jss::offers].isArray() && jrr[jss::offers].size() == 1))
1625 return;
1626
1627 auto const& jvOffer = jrr[jss::offers][0u];
1628 BEAST_EXPECT(
1629 jvOffer[jss::taker_gets_funded] == carolFunds.getJson(JsonOptions::Values::None));
1630 BEAST_EXPECT(
1631 jvOffer[jss::taker_pays_funded] == carolPays.getJson(JsonOptions::Values::None));
1632 }
1633
1634 void
1636 {
1637 testcase("TrackDomainOffer");
1638 using namespace jtx;
1639
1640 FeatureBitset const all{
1641 jtx::testableAmendments() | featurePermissionedDomains | featureCredentials |
1642 featurePermissionedDEX,
1643 };
1644
1645 Env env(*this, all);
1646 PermissionedDEX const permDex(env);
1647 auto const alice = permDex.alice;
1648 auto const bob = permDex.bob;
1649 auto const carol = permDex.carol;
1650 auto const domainID = permDex.domainID;
1651 auto const gw = permDex.gw;
1652 auto const usd = permDex.usd;
1653
1654 auto wsc = makeWSClient(env.app().config());
1655
1656 env(offer(alice, XRP(10), usd(10)), Domain(domainID));
1657 env.close();
1658
1659 auto const checkBookOffers = [&](json::Value const& jrr) {
1660 BEAST_EXPECT(jrr[jss::offers].isArray());
1661 BEAST_EXPECT(jrr[jss::offers].size() == 1);
1662 auto const jrOffer = jrr[jss::offers][0u];
1663 BEAST_EXPECT(jrOffer[sfAccount.fieldName] == alice.human());
1664 BEAST_EXPECT(
1665 jrOffer[sfBookDirectory.fieldName] == getBookDir(env, XRP, usd.issue(), domainID));
1666 BEAST_EXPECT(jrOffer[sfBookNode.fieldName] == "0");
1667 BEAST_EXPECT(jrOffer[jss::Flags] == 0);
1668 BEAST_EXPECT(jrOffer[sfLedgerEntryType.fieldName] == jss::Offer);
1669 BEAST_EXPECT(jrOffer[sfOwnerNode.fieldName] == "0");
1670 BEAST_EXPECT(
1671 jrOffer[jss::TakerGets] == usd(10).value().getJson(JsonOptions::Values::None));
1672 BEAST_EXPECT(
1673 jrOffer[jss::TakerPays] == XRP(10).value().getJson(JsonOptions::Values::None));
1674 BEAST_EXPECT(jrOffer[sfDomainID.jsonName].asString() == to_string(domainID));
1675 };
1676
1677 // book_offers: open book doesn't return offer
1678 {
1679 json::Value jvParams;
1680 jvParams[jss::taker] = env.master.human();
1681 jvParams[jss::taker_pays][jss::currency] = "XRP";
1682 jvParams[jss::ledger_index] = "validated";
1683 jvParams[jss::taker_gets][jss::currency] = "USD";
1684 jvParams[jss::taker_gets][jss::issuer] = gw.human();
1685
1686 auto jv = wsc->invoke("book_offers", jvParams);
1687 auto jrr = jv[jss::result];
1688 BEAST_EXPECT(jrr[jss::offers].isArray());
1689 BEAST_EXPECT(jrr[jss::offers].size() == 0);
1690 }
1691
1692 auto const checkSubBooks = [&](json::Value const& jv) {
1693 BEAST_EXPECT(
1694 jv[jss::result].isMember(jss::offers) && jv[jss::result][jss::offers].size() == 1);
1695 BEAST_EXPECT(
1696 jv[jss::result][jss::offers][0u][jss::TakerGets] ==
1697 usd(10).value().getJson(JsonOptions::Values::None));
1698 BEAST_EXPECT(
1699 jv[jss::result][jss::offers][0u][jss::TakerPays] ==
1701 BEAST_EXPECT(
1702 jv[jss::result][jss::offers][0u][sfDomainID.jsonName].asString() ==
1703 to_string(domainID));
1704 };
1705
1706 // book_offers: requesting domain book returns hybrid offer
1707 {
1708 json::Value jvParams;
1709 jvParams[jss::taker] = env.master.human();
1710 jvParams[jss::taker_pays][jss::currency] = "XRP";
1711 jvParams[jss::ledger_index] = "validated";
1712 jvParams[jss::taker_gets][jss::currency] = "USD";
1713 jvParams[jss::taker_gets][jss::issuer] = gw.human();
1714 jvParams[jss::domain] = to_string(domainID);
1715
1716 auto jv = wsc->invoke("book_offers", jvParams);
1717 auto const jrr = jv[jss::result];
1718 checkBookOffers(jrr);
1719 }
1720
1721 // subscribe to domain book should return domain offer
1722 {
1723 json::Value books;
1724 books[jss::books] = json::ValueType::Array;
1725 {
1726 auto& j = books[jss::books].append(json::ValueType::Object);
1727 j[jss::snapshot] = true;
1728 j[jss::taker_pays][jss::currency] = "XRP";
1729 j[jss::taker_gets][jss::currency] = "USD";
1730 j[jss::taker_gets][jss::issuer] = gw.human();
1731 j[jss::domain] = to_string(domainID);
1732 }
1733
1734 auto jv = wsc->invoke("subscribe", books);
1735 if (!BEAST_EXPECT(jv[jss::status] == "success"))
1736 return;
1737 checkSubBooks(jv);
1738 }
1739
1740 // subscribe to open book should not return domain offer
1741 {
1742 json::Value books;
1743 books[jss::books] = json::ValueType::Array;
1744 {
1745 auto& j = books[jss::books].append(json::ValueType::Object);
1746 j[jss::snapshot] = true;
1747 j[jss::taker_pays][jss::currency] = "XRP";
1748 j[jss::taker_gets][jss::currency] = "USD";
1749 j[jss::taker_gets][jss::issuer] = gw.human();
1750 }
1751
1752 auto jv = wsc->invoke("subscribe", books);
1753 if (!BEAST_EXPECT(jv[jss::status] == "success"))
1754 return;
1755 BEAST_EXPECT(
1756 jv[jss::result].isMember(jss::offers) && jv[jss::result][jss::offers].size() == 0);
1757 }
1758 }
1759
1760 void
1762 {
1763 testcase("TrackHybridOffer");
1764 using namespace jtx;
1765
1766 FeatureBitset const all{
1767 jtx::testableAmendments() | featurePermissionedDomains | featureCredentials |
1768 featurePermissionedDEX,
1769 };
1770
1771 Env env(*this, all);
1772 PermissionedDEX const permDex(env);
1773 auto const alice = permDex.alice;
1774 auto const bob = permDex.bob;
1775 auto const carol = permDex.carol;
1776 auto const domainID = permDex.domainID;
1777 auto const gw = permDex.gw;
1778 auto const usd = permDex.usd;
1779
1780 auto wsc = makeWSClient(env.app().config());
1781
1782 env(offer(alice, XRP(10), usd(10)), Domain(domainID), Txflags(tfHybrid));
1783 env.close();
1784
1785 auto const checkBookOffers = [&](json::Value const& jrr) {
1786 BEAST_EXPECT(jrr[jss::offers].isArray());
1787 BEAST_EXPECT(jrr[jss::offers].size() == 1);
1788 auto const jrOffer = jrr[jss::offers][0u];
1789 BEAST_EXPECT(jrOffer[sfAccount.fieldName] == alice.human());
1790 BEAST_EXPECT(
1791 jrOffer[sfBookDirectory.fieldName] == getBookDir(env, XRP, usd.issue(), domainID));
1792 BEAST_EXPECT(jrOffer[sfBookNode.fieldName] == "0");
1793 BEAST_EXPECT(jrOffer[jss::Flags] == lsfHybrid);
1794 BEAST_EXPECT(jrOffer[sfLedgerEntryType.fieldName] == jss::Offer);
1795 BEAST_EXPECT(jrOffer[sfOwnerNode.fieldName] == "0");
1796 BEAST_EXPECT(
1797 jrOffer[jss::TakerGets] == usd(10).value().getJson(JsonOptions::Values::None));
1798 BEAST_EXPECT(
1799 jrOffer[jss::TakerPays] == XRP(10).value().getJson(JsonOptions::Values::None));
1800 BEAST_EXPECT(jrOffer[sfDomainID.jsonName].asString() == to_string(domainID));
1801 BEAST_EXPECT(jrOffer[sfAdditionalBooks.jsonName].size() == 1);
1802 };
1803
1804 // book_offers: open book returns hybrid offer
1805 {
1806 json::Value jvParams;
1807 jvParams[jss::taker] = env.master.human();
1808 jvParams[jss::taker_pays][jss::currency] = "XRP";
1809 jvParams[jss::ledger_index] = "validated";
1810 jvParams[jss::taker_gets][jss::currency] = "USD";
1811 jvParams[jss::taker_gets][jss::issuer] = gw.human();
1812
1813 auto jv = wsc->invoke("book_offers", jvParams);
1814 auto const jrr = jv[jss::result];
1815 checkBookOffers(jrr);
1816 }
1817
1818 auto const checkSubBooks = [&](json::Value const& jv) {
1819 BEAST_EXPECT(
1820 jv[jss::result].isMember(jss::offers) && jv[jss::result][jss::offers].size() == 1);
1821 BEAST_EXPECT(
1822 jv[jss::result][jss::offers][0u][jss::TakerGets] ==
1823 usd(10).value().getJson(JsonOptions::Values::None));
1824 BEAST_EXPECT(
1825 jv[jss::result][jss::offers][0u][jss::TakerPays] ==
1827 BEAST_EXPECT(
1828 jv[jss::result][jss::offers][0u][sfDomainID.jsonName].asString() ==
1829 to_string(domainID));
1830 };
1831
1832 // book_offers: requesting domain book returns hybrid offer
1833 {
1834 json::Value jvParams;
1835 jvParams[jss::taker] = env.master.human();
1836 jvParams[jss::taker_pays][jss::currency] = "XRP";
1837 jvParams[jss::ledger_index] = "validated";
1838 jvParams[jss::taker_gets][jss::currency] = "USD";
1839 jvParams[jss::taker_gets][jss::issuer] = gw.human();
1840 jvParams[jss::domain] = to_string(domainID);
1841
1842 auto jv = wsc->invoke("book_offers", jvParams);
1843 auto const jrr = jv[jss::result];
1844 checkBookOffers(jrr);
1845 }
1846
1847 // subscribe to domain book should return hybrid offer
1848 {
1849 json::Value books;
1850 books[jss::books] = json::ValueType::Array;
1851 {
1852 auto& j = books[jss::books].append(json::ValueType::Object);
1853 j[jss::snapshot] = true;
1854 j[jss::taker_pays][jss::currency] = "XRP";
1855 j[jss::taker_gets][jss::currency] = "USD";
1856 j[jss::taker_gets][jss::issuer] = gw.human();
1857 j[jss::domain] = to_string(domainID);
1858 }
1859
1860 auto jv = wsc->invoke("subscribe", books);
1861 if (!BEAST_EXPECT(jv[jss::status] == "success"))
1862 return;
1863 checkSubBooks(jv);
1864
1865 // RPC unsubscribe
1866 auto unsubJv = wsc->invoke("unsubscribe", books);
1867 if (wsc->version() == 2)
1868 BEAST_EXPECT(unsubJv[jss::status] == "success");
1869 }
1870
1871 // subscribe to open book should return hybrid offer
1872 {
1873 json::Value books;
1874 books[jss::books] = json::ValueType::Array;
1875 {
1876 auto& j = books[jss::books].append(json::ValueType::Object);
1877 j[jss::snapshot] = true;
1878 j[jss::taker_pays][jss::currency] = "XRP";
1879 j[jss::taker_gets][jss::currency] = "USD";
1880 j[jss::taker_gets][jss::issuer] = gw.human();
1881 }
1882
1883 auto jv = wsc->invoke("subscribe", books);
1884 if (!BEAST_EXPECT(jv[jss::status] == "success"))
1885 return;
1886 checkSubBooks(jv);
1887 }
1888 }
1889
1890 void
1911};
1912
1914
1915} // namespace xrpl::test
A testsuite class.
Definition suite.h:52
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
Represents a JSON value.
Definition json_value.h:121
Value & append(Value const &value)
Append value to array at the end.
virtual Config & config()=0
Specifies an order book.
Definition Book.h:28
A currency issued by an account.
Definition Issue.h:18
static constexpr std::uint64_t kMaxNativeN
Definition STAmount.h:72
json::Value getJson(JsonOptions=JsonOptions::Values::None) const override
void testMultipleBooksOneSideEmptyBook()
static std::string getBookDir(jtx::Env &env, Issue const &in, Issue const &out, std::optional< UInt256 > const &domain=std::nullopt)
Definition Book_test.cpp:46
void testBookOfferFundedTakerPays()
void testBookOfferLimits(bool asAdmin)
void testMultipleBooksOneSideOffersInBook()
void testMultipleBooksBothSidesOffersInBook()
void testMultipleBooksBothSidesEmptyBook()
static bool offerOnlyOnceInStream(std::unique_ptr< WSClient > const &wsc, std::chrono::milliseconds const &timeout, jtx::PrettyAmount const &takerGets, jtx::PrettyAmount const &takerPays)
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.
A transaction testing environment.
Definition Env.h:161
Application & app()
Definition Env.h:300
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
Definition Env.cpp:133
std::shared_ptr< ReadView const > closed()
Returns the last closed ledger.
Definition Env.cpp:127
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
Definition Env.cpp:323
Account const & master
Definition Env.h:165
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
void trust(STAmount const &amount, Account const &account)
Establish trust lines.
Definition Env.cpp:354
void require(Args const &... args)
Check a set of requirements.
Definition Env.h:766
Match the number of items in the account's owner directory.
Definition owners.h:55
Check a set of conditions.
Definition require.h:49
Set the flags on a JTx.
Definition txflags.h:14
@ 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
Keylet offer(AccountID const &id, SeqProxy const &seq) noexcept
An offer from an account.
Definition Indexes.cpp:310
Keylet page(UInt256 const &root, std::uint64_t const index=0) noexcept
A page in a directory.
Definition Indexes.cpp:421
static constexpr LimitRange kBookOffers
Limits for the book_offers command.
The api_version numbers this server serves.
Definition ApiVersion.h:26
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
bool hasEnvelope2(json::Value const &reply)
Reports whether reply carries the version 2 envelope: jsonrpc equal to rpc::kJsonRpcVersion and rippl...
FeatureBitset testableAmendments()
Definition Env.h:92
OwnerCount< ltOFFER > Offers
Match the number of offers in the account's owner directory.
Definition owners.h:137
json::Value offer(Account const &account, STAmount const &takerPays, STAmount const &takerGets, std::uint32_t flags)
Create an offer.
Definition offer.cpp:14
std::unique_ptr< Config > envconfig()
creates and initializes a default configuration for jtx::Env
Definition envconfig.h:38
json::Value trust(Account const &account, STAmount const &amount, std::uint32_t flags)
Modify a trust line.
Definition trust.cpp:18
std::unique_ptr< Config > noAdmin(std::unique_ptr< Config >)
adjust config so no admin ports are enabled
Definition envconfig.cpp:76
json::Value rate(Account const &account, double multiplier)
Set a transfer rate.
Definition rate.cpp:15
constexpr XRPAmount
Convert XRP to drops (integral types).
Definition TxTest.h:53
BEAST_DEFINE_TESTSUITE_PRIO(AccountDelete, app, xrpl, 2)
std::unique_ptr< WSClient > makeWSClient(Config const &cfg, bool v2, unsigned rpcVersion, std::unordered_map< std::string, std::string > const &headers)
Returns a client operating through WebSockets/S.
Definition WSClient.cpp:373
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
bool cdirFirst(ReadView const &view, UInt256 const &root, SLE::const_pointer &page, unsigned int &index, UInt256 &entry)
Returns the first entry in the directory, advancing the index.
@ RpcDstAmtMalformed
Definition ErrorCodes.h:89
@ RpcLgrNotFound
Definition ErrorCodes.h:55
@ RpcBadMarket
Definition ErrorCodes.h:80
@ RpcDomainMalformed
Definition ErrorCodes.h:141
@ RpcSrcCurMalformed
Definition ErrorCodes.h:107
@ RpcInvalidParams
Definition ErrorCodes.h:67
@ RpcSrcIsrMalformed
Definition ErrorCodes.h:108
@ RpcDstIsrMalformed
Definition ErrorCodes.h:91
UInt256 getBookBase(Book const &book)
Definition Indexes.cpp:136
BaseUInt< 256 > Domain
Domain is a 256-bit hash representing a specific domain.
Definition UintTypes.h:59
std::string toBase58(AccountID const &v)
Convert AccountID to base58 checked string.
Definition AccountID.cpp:95
UInt256 getQualityNext(UInt256 const &uBase)
Definition Indexes.cpp:199
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
BaseUInt< 256 > UInt256
Definition base_uint.h:581
json::Value getJson(LedgerFill const &fill)
Return a new json::Value representing the ledger with given options.
AccountID const & noAccount()
A placeholder for empty accounts.
AccountID const & xrpAccount()
Compute AccountID from public key.
Represents an XRP, IOU, or MPT quantity This customizes the string conversion and supports XRP conver...
STAmount const & value() const