1#include <xrpl/consensus/Validations.h>
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>
10#include <csf/Validation.h>
11#include <csf/ledgers.h>
12#include <gtest/gtest.h>
13#include <helpers/TestSink.h>
33template <
class Val
idationStore>
35expireValidations(ValidationStore& validations)
37 auto const j = journal();
38 validations.expire(j);
46toNetClock(ClockType
const& c)
66 Node(
PeerID nodeID, ClockType
const& c) : c_(c), nodeID_(nodeID)
114 return toNetClock(c_);
128 id, seq, now() + signOffset, now() + seenOffset, currKey(), nodeID_, full, loadFee_};
137 return validate(ledger.
id(), ledger.
seq(), signOffset, seenOffset,
true);
141 validate(
Ledger ledger)
const
148 partial(
Ledger ledger)
const
179 Adaptor(ClockType& c,
LedgerOracle& o) : c_{c}, oracle_{o}
186 return toNetClock(c_);
192 return oracle_.
lookup(
id);
209 explicit TestHarness(
LedgerOracle& o) : tv_(p_, clock_, clock_, o)
216 return tv_.add(v.
nodeID(), v);
219 [[nodiscard]] TestValidations&
228 return Node(nextNodeId_++, clock_);
261 using namespace std::chrono_literals;
263 TestHarness harness(h.oracle);
264 Node n = harness.makeNode();
266 auto const v = n.validate(ledgerA);
275 harness.clock().advance(1s);
282 EXPECT_TRUE(harness.vals().numTrustedForLedger(ledgerAB.id()) == 1);
283 EXPECT_TRUE(harness.vals().numTrustedForLedger(ledgerABC.id()) == 0);
288 harness.clock().advance(1s);
296 harness.clock().advance(1s);
298 EXPECT_TRUE(harness.vals().numTrustedForLedger(ledgerAB.id()) == 1);
299 EXPECT_TRUE(harness.vals().numTrustedForLedger(ledgerABC.id()) == 1);
303 harness.clock().advance(2s);
304 auto const valABCDE = n.validate(ledgerABCDE);
306 harness.clock().advance(4s);
307 auto const valABCD = n.validate(ledgerABCD);
316 using namespace std::chrono_literals;
320 TestHarness harness(h.oracle);
321 Node
const n = harness.makeNode();
327 EXPECT_TRUE(
ValStatus::Stale == harness.add(n.validate(ledgerAB, -1s, -1s)));
336 using namespace std::chrono_literals;
339 TestHarness harness(h.oracle);
340 Node
const n = harness.makeNode();
344 harness.add(n.validate(ledgerA, -harness.parms().validationCurrentEarly, 0s)));
348 harness.add(n.validate(ledgerA, harness.parms().validationCurrentWall, 0s)));
352 harness.add(n.validate(ledgerA, 0s, harness.parms().validationCurrentLocal)));
357 using namespace std::chrono_literals;
361 for (
bool doFull : {
true,
false})
363 TestHarness harness(h.oracle);
364 Node n = harness.makeNode();
366 auto const process = [&](
Ledger& lgr) {
368 return harness.add(n.validate(lgr));
369 return harness.add(n.partial(lgr));
373 harness.clock().advance(1s);
374 EXPECT_TRUE(ledgerAB.seq() < ledgerABC.seq());
380 harness.clock().advance(harness.parms().validationSetExpires + 1ms);
387 SCOPED_TRACE(
"Stale validation");
393 Ledger const ledgerAB = h[
"ab"];
398 [&](TestValidations& vals) { vals.currentTrusted(); },
399 [&](TestValidations& vals) { vals.getCurrentNodeIDs(); },
400 [&](TestValidations& vals) { vals.getPreferred(kGenesisLedger); },
401 [&](TestValidations& vals) { vals.getNodesAfter(ledgerA, ledgerA.
id()); },
403 for (Trigger
const& trigger : triggers)
405 TestHarness harness(h.
oracle);
406 Node
const n = harness.makeNode();
409 trigger(harness.vals());
410 EXPECT_TRUE(harness.vals().getNodesAfter(ledgerA, ledgerA.
id()) == 1);
412 harness.vals().getPreferred(kGenesisLedger) ==
414 harness.clock().advance(harness.parms().validationCurrentLocal);
417 trigger(harness.vals());
419 EXPECT_TRUE(harness.vals().getNodesAfter(ledgerA, ledgerA.
id()) == 0);
420 EXPECT_TRUE(harness.vals().getPreferred(kGenesisLedger) == std::nullopt);
424TEST(ValidationsTest, get_nodes_after)
430 using namespace std::chrono_literals;
431 SCOPED_TRACE(
"Get nodes after");
434 Ledger const ledgerA = h[
"a"];
435 Ledger const ledgerAB = h[
"ab"];
436 Ledger const ledgerABC = h[
"abc"];
437 Ledger const ledgerAD = h[
"ad"];
439 TestHarness harness(h.
oracle);
440 Node
const trustedNode1 = harness.makeNode();
441 Node
const trustedNode2 = harness.makeNode();
442 Node
const trustedNode3 = harness.makeNode();
444 Node notTrustedNode = harness.makeNode();
445 notTrustedNode.untrust();
453 for (
Ledger const& ledger : {ledgerA, ledgerAB, ledgerABC, ledgerAD})
454 EXPECT_TRUE(harness.vals().getNodesAfter(ledger, ledger.id()) == 0);
456 harness.clock().advance(5s);
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);
469 EXPECT_TRUE(harness.vals().getNodesAfter(ledgerAD, ledgerA.
id()) == 1);
470 EXPECT_TRUE(harness.vals().getNodesAfter(ledgerAD, ledgerAB.
id()) == 2);
473TEST(ValidationsTest, current_trusted)
475 using namespace std::chrono_literals;
476 SCOPED_TRACE(
"Current trusted validations");
479 Ledger const ledgerA = h[
"a"];
480 Ledger const ledgerB = h[
"b"];
481 Ledger const ledgerAC = h[
"ac"];
483 TestHarness harness(h.
oracle);
484 Node
const a = harness.makeNode();
485 Node b = harness.makeNode();
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());
496 harness.clock().advance(3s);
498 for (
auto const& node : {a, b})
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());
507 harness.clock().advance(harness.parms().validationCurrentLocal);
508 EXPECT_TRUE(harness.vals().currentTrusted().empty());
511TEST(ValidationsTest, get_current_public_keys)
513 using namespace std::chrono_literals;
514 SCOPED_TRACE(
"Current public keys");
517 Ledger const ledgerA = h[
"a"];
518 Ledger const ledgerAC = h[
"ac"];
520 TestHarness harness(h.
oracle);
521 Node a = harness.makeNode(), b = harness.makeNode();
524 for (
auto const& node : {a, b})
529 EXPECT_TRUE(harness.vals().getCurrentNodeIDs() == expectedKeys);
532 harness.clock().advance(3s);
538 for (
auto const& node : {a, b})
543 EXPECT_TRUE(harness.vals().getCurrentNodeIDs() == expectedKeys);
547 harness.clock().advance(harness.parms().validationCurrentLocal);
548 EXPECT_TRUE(harness.vals().getCurrentNodeIDs().empty());
551TEST(ValidationsTest, trusted_by_ledger_functions)
554 using namespace std::chrono_literals;
555 SCOPED_TRACE(
"By ledger functions");
564 TestHarness harness(h.
oracle);
566 Node a = harness.makeNode(), b = harness.makeNode(), c = harness.makeNode(),
567 d = harness.makeNode(), e = harness.makeNode();
580 auto sorted = [](
auto vec) {
584 auto const compare = [&] {
585 for (
auto const& it : trustedValidations)
587 auto const&
id = it.first.first;
588 auto const& seq = it.first.second;
589 auto const& expectedValidations = it.second;
591 EXPECT_TRUE(harness.vals().numTrustedForLedger(
id) == expectedValidations.size());
593 sorted(harness.vals().getTrustedForLedger(
id, seq)) == sorted(expectedValidations));
597 expectedFees.
reserve(expectedValidations.size());
598 for (
auto const& val : expectedValidations)
600 expectedFees.
push_back(val.loadFee().value_or(baseFee));
603 EXPECT_TRUE(sorted(harness.vals().fees(
id, baseFee)) == sorted(expectedFees));
608 Ledger const ledgerA = h[
"a"];
609 Ledger const ledgerB = h[
"b"];
610 Ledger const ledgerAC = h[
"ac"];
616 for (
auto const& node : {a, b, c})
618 auto const val = node.validate(ledgerA);
621 trustedValidations[{val.ledgerID(), val.seq()}].emplace_back(val);
625 auto const val = d.validate(ledgerB);
627 trustedValidations[{val.ledgerID(), val.seq()}].emplace_back(val);
634 harness.clock().advance(5s);
636 for (
auto const& node : {a, b, c})
638 auto const val = node.validate(ledgerAC);
641 trustedValidations[{val.ledgerID(), val.seq()}].emplace_back(val);
659 SCOPED_TRACE(
"Expire validations");
661 TestHarness harness(h.
oracle);
662 Node
const a = harness.makeNode();
667 Ledger const ledgerA = h[
"a"];
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);
677 Ledger const ledgerB = h[
"ab"];
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);
685 harness.vals().setSeqToKeep(ledgerB.
seq() + kOne, ledgerB.
seq() + kTwo);
688 harness.parms().validationSetExpires / harness.parms().validationFRESHNESS + 1;
689 for (
int i = 0; i < loops; ++i)
691 harness.clock().advance(harness.parms().validationFRESHNESS);
692 expireValidations(harness.vals());
694 EXPECT_TRUE(harness.vals().numTrustedForLedger(ledgerB.
id()) == 0);
697 Ledger const ledgerC = h[
"abc"];
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);
709 using namespace std::chrono_literals;
710 SCOPED_TRACE(
"Flush validations");
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();
719 Ledger const ledgerA = h[
"a"];
720 Ledger const ledgerAB = h[
"ab"];
723 for (
auto const& node : {trustedNode1, trustedNode2, notTrustedNode})
725 auto const val = node.validate(ledgerA);
727 expected.
emplace(node.nodeID(), val);
732 harness.clock().advance(1s);
733 auto const newVal = trustedNode1.validate(ledgerAB);
735 expected.
find(trustedNode1.nodeID())->second = newVal;
738TEST(ValidationsTest, get_preferred_ledger)
740 using namespace std::chrono_literals;
741 SCOPED_TRACE(
"Preferred Ledger");
744 TestHarness harness(h.
oracle);
745 Node
const trustedNode1 = harness.makeNode();
746 Node
const trustedNode2 = harness.makeNode();
747 Node
const trustedNode3 = harness.makeNode();
749 Node notTrustedNode = harness.makeNode();
750 notTrustedNode.untrust();
752 Ledger const ledgerA = h[
"a"];
753 Ledger const ledgerB = h[
"b"];
754 Ledger const ledgerAC = h[
"ac"];
755 Ledger const ledgerACD = h[
"acd"];
762 EXPECT_TRUE(harness.vals().getPreferred(ledgerA) == std::nullopt);
766 EXPECT_TRUE(harness.vals().getPreferred(ledgerA) == pref(ledgerB));
767 EXPECT_TRUE(harness.vals().getPreferred(ledgerB) == pref(ledgerB));
770 EXPECT_TRUE(harness.vals().getPreferred(ledgerA,
Seq{10}) == ledgerA.
id());
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));
782 EXPECT_TRUE(harness.vals().getPreferred(ledgerA) == pref(ledgerA));
783 EXPECT_TRUE(harness.vals().getPreferred(ledgerB) == pref(ledgerA));
785 harness.clock().advance(5s);
788 for (
auto const& node : {trustedNode1, trustedNode2, notTrustedNode, trustedNode3})
791 EXPECT_TRUE(harness.vals().getPreferred(ledgerA) == pref(ledgerA));
793 EXPECT_TRUE(harness.vals().getPreferred(ledgerB) == pref(ledgerAC));
795 EXPECT_TRUE(harness.vals().getPreferred(ledgerACD) == pref(ledgerACD));
798 harness.clock().advance(5s);
799 for (
auto const& node : {trustedNode1, trustedNode2, notTrustedNode, trustedNode3})
801 for (
auto const& ledger : {ledgerA, ledgerB, ledgerACD})
802 EXPECT_TRUE(harness.vals().getPreferred(ledger) == pref(ledgerACD));
805TEST(ValidationsTest, get_preferred_lcl)
807 using namespace std::chrono_literals;
808 SCOPED_TRACE(
"Get preferred LCL");
811 TestHarness harness(h.
oracle);
812 Node
const a = harness.makeNode();
814 Ledger const ledgerA = h[
"a"];
815 Ledger const ledgerB = h[
"b"];
816 Ledger const ledgerC = h[
"c"];
824 EXPECT_TRUE(harness.vals().getPreferredLCL(ledgerA,
Seq{0}, peerCounts) == ledgerA.
id());
826 ++peerCounts[ledgerB.
id()];
829 EXPECT_TRUE(harness.vals().getPreferredLCL(ledgerA,
Seq{0}, peerCounts) == ledgerB.
id());
831 ++peerCounts[ledgerC.
id()];
833 EXPECT_TRUE(ledgerC.
id() > ledgerB.
id());
835 EXPECT_TRUE(harness.vals().getPreferredLCL(ledgerA,
Seq{0}, peerCounts) == ledgerC.
id());
837 peerCounts[ledgerC.
id()] += 1000;
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());
847 EXPECT_TRUE(harness.vals().getPreferredLCL(ledgerB,
Seq{2}, peerCounts) == ledgerB.
id());
850TEST(ValidationsTest, acquire_validated_ledger)
852 using namespace std::chrono_literals;
853 SCOPED_TRACE(
"Acquire validated ledger");
856 TestHarness harness(h.
oracle);
857 Node
const a = harness.makeNode();
858 Node
const b = harness.makeNode();
864 Validation const val = a.validate(ID{2},
Seq{2}, 0s, 0s,
true);
868 EXPECT_TRUE(harness.vals().numTrustedForLedger(ID{2}) == 1);
870 EXPECT_TRUE(harness.vals().getNodesAfter(kGenesisLedger, ID{0}) == 0);
873 EXPECT_TRUE(harness.vals().getPreferred(kGenesisLedger) ==
std::make_pair(
Seq{2}, ID{2}));
878 EXPECT_TRUE(harness.vals().getPreferred(kGenesisLedger) ==
std::make_pair(
Seq{2}, ID{3}));
881 Ledger const ledgerAB = h[
"ab"];
883 EXPECT_TRUE(harness.vals().getNodesAfter(kGenesisLedger, ID{0}) == 1);
886 harness.clock().advance(5s);
887 Validation const val2 = a.validate(ID{4},
Seq{4}, 0s, 0s,
true);
889 EXPECT_TRUE(harness.vals().numTrustedForLedger(ID{4}) == 1);
891 harness.vals().getPreferred(kGenesisLedger) ==
895 Validation const val3 = b.validate(ID{4},
Seq{4}, 0s, 0s,
true);
897 EXPECT_TRUE(harness.vals().numTrustedForLedger(ID{4}) == 2);
899 harness.vals().getPreferred(kGenesisLedger) ==
903 harness.clock().advance(5s);
904 Ledger const ledgerABCDE = h[
"abcde"];
908 harness.vals().getPreferred(kGenesisLedger) ==
912TEST(ValidationsTest, num_trusted_for_ledger)
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"];
922 EXPECT_TRUE(harness.vals().numTrustedForLedger(ledgerA.
id()) == 0);
925 EXPECT_TRUE(harness.vals().numTrustedForLedger(ledgerA.
id()) == 1);
928TEST(ValidationsTest, seq_enforcer)
930 SCOPED_TRACE(
"SeqEnforcer");
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));
944 EXPECT_TRUE(!enforcer(
clock.now(),
Seq{1}, p));
946 EXPECT_TRUE(enforcer(
clock.now(),
Seq{1}, p));
949TEST(ValidationsTest, trust_changed)
951 SCOPED_TRACE(
"TrustChanged");
954 auto const checker = [&](TestValidations& vals,
958 trustedVals.empty() ? kGenesisLedger.id() : trustedVals[0].ledgerID();
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())
966 EXPECT_TRUE(vals.getPreferred(kGenesisLedger) == std::nullopt);
970 EXPECT_TRUE(vals.getPreferred(kGenesisLedger)->second == testID);
972 EXPECT_TRUE(vals.getTrustedForLedger(testID, testSeq) == trustedVals);
973 EXPECT_TRUE(vals.numTrustedForLedger(testID) == trustedVals.size());
979 TestHarness harness(h.
oracle);
980 Node
const a = harness.makeNode();
981 Ledger const ledgerAB = h[
"ab"];
987 checker(harness.vals(), listed, trustedVals);
990 harness.vals().trustChanged({}, {a.nodeID()});
991 checker(harness.vals(), listed, trustedVals);
997 TestHarness harness(h.
oracle);
998 Node a = harness.makeNode();
1000 Ledger const ledgerAB = h[
"ab"];
1006 checker(harness.vals(), listed, trustedVals);
1008 trustedVals.push_back(v);
1009 harness.vals().trustChanged({a.nodeID()}, {});
1010 checker(harness.vals(), listed, trustedVals);
1016 TestHarness harness(h.
oracle);
1017 Node
const a = harness.makeNode();
1023 auto& vals = harness.vals();
1024 EXPECT_TRUE(vals.currentTrusted() == trustedVals);
1027 EXPECT_TRUE(vals.getPreferred(kGenesisLedger)->second == v.
ledgerID());
1028 EXPECT_TRUE(vals.getNodesAfter(kGenesisLedger, kGenesisLedger.id()) == 0);
1030 trustedVals.clear();
1031 harness.vals().trustChanged({}, {a.nodeID()});
1034 EXPECT_TRUE(vals.currentTrusted() == trustedVals);
1035 EXPECT_TRUE(vals.getPreferred(kGenesisLedger) == std::nullopt);
1036 EXPECT_TRUE(vals.getNodesAfter(kGenesisLedger, kGenesisLedger.id()) == 0);
Abstract interface to a clock.
A generic endpoint for log messages.
Manual clock implementation.
std::chrono::time_point< NetClock > time_point
std::chrono::duration< rep, period > duration
Enforce validation increasing sequence requirement.
static TestSink & instance()
Maintains current and recent ledger validations.
Oracle maintaining unique ledgers for a simulation.
std::optional< Ledger > lookup(Ledger::ID const &id) const
Find the ledger with the given ID.
A ledger is a set of observed transactions and a sequence number identifying the ledger.
TaggedInteger< std::uint32_t, IdTag > ID
TaggedInteger< std::uint32_t, SeqTag > Seq
Validation of a specific ledger by a specific Peer.
PeerID const & nodeID() const
Ledger::ID ledgerID() const
T duration_cast(T... args)
TEST_F(AddValidationTest, sequencing_key_rotation_and_out_of_order_arrival)
TaggedInteger< std::uint32_t, PeerIDTag > PeerID
TEST(ValidationsTest, on_stale)
std::pair< PeerID, std::uint32_t > PeerKey
The current key of a peer.
json::Value trust(Account const &account, STAmount const &amount, std::uint32_t flags)
Modify a trust line.
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
Timing parameters to control validation staleness and expiration.
std::chrono::seconds validationSetExpires
Duration a set of validations for a given ledger hash remain valid.
Helper for writing unit tests with controlled ledger histories.
Set the sequence number on a JTx.