xrpld
Loading...
Searching...
No Matches
Validations.cpp
1#include <xrpl/consensus/Validations.h>
2
3#include <xrpl/basics/UnorderedContainers.h>
4#include <xrpl/basics/chrono.h>
5#include <xrpl/basics/tagged_integer.h>
6#include <xrpl/beast/clock/abstract_clock.h>
7#include <xrpl/beast/clock/manual_clock.h>
8#include <xrpl/beast/utility/Journal.h>
9
10#include <csf/Validation.h>
11#include <csf/ledgers.h>
12#include <gtest/gtest.h>
13#include <helpers/TestSink.h>
14
15#include <chrono>
16#include <cstddef>
17#include <cstdint>
18#include <functional>
19#include <optional>
20#include <utility>
21#include <vector>
22
23namespace xrpl::test::csf {
24
25namespace {
26
27[[nodiscard]] beast::Journal
28journal()
29{
31}
32
33template <class ValidationStore>
34void
35expireValidations(ValidationStore& validations)
36{
37 auto const j = journal();
38 validations.expire(j);
39}
40
42
43// Helper to convert steady_clock to a reasonable NetClock
44// This allows a single manual clock in the unit tests
45[[nodiscard]] NetClock::time_point
46toNetClock(ClockType const& c)
47{
48 // We don't care about the actual epochs, but do want the
49 // generated NetClock time to be well past its epoch to ensure
50 // any subtractions are positive
51 using namespace std::chrono;
53 duration_cast<NetClock::duration>(c.now().time_since_epoch() + 86400s));
54}
55
56// Represents a node that can issue validations
57class Node
58{
59 ClockType const& c_;
60 PeerID nodeID_;
61 bool trusted_ = true;
62 std::size_t signIdx_{1};
64
65public:
66 Node(PeerID nodeID, ClockType const& c) : c_(c), nodeID_(nodeID)
67 {
68 }
69
70 void
71 untrust()
72 {
73 trusted_ = false;
74 }
75
76 void
77 trust()
78 {
79 trusted_ = true;
80 }
81
82 void
83 setLoadFee(std::uint32_t fee)
84 {
85 loadFee_ = fee;
86 }
87
88 [[nodiscard]] PeerID
89 nodeID() const
90 {
91 return nodeID_;
92 }
93
94 void
95 advanceKey()
96 {
97 signIdx_++;
98 }
99
100 [[nodiscard]] PeerKey
101 currKey() const
102 {
103 return std::make_pair(nodeID_, signIdx_);
104 }
105
106 [[nodiscard]] PeerKey
107 masterKey() const
108 {
109 return std::make_pair(nodeID_, 0);
110 }
111 [[nodiscard]] NetClock::time_point
112 now() const
113 {
114 return toNetClock(c_);
115 }
116
117 // Issue a new validation with given sequence number and id and
118 // with signing and seen times offset from the common clock
119 [[nodiscard]] Validation
120 validate(
121 Ledger::ID id,
122 Ledger::Seq seq,
123 NetClock::duration signOffset,
124 NetClock::duration seenOffset,
125 bool full) const
126 {
127 Validation v{
128 id, seq, now() + signOffset, now() + seenOffset, currKey(), nodeID_, full, loadFee_};
129 if (trusted_)
130 v.setTrusted();
131 return v;
132 }
133
134 [[nodiscard]] Validation
135 validate(Ledger ledger, NetClock::duration signOffset, NetClock::duration seenOffset) const
136 {
137 return validate(ledger.id(), ledger.seq(), signOffset, seenOffset, true);
138 }
139
140 [[nodiscard]] Validation
141 validate(Ledger ledger) const
142 {
143 return validate(
144 ledger.id(), ledger.seq(), NetClock::duration{0}, NetClock::duration{0}, true);
145 }
146
147 [[nodiscard]] Validation
148 partial(Ledger ledger) const
149 {
150 return validate(
151 ledger.id(), ledger.seq(), NetClock::duration{0}, NetClock::duration{0}, false);
152 }
153};
154
155// Generic Validations adaptor
156class Adaptor
157{
158 ClockType& c_;
159 LedgerOracle& oracle_;
160
161public:
162 // Non-locking mutex to avoid locks in generic Validations
163 struct Mutex
164 {
165 void
166 lock()
167 {
168 }
169
170 void
171 unlock()
172 {
173 }
174 };
175
177 using Ledger = csf::Ledger;
178
179 Adaptor(ClockType& c, LedgerOracle& o) : c_{c}, oracle_{o}
180 {
181 }
182
183 [[nodiscard]] NetClock::time_point
184 now() const
185 {
186 return toNetClock(c_);
187 }
188
189 [[nodiscard]] std::optional<Ledger>
190 acquire(Ledger::ID const& id)
191 {
192 return oracle_.lookup(id);
193 }
194};
195
196// Specialize generic Validations using the above types
197using TestValidations = Validations<Adaptor>;
198
199// Gather the dependencies of TestValidations in a single class and provide
200// accessors for simplifying test logic
201class TestHarness
202{
205 TestValidations tv_;
206 PeerID nextNodeId_{0};
207
208public:
209 explicit TestHarness(LedgerOracle& o) : tv_(p_, clock_, clock_, o)
210 {
211 }
212
213 [[nodiscard]] ValStatus
214 add(Validation const& v)
215 {
216 return tv_.add(v.nodeID(), v);
217 }
218
219 [[nodiscard]] TestValidations&
220 vals()
221 {
222 return tv_;
223 }
224
225 [[nodiscard]] Node
226 makeNode()
227 {
228 return Node(nextNodeId_++, clock_);
229 }
230
231 [[nodiscard]] ValidationParms
232 parms() const
233 {
234 return p_;
235 }
236
237 [[nodiscard]] auto&
238 clock()
239 {
240 return clock_;
241 }
242};
243
244Ledger const kGenesisLedger{Ledger::MakeGenesis{}};
245
246} // namespace
247
248struct AddValidationTest : public ::testing::Test
249{
251 Ledger const ledgerA = h["a"];
255 Ledger const ledgerABCD = h["abcd"];
256 Ledger const ledgerABCDE = h["abcde"];
257};
258
259TEST_F(AddValidationTest, sequencing_key_rotation_and_out_of_order_arrival)
260{
261 using namespace std::chrono_literals;
262
263 TestHarness harness(h.oracle);
264 Node n = harness.makeNode();
265
266 auto const v = n.validate(ledgerA);
267
268 // Add a current validation
269 EXPECT_TRUE(ValStatus::Current == harness.add(v));
270
271 // Re-adding violates the increasing seq requirement for full
272 // validations
273 EXPECT_TRUE(ValStatus::BadSeq == harness.add(v));
274
275 harness.clock().advance(1s);
276
277 EXPECT_TRUE(ValStatus::Current == harness.add(n.validate(ledgerAB)));
278
279 // Test the node changing signing key
280
281 // Confirm old ledger on hand, but not new ledger
282 EXPECT_TRUE(harness.vals().numTrustedForLedger(ledgerAB.id()) == 1);
283 EXPECT_TRUE(harness.vals().numTrustedForLedger(ledgerABC.id()) == 0);
284
285 // Rotate signing keys
286 n.advanceKey();
287
288 harness.clock().advance(1s);
289
290 // Cannot re-do the same full validation sequence
291 EXPECT_TRUE(ValStatus::Conflicting == harness.add(n.validate(ledgerAB)));
292 // Cannot send the same partial validation sequence
293 EXPECT_TRUE(ValStatus::Conflicting == harness.add(n.partial(ledgerAB)));
294
295 // Now trusts the newest ledger too
296 harness.clock().advance(1s);
297 EXPECT_TRUE(ValStatus::Current == harness.add(n.validate(ledgerABC)));
298 EXPECT_TRUE(harness.vals().numTrustedForLedger(ledgerAB.id()) == 1);
299 EXPECT_TRUE(harness.vals().numTrustedForLedger(ledgerABC.id()) == 1);
300
301 // Processing validations out of order should ignore the older
302 // validation
303 harness.clock().advance(2s);
304 auto const valABCDE = n.validate(ledgerABCDE);
305
306 harness.clock().advance(4s);
307 auto const valABCD = n.validate(ledgerABCD);
308
309 EXPECT_TRUE(ValStatus::Current == harness.add(valABCD));
310
311 EXPECT_TRUE(ValStatus::Stale == harness.add(valABCDE));
312}
313
314TEST_F(AddValidationTest, validations_arriving_out_of_order_with_shifted_times)
315{
316 using namespace std::chrono_literals;
317
318 // Process validations out of order with shifted times
319
320 TestHarness harness(h.oracle);
321 Node const n = harness.makeNode();
322
323 // Establish a new current validation
324 EXPECT_TRUE(ValStatus::Current == harness.add(n.validate(ledgerA)));
325
326 // Process a validation that has "later" seq but early sign time
327 EXPECT_TRUE(ValStatus::Stale == harness.add(n.validate(ledgerAB, -1s, -1s)));
328
329 // Process a validation that has a later seq and later sign
330 // time
331 EXPECT_TRUE(ValStatus::Current == harness.add(n.validate(ledgerABC, 1s, 1s)));
332}
333
334TEST_F(AddValidationTest, validations_that_are_stale_on_arrival)
335{
336 using namespace std::chrono_literals;
337
338 // Test stale on arrival validations
339 TestHarness harness(h.oracle);
340 Node const n = harness.makeNode();
341
342 EXPECT_TRUE(
344 harness.add(n.validate(ledgerA, -harness.parms().validationCurrentEarly, 0s)));
345
346 EXPECT_TRUE(
348 harness.add(n.validate(ledgerA, harness.parms().validationCurrentWall, 0s)));
349
350 EXPECT_TRUE(
352 harness.add(n.validate(ledgerA, 0s, harness.parms().validationCurrentLocal)));
353}
354
355TEST_F(AddValidationTest, older_sequence_numbers_are_rejected_until_the_set_expires)
356{
357 using namespace std::chrono_literals;
358
359 // Test that full or partials cannot be sent for older sequence
360 // numbers, unless time-out has happened
361 for (bool doFull : {true, false})
362 {
363 TestHarness harness(h.oracle);
364 Node n = harness.makeNode();
365
366 auto const process = [&](Ledger& lgr) {
367 if (doFull)
368 return harness.add(n.validate(lgr));
369 return harness.add(n.partial(lgr));
370 };
371
372 EXPECT_TRUE(ValStatus::Current == process(ledgerABC));
373 harness.clock().advance(1s);
374 EXPECT_TRUE(ledgerAB.seq() < ledgerABC.seq());
375 EXPECT_TRUE(ValStatus::BadSeq == process(ledgerAB));
376
377 // If we advance far enough for AB to expire, we can fully
378 // validate or partially validate that sequence number again
379 EXPECT_TRUE(ValStatus::Conflicting == process(ledgerAZ));
380 harness.clock().advance(harness.parms().validationSetExpires + 1ms);
381 EXPECT_TRUE(ValStatus::Current == process(ledgerAZ));
382 }
383}
384
385TEST(ValidationsTest, on_stale)
386{
387 SCOPED_TRACE("Stale validation");
388 // Verify validation becomes stale based solely on time passing, but
389 // use different functions to trigger the check for staleness
390
392 Ledger ledgerA = h["a"];
393 Ledger const ledgerAB = h["ab"];
394
395 using Trigger = std::function<void(TestValidations&)>;
396
397 std::vector<Trigger> const triggers = {
398 [&](TestValidations& vals) { vals.currentTrusted(); },
399 [&](TestValidations& vals) { vals.getCurrentNodeIDs(); },
400 [&](TestValidations& vals) { vals.getPreferred(kGenesisLedger); },
401 [&](TestValidations& vals) { vals.getNodesAfter(ledgerA, ledgerA.id()); },
402 };
403 for (Trigger const& trigger : triggers)
404 {
405 TestHarness harness(h.oracle);
406 Node const n = harness.makeNode();
407
408 EXPECT_TRUE(ValStatus::Current == harness.add(n.validate(ledgerAB)));
409 trigger(harness.vals());
410 EXPECT_TRUE(harness.vals().getNodesAfter(ledgerA, ledgerA.id()) == 1);
411 EXPECT_TRUE(
412 harness.vals().getPreferred(kGenesisLedger) ==
413 std::make_pair(ledgerAB.seq(), ledgerAB.id()));
414 harness.clock().advance(harness.parms().validationCurrentLocal);
415
416 // trigger check for stale
417 trigger(harness.vals());
418
419 EXPECT_TRUE(harness.vals().getNodesAfter(ledgerA, ledgerA.id()) == 0);
420 EXPECT_TRUE(harness.vals().getPreferred(kGenesisLedger) == std::nullopt);
421 }
422}
423
424TEST(ValidationsTest, get_nodes_after)
425{
426 // Test getting number of nodes working on a validation descending
427 // a prescribed one. This count should only be for trusted nodes, but
428 // includes partial and full validations
429
430 using namespace std::chrono_literals;
431 SCOPED_TRACE("Get nodes after");
432
434 Ledger const ledgerA = h["a"];
435 Ledger const ledgerAB = h["ab"];
436 Ledger const ledgerABC = h["abc"];
437 Ledger const ledgerAD = h["ad"];
438
439 TestHarness harness(h.oracle);
440 Node const trustedNode1 = harness.makeNode();
441 Node const trustedNode2 = harness.makeNode();
442 Node const trustedNode3 = harness.makeNode();
443
444 Node notTrustedNode = harness.makeNode();
445 notTrustedNode.untrust();
446
447 // first round a,b,c agree, d has is partial
448 EXPECT_TRUE(ValStatus::Current == harness.add(trustedNode1.validate(ledgerA)));
449 EXPECT_TRUE(ValStatus::Current == harness.add(trustedNode2.validate(ledgerA)));
450 EXPECT_TRUE(ValStatus::Current == harness.add(notTrustedNode.validate(ledgerA)));
451 EXPECT_TRUE(ValStatus::Current == harness.add(trustedNode3.partial(ledgerA)));
452
453 for (Ledger const& ledger : {ledgerA, ledgerAB, ledgerABC, ledgerAD})
454 EXPECT_TRUE(harness.vals().getNodesAfter(ledger, ledger.id()) == 0);
455
456 harness.clock().advance(5s);
457
458 EXPECT_TRUE(ValStatus::Current == harness.add(trustedNode1.validate(ledgerAB)));
459 EXPECT_TRUE(ValStatus::Current == harness.add(trustedNode2.validate(ledgerABC)));
460 EXPECT_TRUE(ValStatus::Current == harness.add(notTrustedNode.validate(ledgerAB)));
461 EXPECT_TRUE(ValStatus::Current == harness.add(trustedNode3.partial(ledgerABC)));
462
463 EXPECT_TRUE(harness.vals().getNodesAfter(ledgerA, ledgerA.id()) == 3);
464 EXPECT_TRUE(harness.vals().getNodesAfter(ledgerAB, ledgerAB.id()) == 2);
465 EXPECT_TRUE(harness.vals().getNodesAfter(ledgerABC, ledgerABC.id()) == 0);
466 EXPECT_TRUE(harness.vals().getNodesAfter(ledgerAD, ledgerAD.id()) == 0);
467
468 // If given a ledger inconsistent with the id, is still able to check using slower method
469 EXPECT_TRUE(harness.vals().getNodesAfter(ledgerAD, ledgerA.id()) == 1);
470 EXPECT_TRUE(harness.vals().getNodesAfter(ledgerAD, ledgerAB.id()) == 2);
471}
472
473TEST(ValidationsTest, current_trusted)
474{
475 using namespace std::chrono_literals;
476 SCOPED_TRACE("Current trusted validations");
477
479 Ledger const ledgerA = h["a"];
480 Ledger const ledgerB = h["b"];
481 Ledger const ledgerAC = h["ac"];
482
483 TestHarness harness(h.oracle);
484 Node const a = harness.makeNode();
485 Node b = harness.makeNode();
486 b.untrust();
487
488 EXPECT_TRUE(ValStatus::Current == harness.add(a.validate(ledgerA)));
489 EXPECT_TRUE(ValStatus::Current == harness.add(b.validate(ledgerB)));
490
491 // Only a is trusted
492 EXPECT_TRUE(harness.vals().currentTrusted().size() == 1);
493 EXPECT_TRUE(harness.vals().currentTrusted()[0].ledgerID() == ledgerA.id());
494 EXPECT_TRUE(harness.vals().currentTrusted()[0].seq() == ledgerA.seq());
495
496 harness.clock().advance(3s);
497
498 for (auto const& node : {a, b})
499 EXPECT_TRUE(ValStatus::Current == harness.add(node.validate(ledgerAC)));
500
501 // New validation for a
502 EXPECT_TRUE(harness.vals().currentTrusted().size() == 1);
503 EXPECT_TRUE(harness.vals().currentTrusted()[0].ledgerID() == ledgerAC.id());
504 EXPECT_TRUE(harness.vals().currentTrusted()[0].seq() == ledgerAC.seq());
505
506 // Pass enough time for it to go stale
507 harness.clock().advance(harness.parms().validationCurrentLocal);
508 EXPECT_TRUE(harness.vals().currentTrusted().empty());
509}
510
511TEST(ValidationsTest, get_current_public_keys)
512{
513 using namespace std::chrono_literals;
514 SCOPED_TRACE("Current public keys");
515
517 Ledger const ledgerA = h["a"];
518 Ledger const ledgerAC = h["ac"];
519
520 TestHarness harness(h.oracle);
521 Node a = harness.makeNode(), b = harness.makeNode();
522 b.untrust();
523
524 for (auto const& node : {a, b})
525 EXPECT_TRUE(ValStatus::Current == harness.add(node.validate(ledgerA)));
526
527 {
528 HashSet<PeerID> const expectedKeys = {a.nodeID(), b.nodeID()};
529 EXPECT_TRUE(harness.vals().getCurrentNodeIDs() == expectedKeys);
530 }
531
532 harness.clock().advance(3s);
533
534 // Change keys and issue partials
535 a.advanceKey();
536 b.advanceKey();
537
538 for (auto const& node : {a, b})
539 EXPECT_TRUE(ValStatus::Current == harness.add(node.partial(ledgerAC)));
540
541 {
542 HashSet<PeerID> const expectedKeys = {a.nodeID(), b.nodeID()};
543 EXPECT_TRUE(harness.vals().getCurrentNodeIDs() == expectedKeys);
544 }
545
546 // Pass enough time for them to go stale
547 harness.clock().advance(harness.parms().validationCurrentLocal);
548 EXPECT_TRUE(harness.vals().getCurrentNodeIDs().empty());
549}
550
551TEST(ValidationsTest, trusted_by_ledger_functions)
552{
553 // Test the Validations functions that calculate a value by ledger ID
554 using namespace std::chrono_literals;
555 SCOPED_TRACE("By ledger functions");
556
557 // Several Validations functions return a set of values associated
558 // with trusted ledgers sharing the same ledger ID. The tests below
559 // exercise this logic by saving the set of trusted Validations, and
560 // verifying that the Validations member functions all calculate the
561 // proper transformation of the available ledgers.
562
564 TestHarness harness(h.oracle);
565
566 Node a = harness.makeNode(), b = harness.makeNode(), c = harness.makeNode(),
567 d = harness.makeNode(), e = harness.makeNode();
568
569 c.untrust();
570 // Mix of load fees
571 a.setLoadFee(12);
572 b.setLoadFee(1);
573 c.setLoadFee(12);
574 e.setLoadFee(12);
575
577
578 //----------------------------------------------------------------------
579 // checkers
580 auto sorted = [](auto vec) {
581 std::sort(vec.begin(), vec.end());
582 return vec;
583 };
584 auto const compare = [&] {
585 for (auto const& it : trustedValidations)
586 {
587 auto const& id = it.first.first;
588 auto const& seq = it.first.second;
589 auto const& expectedValidations = it.second;
590
591 EXPECT_TRUE(harness.vals().numTrustedForLedger(id) == expectedValidations.size());
592 EXPECT_TRUE(
593 sorted(harness.vals().getTrustedForLedger(id, seq)) == sorted(expectedValidations));
594
595 std::uint32_t const baseFee = 0;
596 std::vector<uint32_t> expectedFees;
597 expectedFees.reserve(expectedValidations.size());
598 for (auto const& val : expectedValidations)
599 {
600 expectedFees.push_back(val.loadFee().value_or(baseFee));
601 }
602
603 EXPECT_TRUE(sorted(harness.vals().fees(id, baseFee)) == sorted(expectedFees));
604 }
605 };
606
607 //----------------------------------------------------------------------
608 Ledger const ledgerA = h["a"];
609 Ledger const ledgerB = h["b"];
610 Ledger const ledgerAC = h["ac"];
611
612 // Add a dummy ID to cover unknown ledger identifiers
613 trustedValidations[{Ledger::ID{100}, Ledger::Seq{100}}] = {};
614
615 // first round a,b,c agree
616 for (auto const& node : {a, b, c})
617 {
618 auto const val = node.validate(ledgerA);
619 EXPECT_TRUE(ValStatus::Current == harness.add(val));
620 if (val.trusted())
621 trustedValidations[{val.ledgerID(), val.seq()}].emplace_back(val);
622 }
623 // d disagrees
624 {
625 auto const val = d.validate(ledgerB);
626 EXPECT_TRUE(ValStatus::Current == harness.add(val));
627 trustedValidations[{val.ledgerID(), val.seq()}].emplace_back(val);
628 }
629 // e only issues partials
630 {
631 EXPECT_TRUE(ValStatus::Current == harness.add(e.partial(ledgerA)));
632 }
633
634 harness.clock().advance(5s);
635 // second round, a,b,c move to ledger 2
636 for (auto const& node : {a, b, c})
637 {
638 auto const val = node.validate(ledgerAC);
639 EXPECT_TRUE(ValStatus::Current == harness.add(val));
640 if (val.trusted())
641 trustedValidations[{val.ledgerID(), val.seq()}].emplace_back(val);
642 }
643 // d now thinks ledger 1, but cannot re-issue a previously used seq
644 // and attempting it should generate a conflict.
645 {
646 EXPECT_TRUE(ValStatus::Conflicting == harness.add(d.partial(ledgerA)));
647 }
648 // e only issues partials
649 {
650 EXPECT_TRUE(ValStatus::Current == harness.add(e.partial(ledgerAC)));
651 }
652
653 compare();
654}
655
656TEST(ValidationsTest, expire)
657{
658 // Verify expiring clears out validations stored by ledger
659 SCOPED_TRACE("Expire validations");
661 TestHarness harness(h.oracle);
662 Node const a = harness.makeNode();
663 constexpr Ledger::Seq kOne(1);
664 constexpr Ledger::Seq kTwo(2);
665
666 // simple cases
667 Ledger const ledgerA = h["a"];
668 EXPECT_TRUE(ValStatus::Current == harness.add(a.validate(ledgerA)));
669 EXPECT_TRUE(harness.vals().numTrustedForLedger(ledgerA.id()) == 1);
670 expireValidations(harness.vals());
671 EXPECT_TRUE(harness.vals().numTrustedForLedger(ledgerA.id()) == 1);
672 harness.clock().advance(harness.parms().validationSetExpires);
673 expireValidations(harness.vals());
674 EXPECT_TRUE(harness.vals().numTrustedForLedger(ledgerA.id()) == 0);
675
676 // use setSeqToKeep to keep the validation from expire
677 Ledger const ledgerB = h["ab"];
678 EXPECT_TRUE(ValStatus::Current == harness.add(a.validate(ledgerB)));
679 EXPECT_TRUE(harness.vals().numTrustedForLedger(ledgerB.id()) == 1);
680 harness.vals().setSeqToKeep(ledgerB.seq(), ledgerB.seq() + kOne);
681 harness.clock().advance(harness.parms().validationSetExpires);
682 expireValidations(harness.vals());
683 EXPECT_TRUE(harness.vals().numTrustedForLedger(ledgerB.id()) == 1);
684 // change toKeep
685 harness.vals().setSeqToKeep(ledgerB.seq() + kOne, ledgerB.seq() + kTwo);
686 // advance clock slowly
687 int const loops =
688 harness.parms().validationSetExpires / harness.parms().validationFRESHNESS + 1;
689 for (int i = 0; i < loops; ++i)
690 {
691 harness.clock().advance(harness.parms().validationFRESHNESS);
692 expireValidations(harness.vals());
693 }
694 EXPECT_TRUE(harness.vals().numTrustedForLedger(ledgerB.id()) == 0);
695
696 // Allow the validation with high seq to expire
697 Ledger const ledgerC = h["abc"];
698 EXPECT_TRUE(ValStatus::Current == harness.add(a.validate(ledgerC)));
699 EXPECT_TRUE(harness.vals().numTrustedForLedger(ledgerC.id()) == 1);
700 harness.vals().setSeqToKeep(ledgerC.seq() - kOne, ledgerC.seq());
701 harness.clock().advance(harness.parms().validationSetExpires);
702 expireValidations(harness.vals());
703 EXPECT_TRUE(harness.vals().numTrustedForLedger(ledgerC.id()) == 0);
704}
705
706TEST(ValidationsTest, flush)
707{
708 // Test final flush of validations
709 using namespace std::chrono_literals;
710 SCOPED_TRACE("Flush validations");
711
713 TestHarness harness(h.oracle);
714 Node const trustedNode1 = harness.makeNode();
715 Node const trustedNode2 = harness.makeNode();
716 Node notTrustedNode = harness.makeNode();
717 notTrustedNode.untrust();
718
719 Ledger const ledgerA = h["a"];
720 Ledger const ledgerAB = h["ab"];
721
723 for (auto const& node : {trustedNode1, trustedNode2, notTrustedNode})
724 {
725 auto const val = node.validate(ledgerA);
726 EXPECT_TRUE(ValStatus::Current == harness.add(val));
727 expected.emplace(node.nodeID(), val);
728 }
729
730 // Send in a new validation for a, saving the new one into the expected
731 // map after setting the proper prior ledger ID it replaced
732 harness.clock().advance(1s);
733 auto const newVal = trustedNode1.validate(ledgerAB);
734 EXPECT_TRUE(ValStatus::Current == harness.add(newVal));
735 expected.find(trustedNode1.nodeID())->second = newVal;
736}
737
738TEST(ValidationsTest, get_preferred_ledger)
739{
740 using namespace std::chrono_literals;
741 SCOPED_TRACE("Preferred Ledger");
742
744 TestHarness harness(h.oracle);
745 Node const trustedNode1 = harness.makeNode();
746 Node const trustedNode2 = harness.makeNode();
747 Node const trustedNode3 = harness.makeNode();
748
749 Node notTrustedNode = harness.makeNode();
750 notTrustedNode.untrust();
751
752 Ledger const ledgerA = h["a"];
753 Ledger const ledgerB = h["b"];
754 Ledger const ledgerAC = h["ac"];
755 Ledger const ledgerACD = h["acd"];
756
757 using Seq = Ledger::Seq;
758
759 auto const pref = [](Ledger ledger) { return std::make_pair(ledger.seq(), ledger.id()); };
760
761 // Empty (no ledgers)
762 EXPECT_TRUE(harness.vals().getPreferred(ledgerA) == std::nullopt);
763
764 // Single ledger
765 EXPECT_TRUE(ValStatus::Current == harness.add(trustedNode1.validate(ledgerB)));
766 EXPECT_TRUE(harness.vals().getPreferred(ledgerA) == pref(ledgerB));
767 EXPECT_TRUE(harness.vals().getPreferred(ledgerB) == pref(ledgerB));
768
769 // Minimum valid sequence
770 EXPECT_TRUE(harness.vals().getPreferred(ledgerA, Seq{10}) == ledgerA.id());
771
772 // Untrusted doesn't impact preferred ledger
773 // (ledgerB has tie-break over ledgerA)
774 EXPECT_TRUE(ValStatus::Current == harness.add(trustedNode2.validate(ledgerA)));
775 EXPECT_TRUE(ValStatus::Current == harness.add(notTrustedNode.validate(ledgerA)));
776 EXPECT_TRUE(ledgerB.id() > ledgerA.id());
777 EXPECT_TRUE(harness.vals().getPreferred(ledgerA) == pref(ledgerB));
778 EXPECT_TRUE(harness.vals().getPreferred(ledgerB) == pref(ledgerB));
779
780 // Partial does break ties
781 EXPECT_TRUE(ValStatus::Current == harness.add(trustedNode3.partial(ledgerA)));
782 EXPECT_TRUE(harness.vals().getPreferred(ledgerA) == pref(ledgerA));
783 EXPECT_TRUE(harness.vals().getPreferred(ledgerB) == pref(ledgerA));
784
785 harness.clock().advance(5s);
786
787 // Parent of preferred-> stick with ledger
788 for (auto const& node : {trustedNode1, trustedNode2, notTrustedNode, trustedNode3})
789 EXPECT_TRUE(ValStatus::Current == harness.add(node.validate(ledgerAC)));
790 // Parent of preferred stays put
791 EXPECT_TRUE(harness.vals().getPreferred(ledgerA) == pref(ledgerA));
792 // Earlier different chain, switch
793 EXPECT_TRUE(harness.vals().getPreferred(ledgerB) == pref(ledgerAC));
794 // Later on chain, stays where it is
795 EXPECT_TRUE(harness.vals().getPreferred(ledgerACD) == pref(ledgerACD));
796
797 // Any later grandchild or different chain is preferred
798 harness.clock().advance(5s);
799 for (auto const& node : {trustedNode1, trustedNode2, notTrustedNode, trustedNode3})
800 EXPECT_TRUE(ValStatus::Current == harness.add(node.validate(ledgerACD)));
801 for (auto const& ledger : {ledgerA, ledgerB, ledgerACD})
802 EXPECT_TRUE(harness.vals().getPreferred(ledger) == pref(ledgerACD));
803}
804
805TEST(ValidationsTest, get_preferred_lcl)
806{
807 using namespace std::chrono_literals;
808 SCOPED_TRACE("Get preferred LCL");
809
811 TestHarness harness(h.oracle);
812 Node const a = harness.makeNode();
813
814 Ledger const ledgerA = h["a"];
815 Ledger const ledgerB = h["b"];
816 Ledger const ledgerC = h["c"];
817
818 using ID = Ledger::ID;
819 using Seq = Ledger::Seq;
820
822
823 // No trusted validations or counts sticks with current ledger
824 EXPECT_TRUE(harness.vals().getPreferredLCL(ledgerA, Seq{0}, peerCounts) == ledgerA.id());
825
826 ++peerCounts[ledgerB.id()];
827
828 // No trusted validations, rely on peer counts
829 EXPECT_TRUE(harness.vals().getPreferredLCL(ledgerA, Seq{0}, peerCounts) == ledgerB.id());
830
831 ++peerCounts[ledgerC.id()];
832 // No trusted validations, tied peers goes with larger ID
833 EXPECT_TRUE(ledgerC.id() > ledgerB.id());
834
835 EXPECT_TRUE(harness.vals().getPreferredLCL(ledgerA, Seq{0}, peerCounts) == ledgerC.id());
836
837 peerCounts[ledgerC.id()] += 1000;
838
839 // Single trusted always wins over peer counts
840 EXPECT_TRUE(ValStatus::Current == harness.add(a.validate(ledgerA)));
841 EXPECT_TRUE(harness.vals().getPreferredLCL(ledgerA, Seq{0}, peerCounts) == ledgerA.id());
842 EXPECT_TRUE(harness.vals().getPreferredLCL(ledgerB, Seq{0}, peerCounts) == ledgerA.id());
843 EXPECT_TRUE(harness.vals().getPreferredLCL(ledgerC, Seq{0}, peerCounts) == ledgerA.id());
844
845 // Stick with current ledger if trusted validation ledger has too old
846 // of a sequence
847 EXPECT_TRUE(harness.vals().getPreferredLCL(ledgerB, Seq{2}, peerCounts) == ledgerB.id());
848}
849
850TEST(ValidationsTest, acquire_validated_ledger)
851{
852 using namespace std::chrono_literals;
853 SCOPED_TRACE("Acquire validated ledger");
854
856 TestHarness harness(h.oracle);
857 Node const a = harness.makeNode();
858 Node const b = harness.makeNode();
859
860 using ID = Ledger::ID;
861 using Seq = Ledger::Seq;
862
863 // Validate the ledger before it is actually available
864 Validation const val = a.validate(ID{2}, Seq{2}, 0s, 0s, true);
865
866 EXPECT_TRUE(ValStatus::Current == harness.add(val));
867 // Validation is available
868 EXPECT_TRUE(harness.vals().numTrustedForLedger(ID{2}) == 1);
869 // but ledger based data is not
870 EXPECT_TRUE(harness.vals().getNodesAfter(kGenesisLedger, ID{0}) == 0);
871 // Initial preferred branch falls back to the ledger we are trying to
872 // acquire
873 EXPECT_TRUE(harness.vals().getPreferred(kGenesisLedger) == std::make_pair(Seq{2}, ID{2}));
874
875 // After adding another unavailable validation, the preferred ledger
876 // breaks ties via higher ID
877 EXPECT_TRUE(ValStatus::Current == harness.add(b.validate(ID{3}, Seq{2}, 0s, 0s, true)));
878 EXPECT_TRUE(harness.vals().getPreferred(kGenesisLedger) == std::make_pair(Seq{2}, ID{3}));
879
880 // Create the ledger
881 Ledger const ledgerAB = h["ab"];
882 // Now it should be available
883 EXPECT_TRUE(harness.vals().getNodesAfter(kGenesisLedger, ID{0}) == 1);
884
885 // Create a validation that is not available
886 harness.clock().advance(5s);
887 Validation const val2 = a.validate(ID{4}, Seq{4}, 0s, 0s, true);
888 EXPECT_TRUE(ValStatus::Current == harness.add(val2));
889 EXPECT_TRUE(harness.vals().numTrustedForLedger(ID{4}) == 1);
890 EXPECT_TRUE(
891 harness.vals().getPreferred(kGenesisLedger) ==
892 std::make_pair(ledgerAB.seq(), ledgerAB.id()));
893
894 // Another node requesting that ledger still doesn't change things
895 Validation const val3 = b.validate(ID{4}, Seq{4}, 0s, 0s, true);
896 EXPECT_TRUE(ValStatus::Current == harness.add(val3));
897 EXPECT_TRUE(harness.vals().numTrustedForLedger(ID{4}) == 2);
898 EXPECT_TRUE(
899 harness.vals().getPreferred(kGenesisLedger) ==
900 std::make_pair(ledgerAB.seq(), ledgerAB.id()));
901
902 // Switch to validation that is available
903 harness.clock().advance(5s);
904 Ledger const ledgerABCDE = h["abcde"];
905 EXPECT_TRUE(ValStatus::Current == harness.add(a.partial(ledgerABCDE)));
906 EXPECT_TRUE(ValStatus::Current == harness.add(b.partial(ledgerABCDE)));
907 EXPECT_TRUE(
908 harness.vals().getPreferred(kGenesisLedger) ==
909 std::make_pair(ledgerABCDE.seq(), ledgerABCDE.id()));
910}
911
912TEST(ValidationsTest, num_trusted_for_ledger)
913{
914 SCOPED_TRACE("NumTrustedForLedger");
916 TestHarness harness(h.oracle);
917 Node const a = harness.makeNode();
918 Node const b = harness.makeNode();
919 Ledger const ledgerA = h["a"];
920
921 EXPECT_TRUE(ValStatus::Current == harness.add(a.partial(ledgerA)));
922 EXPECT_TRUE(harness.vals().numTrustedForLedger(ledgerA.id()) == 0);
923
924 EXPECT_TRUE(ValStatus::Current == harness.add(b.validate(ledgerA)));
925 EXPECT_TRUE(harness.vals().numTrustedForLedger(ledgerA.id()) == 1);
926}
927
928TEST(ValidationsTest, seq_enforcer)
929{
930 SCOPED_TRACE("SeqEnforcer");
931 using Seq = Ledger::Seq;
932 using namespace std::chrono;
933
935 SeqEnforcer<Seq> enforcer;
936
937 ValidationParms const p;
938
939 EXPECT_TRUE(enforcer(clock.now(), Seq{1}, p));
940 EXPECT_TRUE(enforcer(clock.now(), Seq{10}, p));
941 EXPECT_TRUE(!enforcer(clock.now(), Seq{5}, p));
942 EXPECT_TRUE(!enforcer(clock.now(), Seq{9}, p));
943 clock.advance(p.validationSetExpires - 1ms);
944 EXPECT_TRUE(!enforcer(clock.now(), Seq{1}, p));
945 clock.advance(2ms);
946 EXPECT_TRUE(enforcer(clock.now(), Seq{1}, p));
947}
948
949TEST(ValidationsTest, trust_changed)
950{
951 SCOPED_TRACE("TrustChanged");
952 using namespace std::chrono;
953
954 auto const checker = [&](TestValidations& vals,
955 HashSet<PeerID> const& listed,
956 std::vector<Validation> const& trustedVals) {
957 Ledger::ID const testID =
958 trustedVals.empty() ? kGenesisLedger.id() : trustedVals[0].ledgerID();
959 Ledger::Seq const testSeq =
960 trustedVals.empty() ? kGenesisLedger.seq() : trustedVals[0].seq();
961 EXPECT_TRUE(vals.currentTrusted() == trustedVals);
962 EXPECT_TRUE(vals.getCurrentNodeIDs() == listed);
963 EXPECT_TRUE(vals.getNodesAfter(kGenesisLedger, kGenesisLedger.id()) == trustedVals.size());
964 if (trustedVals.empty())
965 {
966 EXPECT_TRUE(vals.getPreferred(kGenesisLedger) == std::nullopt);
967 }
968 else
969 {
970 EXPECT_TRUE(vals.getPreferred(kGenesisLedger)->second == testID);
971 }
972 EXPECT_TRUE(vals.getTrustedForLedger(testID, testSeq) == trustedVals);
973 EXPECT_TRUE(vals.numTrustedForLedger(testID) == trustedVals.size());
974 };
975
976 {
977 // Trusted to untrusted
979 TestHarness harness(h.oracle);
980 Node const a = harness.makeNode();
981 Ledger const ledgerAB = h["ab"];
982 Validation const v = a.validate(ledgerAB);
983 EXPECT_TRUE(ValStatus::Current == harness.add(v));
984
985 HashSet<PeerID> const listed({a.nodeID()});
986 std::vector<Validation> trustedVals({v});
987 checker(harness.vals(), listed, trustedVals);
988
989 trustedVals.clear();
990 harness.vals().trustChanged({}, {a.nodeID()});
991 checker(harness.vals(), listed, trustedVals);
992 }
993
994 {
995 // Untrusted to trusted
997 TestHarness harness(h.oracle);
998 Node a = harness.makeNode();
999 a.untrust();
1000 Ledger const ledgerAB = h["ab"];
1001 Validation const v = a.validate(ledgerAB);
1002 EXPECT_TRUE(ValStatus::Current == harness.add(v));
1003
1004 HashSet<PeerID> const listed({a.nodeID()});
1005 std::vector<Validation> trustedVals;
1006 checker(harness.vals(), listed, trustedVals);
1007
1008 trustedVals.push_back(v);
1009 harness.vals().trustChanged({a.nodeID()}, {});
1010 checker(harness.vals(), listed, trustedVals);
1011 }
1012
1013 {
1014 // Trusted but not acquired -> untrusted
1016 TestHarness harness(h.oracle);
1017 Node const a = harness.makeNode();
1018 Validation const v = a.validate(Ledger::ID{2}, Ledger::Seq{2}, 0s, 0s, true);
1019 EXPECT_TRUE(ValStatus::Current == harness.add(v));
1020
1021 HashSet<PeerID> const listed({a.nodeID()});
1022 std::vector<Validation> trustedVals({v});
1023 auto& vals = harness.vals();
1024 EXPECT_TRUE(vals.currentTrusted() == trustedVals);
1025
1026 // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
1027 EXPECT_TRUE(vals.getPreferred(kGenesisLedger)->second == v.ledgerID());
1028 EXPECT_TRUE(vals.getNodesAfter(kGenesisLedger, kGenesisLedger.id()) == 0);
1029
1030 trustedVals.clear();
1031 harness.vals().trustChanged({}, {a.nodeID()});
1032 // make acquiring ledger available
1033 h["ab"];
1034 EXPECT_TRUE(vals.currentTrusted() == trustedVals);
1035 EXPECT_TRUE(vals.getPreferred(kGenesisLedger) == std::nullopt);
1036 EXPECT_TRUE(vals.getNodesAfter(kGenesisLedger, kGenesisLedger.id()) == 0);
1037 }
1038}
1039
1040} // namespace xrpl::test::csf
Abstract interface to a clock.
A generic endpoint for log messages.
Definition Journal.h:44
Manual clock implementation.
std::chrono::time_point< NetClock > time_point
Definition chrono.h:48
std::chrono::duration< rep, period > duration
Definition chrono.h:47
Enforce validation increasing sequence requirement.
Definition Validations.h:95
static TestSink & instance()
Definition TestSink.h:12
Maintains current and recent ledger validations.
Oracle maintaining unique ledgers for a simulation.
Definition ledgers.h:249
std::optional< Ledger > lookup(Ledger::ID const &id) const
Find the ledger with the given ID.
Definition ledgers.cpp:124
A ledger is a set of observed transactions and a sequence number identifying the ledger.
Definition ledgers.h:48
TaggedInteger< std::uint32_t, IdTag > ID
Definition ledgers.h:56
TaggedInteger< std::uint32_t, SeqTag > Seq
Definition ledgers.h:53
Validation of a specific ledger by a specific Peer.
Definition Validation.h:32
PeerID const & nodeID() const
Definition Validation.h:102
Ledger::ID ledgerID() const
Definition Validation.h:72
T clock(T... args)
T duration_cast(T... args)
T emplace(T... args)
T find(T... args)
T flush(T... args)
T lock(T... args)
T make_pair(T... args)
TEST_F(AddValidationTest, sequencing_key_rotation_and_out_of_order_arrival)
TaggedInteger< std::uint32_t, PeerIDTag > PeerID
Definition Validation.h:17
TEST(ValidationsTest, on_stale)
std::pair< PeerID, std::uint32_t > PeerKey
The current key of a peer.
Definition Validation.h:26
json::Value trust(Account const &account, STAmount const &amount, std::uint32_t flags)
Modify a trust line.
Definition trust.cpp:18
ValStatus
Status of validation we received.
@ Current
This was a new validation and was added.
@ BadSeq
A validation violates the increasing seq requirement.
@ Conflicting
Multiple validations by a validator for different ledgers.
@ Stale
Not current or was older than current from this node.
std::unordered_set< Value, Hash, Pred, Allocator > HashSet
std::unordered_map< Key, Value, Hash, Pred, Allocator > HashMap
T push_back(T... args)
T reserve(T... args)
T sort(T... args)
Timing parameters to control validation staleness and expiration.
Definition Validations.h:36
std::chrono::seconds validationSetExpires
Duration a set of validations for a given ledger hash remain valid.
Definition Validations.h:72
Helper for writing unit tests with controlled ledger histories.
Definition ledgers.h:328
Set the sequence number on a JTx.
Definition seq.h:16