xrpld
Loading...
Searching...
No Matches
Oracle_test.cpp
1#include <test/jtx/Account.h>
2#include <test/jtx/Env.h>
3#include <test/jtx/Oracle.h>
4#include <test/jtx/TestHelpers.h>
5#include <test/jtx/acctdelete.h>
6#include <test/jtx/amount.h>
7#include <test/jtx/fee.h>
8#include <test/jtx/flags.h>
9#include <test/jtx/multisign.h>
10#include <test/jtx/owners.h>
11#include <test/jtx/regkey.h>
12#include <test/jtx/seq.h>
13#include <test/jtx/sig.h>
14#include <test/jtx/tags.h>
15#include <test/jtx/ter.h>
16
17#include <xrpl/basics/base_uint.h>
18#include <xrpl/basics/chrono.h>
19#include <xrpl/beast/unit_test/suite.h>
20#include <xrpl/json/to_string.h>
21#include <xrpl/protocol/Feature.h>
22#include <xrpl/protocol/Indexes.h>
23#include <xrpl/protocol/KeyType.h>
24#include <xrpl/protocol/Protocol.h>
25#include <xrpl/protocol/SField.h>
26#include <xrpl/protocol/TER.h>
27#include <xrpl/protocol/TxFlags.h>
28#include <xrpl/protocol/jss.h>
29
30#include <chrono>
31#include <cstdint>
32#include <optional>
33
35
37{
38private:
39 void
41 {
42 testcase("Invalid Set");
43
44 using namespace jtx;
45 Account const owner("owner");
46
47 {
48 // Invalid account
49 Env env(*this);
50 Account const bad("bad");
51 env.memoize(bad);
52 Oracle const oracle(
53 env,
54 {
55 .owner = bad,
56 .seq = Seq(1),
57 .fee = static_cast<int>(env.current()->fees().base.drops()),
58 .err = Ter(terNO_ACCOUNT),
59 });
60 }
61
62 // Insufficient reserve
63 {
64 Env env(*this);
65 env.fund(env.current()->fees().accountReserve(0, 1), owner);
66 Oracle const oracle(
67 env,
68 {
69 .owner = owner,
70 .fee = static_cast<int>(env.current()->fees().base.drops()),
72 });
73 }
74 // Insufficient reserve if the data series extends to greater than 5
75 {
76 Env env(*this);
77 env.fund(
78 env.current()->fees().accountReserve(1, 1) + env.current()->fees().base * 2, owner);
80 env, {.owner = owner, .fee = static_cast<int>(env.current()->fees().base.drops())});
81 BEAST_EXPECT(oracle.exists());
82 oracle.set(
84 .series =
85 {
86 {"XRP", "EUR", 740, 1},
87 {"XRP", "GBP", 740, 1},
88 {"XRP", "CNY", 740, 1},
89 {"XRP", "CAD", 740, 1},
90 {"XRP", "AUD", 740, 1},
91 },
92 .fee = static_cast<int>(env.current()->fees().base.drops()),
94 });
95 }
96
97 {
98 Env env(*this);
99 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
100 env.fund(XRP(1'000), owner);
101 Oracle oracle(env, {.owner = owner, .fee = baseFee}, false);
102
103 // Invalid flag
104 oracle.set(
105 CreateArg{.flags = tfSellNFToken, .fee = baseFee, .err = Ter(temINVALID_FLAG)});
106
107 // Duplicate token pair
108 oracle.set(
109 CreateArg{
110 .series = {{"XRP", "USD", 740, 1}, {"XRP", "USD", 750, 1}},
111 .fee = baseFee,
112 .err = Ter(temMALFORMED),
113 });
114
115 // Price is not included
116 oracle.set(
117 CreateArg{
118 .series = {{"XRP", "USD", 740, 1}, {"XRP", "EUR", std::nullopt, 1}},
119 .fee = baseFee,
120 .err = Ter(temMALFORMED),
121 });
122
123 // Token pair is in update and delete
124 oracle.set(
125 CreateArg{
126 .series = {{"XRP", "USD", 740, 1}, {"XRP", "USD", std::nullopt, 1}},
127 .fee = baseFee,
128 .err = Ter(temMALFORMED),
129 });
130 // Token pair is in add and delete
131 oracle.set(
132 CreateArg{
133 .series = {{"XRP", "EUR", 740, 1}, {"XRP", "EUR", std::nullopt, 1}},
134 .fee = baseFee,
135 .err = Ter(temMALFORMED),
136 });
137
138 // Array of token pair is 0 or exceeds 10
139 oracle.set(
140 CreateArg{
141 .series =
142 {
143 {"XRP", "US1", 740, 1},
144 {"XRP", "US2", 750, 1},
145 {"XRP", "US3", 740, 1},
146 {"XRP", "US4", 750, 1},
147 {"XRP", "US5", 740, 1},
148 {"XRP", "US6", 750, 1},
149 {"XRP", "US7", 740, 1},
150 {"XRP", "US8", 750, 1},
151 {"XRP", "US9", 740, 1},
152 {"XRP", "U10", 750, 1},
153 {"XRP", "U11", 740, 1},
154 },
155 .fee = baseFee,
156 .err = Ter(temARRAY_TOO_LARGE),
157 });
158 oracle.set(CreateArg{.series = {}, .fee = baseFee, .err = Ter(temARRAY_EMPTY)});
159 }
160
161 // Array of token pair exceeds 10 after update
162 {
163 Env env{*this};
164 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
165 env.fund(XRP(1'000), owner);
166
168 env,
169 CreateArg{.owner = owner, .series = {{{"XRP", "USD", 740, 1}}}, .fee = baseFee});
170 oracle.set(
171 UpdateArg{
172 .series =
173 {
174 {"XRP", "US1", 740, 1},
175 {"XRP", "US2", 750, 1},
176 {"XRP", "US3", 740, 1},
177 {"XRP", "US4", 750, 1},
178 {"XRP", "US5", 740, 1},
179 {"XRP", "US6", 750, 1},
180 {"XRP", "US7", 740, 1},
181 {"XRP", "US8", 750, 1},
182 {"XRP", "US9", 740, 1},
183 {"XRP", "U10", 750, 1},
184 },
185 .fee = baseFee,
186 .err = Ter(tecARRAY_TOO_LARGE),
187 });
188 }
189
190 {
191 Env env(*this);
192 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
193 env.fund(XRP(1'000), owner);
194 Oracle oracle(env, {.owner = owner, .fee = baseFee}, false);
195
196 // Asset class or provider not included on create
197 oracle.set(
198 CreateArg{
199 .assetClass = std::nullopt,
200 .provider = "provider",
201 .fee = baseFee,
202 .err = Ter(temMALFORMED),
203 });
204 oracle.set(
205 CreateArg{
206 .assetClass = "currency",
207 .provider = std::nullopt,
208 .uri = "URI",
209 .fee = baseFee,
210 .err = Ter(temMALFORMED),
211 });
212
213 // Asset class or provider are included on update
214 // and don't match the current values
215 oracle.set(CreateArg{.fee = static_cast<int>(env.current()->fees().base.drops())});
216 BEAST_EXPECT(oracle.exists());
217 oracle.set(
218 UpdateArg{
219 .series = {{"XRP", "USD", 740, 1}},
220 .provider = "provider1",
221 .fee = baseFee,
222 .err = Ter(temMALFORMED),
223 });
224 oracle.set(
225 UpdateArg{
226 .series = {{"XRP", "USD", 740, 1}},
227 .assetClass = "currency1",
228 .fee = baseFee,
229 .err = Ter(temMALFORMED),
230 });
231 }
232
233 {
234 Env env(*this);
235 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
236 env.fund(XRP(1'000), owner);
237 Oracle oracle(env, {.owner = owner, .fee = baseFee}, false);
238
239 // Fields too long
240 // Asset class
241 std::string assetClass(17, '0');
242 oracle.set(
243 CreateArg{.assetClass = assetClass, .fee = baseFee, .err = Ter(temMALFORMED)});
244 // provider
245 std::string const large(257, '0');
246 oracle.set(CreateArg{.provider = large, .fee = baseFee, .err = Ter(temMALFORMED)});
247 // URI
248 oracle.set(CreateArg{.uri = large, .fee = baseFee, .err = Ter(temMALFORMED)});
249 // Empty field
250 // Asset class
251 oracle.set(CreateArg{.assetClass = "", .fee = baseFee, .err = Ter(temMALFORMED)});
252 // provider
253 oracle.set(CreateArg{.provider = "", .fee = baseFee, .err = Ter(temMALFORMED)});
254 // URI
255 oracle.set(CreateArg{.uri = "", .fee = baseFee, .err = Ter(temMALFORMED)});
256 }
257
258 {
259 // Different owner creates a new object and fails because
260 // of missing fields currency/provider
261 Env env(*this);
262 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
263 Account const some("some");
264 env.fund(XRP(1'000), owner);
265 env.fund(XRP(1'000), some);
266 Oracle oracle(env, {.owner = owner, .fee = baseFee});
267 BEAST_EXPECT(oracle.exists());
268 oracle.set(
269 UpdateArg{
270 .owner = some,
271 .series = {{"XRP", "USD", 740, 1}},
272 .fee = baseFee,
273 .err = Ter(temMALFORMED),
274 });
275 }
276
277 {
278 // Invalid update time
279 using namespace std::chrono;
280 Env env(*this);
281 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
282 auto const closeTime = [&] {
284 env.current()->header().closeTime.time_since_epoch() - 10'000s)
285 .count();
286 };
287 env.fund(XRP(1'000), owner);
288 Oracle oracle(env, {.owner = owner, .fee = baseFee});
289 BEAST_EXPECT(oracle.exists());
290 env.close(seconds(400));
291 // Less than the last close time - 300s
292 oracle.set(
293 UpdateArg{
294 .series = {{"XRP", "USD", 740, 1}},
295 .lastUpdateTime = static_cast<std::uint32_t>(closeTime() - 301),
296 .fee = baseFee,
298 });
299 // Greater than last close time + 300s
300 oracle.set(
301 UpdateArg{
302 .series = {{"XRP", "USD", 740, 1}},
303 .lastUpdateTime = static_cast<std::uint32_t>(closeTime() + 311),
304 .fee = baseFee,
306 });
307 oracle.set(UpdateArg{.series = {{"XRP", "USD", 740, 1}}, .fee = baseFee});
308 BEAST_EXPECT(oracle.expectLastUpdateTime(
309 static_cast<std::uint32_t>(kTestStartTime.count() + 450)));
310 // Less than the previous lastUpdateTime
311 oracle.set(
312 UpdateArg{
313 .series = {{"XRP", "USD", 740, 1}},
314 .lastUpdateTime = static_cast<std::uint32_t>(449),
315 .fee = baseFee,
317 });
318 // Less than the epoch time
319 oracle.set(
320 UpdateArg{
321 .series = {{"XRP", "USD", 740, 1}},
322 .lastUpdateTime = static_cast<int>(kEpochOffset.count() - 1),
323 .fee = baseFee,
325 });
326 }
327
328 {
329 // delete token pair that doesn't exist
330 Env env(*this);
331 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
332 env.fund(XRP(1'000), owner);
333 Oracle oracle(env, {.owner = owner, .fee = baseFee});
334 BEAST_EXPECT(oracle.exists());
335 oracle.set(
336 UpdateArg{
337 .series = {{"XRP", "EUR", std::nullopt, std::nullopt}},
338 .fee = baseFee,
340 });
341 // delete all token pairs
342 oracle.set(
343 UpdateArg{
344 .series = {{"XRP", "USD", std::nullopt, std::nullopt}},
345 .fee = baseFee,
346 .err = Ter(tecARRAY_EMPTY),
347 });
348 }
349
350 {
351 // same BaseAsset and QuoteAsset
352 Env env(*this);
353 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
354 env.fund(XRP(1'000), owner);
355 Oracle const oracle(
356 env,
357 {
358 .owner = owner,
359 .series = {{"USD", "USD", 740, 1}},
360 .fee = baseFee,
361 .err = Ter(temMALFORMED),
362 });
363 }
364
365 {
366 // Scale is greater than maxPriceScale
367 Env env(*this);
368 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
369 env.fund(XRP(1'000), owner);
370 Oracle const oracle(
371 env,
372 {
373 .owner = owner,
374 .series = {{"USD", "BTC", 740, kMaxPriceScale + 1}},
375 .fee = baseFee,
376 .err = Ter(temMALFORMED),
377 });
378 }
379
380 {
381 // Updating token pair to add and delete
382 Env env(*this);
383 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
384 env.fund(XRP(1'000), owner);
385 Oracle oracle(env, {.owner = owner, .fee = baseFee});
386 oracle.set(
387 UpdateArg{
388 .series = {{"XRP", "EUR", std::nullopt, std::nullopt}, {"XRP", "EUR", 740, 1}},
389 .fee = baseFee,
390 .err = Ter(temMALFORMED),
391 });
392 // Delete token pair that doesn't exist in this oracle
393 oracle.set(
394 UpdateArg{
395 .series = {{"XRP", "EUR", std::nullopt, std::nullopt}},
396 .fee = baseFee,
398 });
399 // Delete token pair in oracle, which is not in the ledger
400 oracle.set(
401 UpdateArg{
402 .documentID = 10,
403 .series = {{"XRP", "EUR", std::nullopt, std::nullopt}},
404 .fee = baseFee,
405 .err = Ter(temMALFORMED),
406 });
407 }
408
409 {
410 // Bad fee
411 Env env(*this);
412 env.fund(XRP(1'000), owner);
413 Oracle oracle(env, {.owner = owner, .fee = -1, .err = Ter(temBAD_FEE)});
414 Oracle const oracle1(
415 env, {.owner = owner, .fee = static_cast<int>(env.current()->fees().base.drops())});
416 oracle.set(UpdateArg{.owner = owner, .fee = -1, .err = Ter(temBAD_FEE)});
417 }
418 }
419
420 void
422 {
423 testcase("Create");
424 using namespace jtx;
425 Account const owner("owner");
426
427 auto const test = [&](Env& env, DataSeries const& series, std::uint16_t adj) {
428 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
429 env.fund(XRP(1'000), owner);
430 auto const count = ownerCount(env, owner);
431 Oracle const oracle(env, {.owner = owner, .series = series, .fee = baseFee});
432 BEAST_EXPECT(oracle.exists());
433 BEAST_EXPECT(ownerCount(env, owner) == (count + adj));
434 auto const entry = oracle.ledgerEntry();
435 BEAST_EXPECT(entry[jss::node][jss::Owner] == owner.human());
436 if (features[fixIncludeKeyletFields])
437 {
438 BEAST_EXPECT(entry[jss::node][jss::OracleDocumentID] == oracle.documentID());
439 }
440 else
441 {
442 BEAST_EXPECT(!entry[jss::node].isMember(jss::OracleDocumentID));
443 }
444 BEAST_EXPECT(oracle.expectLastUpdateTime(946694810));
445 };
446
447 {
448 // owner count is adjusted by 1
449 Env env(*this, features);
450 test(env, {{"XRP", "USD", 740, 1}}, 1);
451 }
452
453 {
454 // owner count is adjusted by 2
455 Env env(*this, features);
456 test(
457 env,
458 {
459 {"XRP", "USD", 740, 1},
460 {"BTC", "USD", 740, 1},
461 {"ETH", "USD", 740, 1},
462 {"CAN", "USD", 740, 1},
463 {"YAN", "USD", 740, 1},
464 {"GBP", "USD", 740, 1},
465 },
466 2);
467 }
468
469 {
470 // Different owner creates a new object
471 Env env(*this, features);
472 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
473 Account const some("some");
474 env.fund(XRP(1'000), owner);
475 env.fund(XRP(1'000), some);
476 Oracle oracle(env, {.owner = owner, .fee = baseFee});
477 BEAST_EXPECT(oracle.exists());
478 oracle.set(
479 CreateArg{.owner = some, .series = {{"912810RR9", "USD", 740, 1}}, .fee = baseFee});
480 BEAST_EXPECT(Oracle::exists(env, some, oracle.documentID()));
481 }
482 }
483
484 void
486 {
487 testcase("Invalid Delete");
488
489 using namespace jtx;
490 Env env(*this);
491 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
492 Account const owner("owner");
493 env.fund(XRP(1'000), owner);
494 Oracle oracle(env, {.owner = owner, .fee = baseFee});
495 BEAST_EXPECT(oracle.exists());
496
497 {
498 // Invalid account
499 Account const bad("bad");
500 env.memoize(bad);
501 oracle.remove({.owner = bad, .seq = Seq(1), .fee = baseFee, .err = Ter(terNO_ACCOUNT)});
502 }
503
504 // Invalid DocumentID
505 oracle.remove({.documentID = 2, .fee = baseFee, .err = Ter(tecNO_ENTRY)});
506
507 // Invalid owner
508 Account const invalid("invalid");
509 env.fund(XRP(1'000), invalid);
510 oracle.remove({.owner = invalid, .fee = baseFee, .err = Ter(tecNO_ENTRY)});
511
512 // Invalid flags
513 oracle.remove({.flags = tfSellNFToken, .fee = baseFee, .err = Ter(temINVALID_FLAG)});
514
515 // Bad fee
516 oracle.remove({.fee = -1, .err = Ter(temBAD_FEE)});
517 }
518
519 void
521 {
522 testcase("Delete");
523 using namespace jtx;
524 Account const owner("owner");
525
526 auto const test = [&](Env& env, DataSeries const& series, std::uint16_t adj) {
527 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
528 env.fund(XRP(1'000), owner);
529 Oracle oracle(env, {.owner = owner, .series = series, .fee = baseFee});
530 auto const count = ownerCount(env, owner);
531 BEAST_EXPECT(oracle.exists());
532 oracle.remove({.fee = baseFee});
533 BEAST_EXPECT(!oracle.exists());
534 BEAST_EXPECT(ownerCount(env, owner) == (count - adj));
535 };
536
537 {
538 // owner count is adjusted by 1
539 Env env(*this);
540 test(env, {{"XRP", "USD", 740, 1}}, 1);
541 }
542
543 {
544 // owner count is adjusted by 2
545 Env env(*this);
546 test(
547 env,
548 {
549 {"XRP", "USD", 740, 1},
550 {"BTC", "USD", 740, 1},
551 {"ETH", "USD", 740, 1},
552 {"CAN", "USD", 740, 1},
553 {"YAN", "USD", 740, 1},
554 {"GBP", "USD", 740, 1},
555 },
556 2);
557 }
558
559 {
560 // deleting the account deletes the oracles
561 Env env(*this);
562 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
563
564 auto const alice = Account("alice");
565 auto const acctDelFee{drops(env.current()->fees().increment)};
566 env.fund(XRP(1'000), owner);
567 env.fund(XRP(1'000), alice);
568 Oracle const oracle(
569 env, {.owner = owner, .series = {{"XRP", "USD", 740, 1}}, .fee = baseFee});
570 Oracle const oracle1(
571 env,
572 {
573 .owner = owner,
574 .documentID = 2,
575 .series = {{"XRP", "EUR", 740, 1}},
576 .fee = baseFee,
577 });
578 BEAST_EXPECT(ownerCount(env, owner) == 2);
579 BEAST_EXPECT(oracle.exists());
580 BEAST_EXPECT(oracle1.exists());
581 auto const index = env.closed()->seq();
582 auto const hash = env.closed()->header().hash;
583 for (int i = 0; i < 256; ++i)
584 env.close();
585 env(acctdelete(owner, alice), Fee(acctDelFee));
586 env.close();
587 BEAST_EXPECT(!oracle.exists());
588 BEAST_EXPECT(!oracle1.exists());
589
590 // can still get the oracles via the ledger index or hash
591 auto const verifyLedgerData = [&](auto const& field, auto const& value) {
592 json::Value jvParams;
593 jvParams[field] = value;
594 jvParams[jss::binary] = false;
595 jvParams[jss::type] = jss::oracle;
596 json::Value jrr = env.rpc("json", "ledger_data", to_string(jvParams));
597 BEAST_EXPECT(jrr[jss::result][jss::state].size() == 2);
598 };
599 verifyLedgerData(jss::ledger_index, index);
600 verifyLedgerData(jss::ledger_hash, to_string(hash));
601 }
602 }
603
604 void
606 {
607 testcase("Update");
608 using namespace jtx;
609 Account const owner("owner");
610
611 {
612 Env env(*this);
613 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
614 env.fund(XRP(1'000), owner);
615 auto count = ownerCount(env, owner);
616 Oracle oracle(env, {.owner = owner, .fee = baseFee});
617 BEAST_EXPECT(oracle.exists());
618
619 // update existing pair
620 oracle.set(UpdateArg{.series = {{"XRP", "USD", 740, 2}}, .fee = baseFee});
621 BEAST_EXPECT(oracle.expectPrice({{"XRP", "USD", 740, 2}}));
622 // owner count is increased by 1 since the oracle object is added
623 // with one token pair
624 count += 1;
625 BEAST_EXPECT(ownerCount(env, owner) == count);
626
627 // add new pairs, not-included pair is reset
628 oracle.set(UpdateArg{.series = {{"XRP", "EUR", 700, 2}}, .fee = baseFee});
629 BEAST_EXPECT(oracle.expectPrice({{"XRP", "USD", 0, 0}, {"XRP", "EUR", 700, 2}}));
630 // owner count is not changed since the number of pairs is 2
631 BEAST_EXPECT(ownerCount(env, owner) == count);
632
633 // update both pairs
634 oracle.set(
635 UpdateArg{
636 .series = {{"XRP", "USD", 741, 2}, {"XRP", "EUR", 710, 2}},
637 .fee = baseFee,
638 });
639 BEAST_EXPECT(oracle.expectPrice({{"XRP", "USD", 741, 2}, {"XRP", "EUR", 710, 2}}));
640 // owner count is not changed since the number of pairs is 2
641 BEAST_EXPECT(ownerCount(env, owner) == count);
642
643 // owner count is increased by 1 since the number of pairs is 6
644 oracle.set(
645 UpdateArg{
646 .series =
647 {
648 {"BTC", "USD", 741, 2},
649 {"ETH", "EUR", 710, 2},
650 {"YAN", "EUR", 710, 2},
651 {"CAN", "EUR", 710, 2},
652 },
653 .fee = baseFee,
654 });
655 count += 1;
656 BEAST_EXPECT(ownerCount(env, owner) == count);
657
658 // update two pairs and delete four
659 oracle.set(
660 UpdateArg{.series = {{"BTC", "USD", std::nullopt, std::nullopt}}, .fee = baseFee});
661 oracle.set(
662 UpdateArg{
663 .series =
664 {
665 {"XRP", "USD", 742, 2},
666 {"XRP", "EUR", 711, 2},
667 {"ETH", "EUR", std::nullopt, std::nullopt},
668 {"YAN", "EUR", std::nullopt, std::nullopt},
669 {"CAN", "EUR", std::nullopt, std::nullopt},
670 },
671 .fee = baseFee,
672 });
673 BEAST_EXPECT(oracle.expectPrice({{"XRP", "USD", 742, 2}, {"XRP", "EUR", 711, 2}}));
674 // owner count is decreased by 1 since the number of pairs is 2
675 count -= 1;
676 BEAST_EXPECT(ownerCount(env, owner) == count);
677 }
678
679 // Min reserve to create and update
680 {
681 Env env(*this);
682 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
683 env.fund(
684 env.current()->fees().accountReserve(1, 1) + env.current()->fees().base * 2, owner);
685 Oracle oracle(env, {.owner = owner, .fee = baseFee});
686 oracle.set(UpdateArg{.series = {{"XRP", "USD", 742, 2}}, .fee = baseFee});
687 }
688
689 for (bool const withFixOrder : {false, true})
690 {
691 // Should be same order as creation
692 Env env(
693 *this,
694 withFixOrder ? testableAmendments() : testableAmendments() - fixPriceOracleOrder);
695 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
696
697 auto const test = [&](Env& env, DataSeries const& series) {
698 env.fund(XRP(1'000), owner);
699 Oracle oracle(env, {.owner = owner, .series = series, .fee = baseFee});
700 BEAST_EXPECT(oracle.exists());
701 auto sle = env.le(keylet::oracle(owner, oracle.documentID()));
702 BEAST_EXPECT(sle->getFieldArray(sfPriceDataSeries).size() == series.size());
703
704 auto const beforeQuoteAssetName1 = sle->getFieldArray(sfPriceDataSeries)[0]
705 .getFieldCurrency(sfQuoteAsset)
706 .getText();
707 auto const beforeQuoteAssetName2 = sle->getFieldArray(sfPriceDataSeries)[1]
708 .getFieldCurrency(sfQuoteAsset)
709 .getText();
710
711 oracle.set(UpdateArg{.series = series, .fee = baseFee});
712 sle = env.le(keylet::oracle(owner, oracle.documentID()));
713
714 auto const afterQuoteAssetName1 = sle->getFieldArray(sfPriceDataSeries)[0]
715 .getFieldCurrency(sfQuoteAsset)
716 .getText();
717 auto const afterQuoteAssetName2 = sle->getFieldArray(sfPriceDataSeries)[1]
718 .getFieldCurrency(sfQuoteAsset)
719 .getText();
720
721 if (env.current()->rules().enabled(fixPriceOracleOrder))
722 {
723 BEAST_EXPECT(afterQuoteAssetName1 == beforeQuoteAssetName1);
724 BEAST_EXPECT(afterQuoteAssetName2 == beforeQuoteAssetName2);
725 }
726 else
727 {
728 BEAST_EXPECT(afterQuoteAssetName1 != beforeQuoteAssetName1);
729 BEAST_EXPECT(afterQuoteAssetName2 != beforeQuoteAssetName2);
730 }
731 };
732 test(env, {{"XRP", "USD", 742, 2}, {"XRP", "EUR", 711, 2}});
733 }
734 }
735
736 void
738 {
739 testcase("Multisig");
740 using namespace jtx;
741 Oracle::setFee(100'000);
742
743 Env env(*this);
744 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
745
746 Account const alice{"alice", KeyType::Secp256k1};
747 Account const bogie{"bogie", KeyType::Secp256k1};
748 Account const ed{"ed", KeyType::Secp256k1};
749 Account const becky{"becky", KeyType::Ed25519};
750 Account const zelda{"zelda", KeyType::Secp256k1};
751 Account const bob{"bob", KeyType::Secp256k1};
752 env.fund(XRP(10'000), alice, becky, zelda, ed, bob);
753
754 // alice uses a regular key with the master disabled.
755 Account const alie{"alie", KeyType::Secp256k1};
756 env(regkey(alice, alie));
757 env(fset(alice, asfDisableMaster), Sig(alice));
758
759 // Attach signers to alice.
760 env(signers(alice, 2, {{becky, 1}, {bogie, 1}, {ed, 2}}), Sig(alie));
761 env.close();
762
763 env.require(Owners(alice, 1));
764
765 // Create
766 // Force close (true) and time advancement because the close time
767 // is no longer 0.
768 Oracle oracle(env, CreateArg{.owner = alice, .fee = baseFee, .close = true}, false);
769 oracle.set(CreateArg{.msig = Msig(becky), .fee = baseFee, .err = Ter(tefBAD_QUORUM)});
770 oracle.set(CreateArg{.msig = Msig(zelda), .fee = baseFee, .err = Ter(tefBAD_SIGNATURE)});
771 oracle.set(CreateArg{.msig = Msig(becky, bogie), .fee = baseFee});
772 BEAST_EXPECT(oracle.exists());
773
774 // Update
775 oracle.set(
776 UpdateArg{
777 .series = {{"XRP", "USD", 740, 1}},
778 .msig = Msig(becky),
779 .fee = baseFee,
780 .err = Ter(tefBAD_QUORUM),
781 });
782 oracle.set(
783 UpdateArg{
784 .series = {{"XRP", "USD", 740, 1}},
785 .msig = Msig(zelda),
786 .fee = baseFee,
787 .err = Ter(tefBAD_SIGNATURE),
788 });
789 oracle.set(
790 UpdateArg{
791 .series = {{"XRP", "USD", 741, 1}},
792 .msig = Msig(becky, bogie),
793 .fee = baseFee,
794 });
795 BEAST_EXPECT(oracle.expectPrice({{"XRP", "USD", 741, 1}}));
796 // remove the signer list
797 env(signers(alice, jtx::kNone), Sig(alie));
798 env.close();
799 env.require(Owners(alice, 1));
800 // create new signer list
801 env(signers(alice, 2, {{zelda, 1}, {bob, 1}, {ed, 2}}), Sig(alie));
802 env.close();
803 // old list fails
804 oracle.set(
805 UpdateArg{
806 .series = {{"XRP", "USD", 740, 1}},
807 .msig = Msig(becky, bogie),
808 .fee = baseFee,
809 .err = Ter(tefBAD_SIGNATURE),
810 });
811 // updated list succeeds
812 oracle.set(
813 UpdateArg{
814 .series = {{"XRP", "USD", 7412, 2}},
815 .msig = Msig(zelda, bob),
816 .fee = baseFee,
817 });
818 BEAST_EXPECT(oracle.expectPrice({{"XRP", "USD", 7412, 2}}));
819 oracle.set(
820 UpdateArg{.series = {{"XRP", "USD", 74245, 3}}, .msig = Msig(ed), .fee = baseFee});
821 BEAST_EXPECT(oracle.expectPrice({{"XRP", "USD", 74245, 3}}));
822
823 // Remove
824 oracle.remove({.msig = Msig(bob), .fee = baseFee, .err = Ter(tefBAD_QUORUM)});
825 oracle.remove({.msig = Msig(becky), .fee = baseFee, .err = Ter(tefBAD_SIGNATURE)});
826 oracle.remove({.msig = Msig(ed), .fee = baseFee});
827 BEAST_EXPECT(!oracle.exists());
828 }
829
830 void
832 {
833 testcase("Amendment");
834 using namespace jtx;
835
836 auto const features = testableAmendments() - featurePriceOracle;
837 Account const owner("owner");
838 Env env(*this, features);
839 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
840
841 env.fund(XRP(1'000), owner);
842 {
843 Oracle const oracle(env, {.owner = owner, .fee = baseFee, .err = Ter(temDISABLED)});
844 }
845
846 {
847 Oracle oracle(env, {.owner = owner, .fee = baseFee}, false);
848 oracle.remove({.fee = baseFee, .err = Ter(temDISABLED)});
849 }
850 }
851
852public:
853 void
854 run() override
855 {
856 using namespace jtx;
857 auto const all = testableAmendments();
860 testCreate(all);
861 testCreate(all - fixIncludeKeyletFields);
862 testDelete();
863 testUpdate();
865 testMultisig();
866 }
867};
868
870
871} // namespace xrpl::test::jtx::oracle
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
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
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
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 memoize(Account const &account)
Associate AccountID with account.
Definition Env.cpp:174
void require(Args const &... args)
Check a set of requirements.
Definition Env.h:766
std::shared_ptr< OpenView const > current() const
Returns the current ledger.
Definition Env.h:377
Set the fee on a JTx.
Definition fee.h:20
Set a multisignature on a JTx.
Definition multisign.h:53
Match the number of items in the account's owner directory.
Definition owners.h:55
Set the regular signature on a JTx.
Definition sig.h:19
Set the expected result code for a JTx The test will fail if the code doesn't match.
Definition ter.h:18
Oracle class facilitates unit-testing of the Price Oracle feature.
static void setFee(std::uint32_t f)
T count(T... args)
T duration_cast(T... args)
Keylet oracle(AccountID const &account, std::uint32_t const documentID) noexcept
Definition Indexes.cpp:535
BEAST_DEFINE_TESTSUITE(Oracle, app, xrpl)
std::vector< std:: tuple< std::string, std::string, std::optional< std::uint32_t >, std::optional< std::uint8_t > > > DataSeries
static constexpr std::chrono::seconds kTestStartTime
static NoneT const kNone
Definition tags.h:9
json::Value regkey(Account const &account, DisabledT)
Disable the regular key.
Definition regkey.cpp:13
XrpT const XRP
Converts to XRP Issue or STAmount.
Definition amount.cpp:92
std::uint32_t ownerCount(Env const &env, Account const &account)
FeatureBitset testableAmendments()
Definition Env.h:92
json::Value acctdelete(Account const &account, Account const &dest)
Delete account.
PrettyAmount drops(Integer i)
Returns an XRP PrettyAmount, which is trivially convertible to STAmount.
json::Value signers(Account const &account, std::uint32_t quorum, std::vector< Signer > const &v)
Definition multisign.cpp:31
json::Value fset(Account const &account, std::uint32_t on, std::uint32_t off=0)
Add and/or remove flag.
Definition flags.cpp:15
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
static constexpr std::chrono::seconds kEpochOffset
Clock for measuring the network time.
Definition chrono.h:35
@ terNO_ACCOUNT
Definition TER.h:219
std::uint32_t ownerCount(SLE::ConstRef sle, beast::Journal j, std::int32_t ownerCountAdj=0)
Return number of the objects which reserve is covered by the account(sle) (so called "ownercount").
constexpr std::size_t kMaxPriceScale
The maximum price scaling factor.
Definition Protocol.h:467
@ tefBAD_QUORUM
Definition TER.h:174
@ tefBAD_SIGNATURE
Definition TER.h:173
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
@ temARRAY_TOO_LARGE
Definition TER.h:129
@ temBAD_FEE
Definition TER.h:80
@ temINVALID_FLAG
Definition TER.h:99
@ temMALFORMED
Definition TER.h:75
@ temARRAY_EMPTY
Definition TER.h:128
@ temDISABLED
Definition TER.h:102
@ tecINVALID_UPDATE_TIME
Definition TER.h:365
@ tecNO_ENTRY
Definition TER.h:317
@ tecARRAY_TOO_LARGE
Definition TER.h:368
@ tecARRAY_EMPTY
Definition TER.h:367
@ tecINSUFFICIENT_RESERVE
Definition TER.h:318
@ tecTOKEN_PAIR_NOT_FOUND
Definition TER.h:366
T size(T... args)
Set the sequence number on a JTx.
Definition seq.h:16
void run() override
Runs the suite.
void testCreate(FeatureBitset features)