540 using namespace std::chrono_literals;
544 auto const checkAvailable =
546 auto const& trustedKeys,
547 auto const& hexPublic,
548 auto const& manifest,
551 auto const available = trustedKeys->getAvailable(hexPublic);
553 BEAST_EXPECT(!version || available);
556 auto const& a = *available;
557 BEAST_EXPECT(a[jss::public_key] == hexPublic);
558 BEAST_EXPECT(a[jss::manifest] == manifest);
561 BEAST_EXPECT(a[jss::version] == version);
564 BEAST_EXPECT(expected.size() == 1);
565 BEAST_EXPECT(a[jss::blob] == expected[0].first);
566 BEAST_EXPECT(a[jss::signature] == expected[0].second);
567 BEAST_EXPECT(!a.isMember(jss::blobs_v2));
569 else if (BEAST_EXPECT(a.isMember(jss::blobs_v2)))
571 BEAST_EXPECT(!a.isMember(jss::blob));
572 BEAST_EXPECT(!a.isMember(jss::signature));
573 auto const& blobsV2 = a[jss::blobs_v2];
574 BEAST_EXPECT(blobsV2.isArray() && blobsV2.size() == expected.size());
576 for (
unsigned int i = 0; i < expected.size(); ++i)
578 BEAST_EXPECT(blobsV2[i][jss::blob] == expected[i].first);
579 BEAST_EXPECT(blobsV2[i][jss::signature] == expected[i].second);
587 auto& app = env.
app();
596 for (
auto const& val : list)
598 BEAST_EXPECT(trustedKeys->listed(val.masterPublic));
599 BEAST_EXPECT(trustedKeys->listed(val.signingPublic));
604 for (
auto const& val : list)
606 BEAST_EXPECT(!trustedKeys->listed(val.masterPublic));
607 BEAST_EXPECT(!trustedKeys->listed(val.signingPublic));
613 auto const hexPublic =
strHex(publisherPublic.begin(), publisherPublic.end());
616 publisherPublic, publisherSecret, pubSigningKeys1.first, pubSigningKeys1.second, 1));
621 BEAST_EXPECT(trustedKeys->load({}, emptyCfgKeys, cfgPublisherKeys));
624 static constexpr auto kListSize = 20;
625 static constexpr auto kNumLists = 9;
628 for (
auto i = 1; i <= kNumLists; ++i)
630 auto& list = lists[i];
631 list.reserve(kListSize);
632 while (list.size() < kListSize)
640 auto const version = 1;
641 auto const sequence1 = 1;
642 auto const expiredblob =
644 auto const expiredSig =
signList(expiredblob, pubSigningKeys1);
647 auto const sequence2 = 2;
649 auto const sig2 =
signList(blob2, pubSigningKeys1);
652 trustedKeys->applyLists(
656 {.blob = expiredblob, .signature = expiredSig, .manifest = {}},
657 {.blob = blob2, .signature = sig2, .manifest = {}},
664 expectTrusted(lists.at(2));
666 checkAvailable(trustedKeys, hexPublic, manifest1, version, {{blob2, sig2}});
669 auto const version2 = 2;
670 auto const sequence7 = 7;
671 auto const effective7 = validUntil - 60s;
672 auto const expiration7 = effective7 + 3600s;
676 expiration7.time_since_epoch().count(),
677 effective7.time_since_epoch().count());
678 auto const sig7 = signList(blob7, pubSigningKeys1);
680 auto const sequence8 = 8;
681 auto const effective8 = expiration7 - 60s;
682 auto const expiration8 = effective8 + 3600s;
686 expiration8.time_since_epoch().count(),
687 effective8.time_since_epoch().count());
688 auto const sig8 = signList(blob8, pubSigningKeys1);
691 trustedKeys->applyLists(
695 {.blob = blob7, .signature = sig7, .manifest = {}},
696 {.blob = blob8, .signature = sig8, .manifest = {}},
700 ListDisposition::Pending,
701 ListDisposition::Pending);
703 expectUntrusted(lists.at(7));
704 expectUntrusted(lists.at(8));
707 auto const sequence6 = 6;
708 auto const effective6 = effective7 - 60s;
709 auto const expiration6 = effective6 + 3600s;
713 expiration6.time_since_epoch().count(),
714 effective6.time_since_epoch().count());
715 auto const sig6 = signList(blob6, pubSigningKeys1);
718 auto const sequence6a = 5;
719 auto const effective6a = effective6 + 60s;
720 auto const expiration6a = effective6a + 3600s;
724 expiration6a.time_since_epoch().count(),
725 effective6a.time_since_epoch().count());
726 auto const sig6a = signList(blob6a, pubSigningKeys1);
729 trustedKeys->applyLists(
733 {.blob = blob6a, .signature = sig6a, .manifest = {}},
734 {.blob = blob6, .signature = sig6, .manifest = {}},
738 ListDisposition::Pending,
739 ListDisposition::Pending);
741 expectUntrusted(lists.at(6));
742 expectTrusted(lists.at(2));
747 trustedKeys->applyLists(
751 {.blob = blob7, .signature = sig7, .manifest = {}},
752 {.blob = blob6, .signature = sig6, .manifest = {}},
756 ListDisposition::KnownSequence,
757 ListDisposition::KnownSequence);
759 expectUntrusted(lists.at(6));
760 expectUntrusted(lists.at(7));
761 expectTrusted(lists.at(2));
765 trustedKeys->applyLists(
769 {.blob = blob7, .signature = sig7, .manifest = {}},
770 {.blob = blob6, .signature = sig6, .manifest = {}},
774 ListDisposition::Invalid,
775 ListDisposition::Invalid);
778 trustedKeys->applyLists(
782 {.blob = blob7, .signature = sig7, .manifest = {}},
783 {.blob = blob6, .signature = sig6, .manifest = {}},
787 ListDisposition::Invalid,
788 ListDisposition::Invalid);
791 auto const untrustedManifest =
base64Encode(makeManifestString(
792 randomMasterKey(), publisherSecret, pubSigningKeys1.first, pubSigningKeys1.second, 1));
795 trustedKeys->applyLists(
798 {{.blob = blob2, .signature = sig2, .manifest = {}}},
801 ListDisposition::Untrusted,
802 ListDisposition::Untrusted);
805 auto const badVersion = 666;
807 trustedKeys->applyLists(
810 {{.blob = blob2, .signature = sig2, .manifest = {}}},
813 ListDisposition::UnsupportedVersion,
814 ListDisposition::UnsupportedVersion);
817 auto const sequence3 = 3;
818 auto const blob3 =
makeList(lists.at(3), sequence3, validUntil.time_since_epoch().count());
819 auto const sig3 = signList(blob3, pubSigningKeys1);
822 trustedKeys->applyLists(
823 manifest1, version, {{.blob = blob3, .signature = sig3, .manifest = {}}}, siteUri),
825 ListDisposition::Accepted,
826 ListDisposition::Accepted);
828 expectUntrusted(lists.at(1));
829 expectUntrusted(lists.at(2));
830 expectTrusted(lists.at(3));
839 {{blob3, sig3}, {blob6, sig6}, {blob7, sig7}, {blob8, sig8}});
843 trustedKeys->applyLists(
847 {.blob = blob2, .signature = sig2, .manifest = {}},
848 {.blob = blob3, .signature = sig3, .manifest = {}},
852 ListDisposition::Stale,
853 ListDisposition::SameSequence);
857 auto const pubSigningKeys2 =
randomKeyPair(KeyType::Secp256k1);
859 publisherPublic, publisherSecret, pubSigningKeys2.first, pubSigningKeys2.second, 2));
861 auto const sequence4 = 4;
862 auto const blob4 =
makeList(lists.at(4), sequence4, validUntil.time_since_epoch().count());
863 auto const sig4 = signList(blob4, pubSigningKeys2);
866 trustedKeys->applyLists(
870 {.blob = blob2, .signature = sig2, .manifest = manifest1},
871 {.blob = blob3, .signature = sig3, .manifest = manifest1},
872 {.blob = blob4, .signature = sig4, .manifest = {}},
876 ListDisposition::Stale,
877 ListDisposition::Accepted);
879 expectUntrusted(lists.at(2));
880 expectUntrusted(lists.at(3));
881 expectTrusted(lists.at(4));
888 {{blob4, sig4}, {blob6, sig6}, {blob7, sig7}, {blob8, sig8}});
890 auto const sequence5 = 5;
891 auto const blob5 =
makeList(lists.at(5), sequence5, validUntil.time_since_epoch().count());
892 auto const badSig = signList(blob5, pubSigningKeys1);
894 trustedKeys->applyLists(
897 {{.blob = blob5, .signature = badSig, .manifest = {}}},
900 ListDisposition::Invalid,
901 ListDisposition::Invalid);
903 expectUntrusted(lists.at(2));
904 expectUntrusted(lists.at(3));
905 expectTrusted(lists.at(4));
906 expectUntrusted(lists.at(5));
910 trustedKeys->applyLists(
914 {.blob = blob7, .signature = sig7, .manifest = {}},
915 {.blob = blob8, .signature = sig8, .manifest = {}},
919 ListDisposition::Invalid,
920 ListDisposition::Invalid);
922 expectTrusted(lists.at(4));
923 expectUntrusted(lists.at(7));
924 expectUntrusted(lists.at(8));
929 trustedKeys->updateTrusted(
933 env.app().getOverlay(),
934 env.app().getHashRouter());
936 expectUntrusted(lists.at(3));
937 expectTrusted(lists.at(6));
940 trustedKeys, hexPublic, manifest2, 2, {{blob6, sig6}, {blob7, sig7}, {blob8, sig8}});
946 env.timeKeeper().set(effective8);
947 trustedKeys->updateTrusted(
951 env.app().getOverlay(),
952 env.app().getHashRouter());
954 expectUntrusted(lists.at(6));
955 expectUntrusted(lists.at(7));
956 expectTrusted(lists.at(8));
958 checkAvailable(trustedKeys, hexPublic, manifest2, 2, {{blob8, sig8}});
964 auto const sig82 = signList(blob8, pubSigningKeys2);
967 trustedKeys->applyLists(
971 {.blob = blob8, .signature = sig8, .manifest = manifest1},
972 {.blob = blob8, .signature = sig82, .manifest = {}},
976 ListDisposition::Invalid,
977 ListDisposition::SameSequence);
979 expectTrusted(lists.at(8));
981 checkAvailable(trustedKeys, hexPublic, manifest2, 2, {{blob8, sig8}});
985 auto const signingKeysMax =
randomKeyPair(KeyType::Secp256k1);
986 auto const maxManifest =
987 base64Encode(makeRevocationString(publisherPublic, publisherSecret));
989 auto const sequence9 = 9;
990 auto const blob9 =
makeList(lists.at(9), sequence9, validUntil.time_since_epoch().count());
991 auto const sig9 = signList(blob9, signingKeysMax);
994 trustedKeys->applyLists(
997 {{.blob = blob9, .signature = sig9, .manifest = {}}},
1000 ListDisposition::Untrusted,
1001 ListDisposition::Untrusted);
1003 BEAST_EXPECT(!trustedKeys->trustedPublisher(publisherPublic));
1004 for (
auto const& [num, list] : lists)
1007 expectUntrusted(list);
1010 checkAvailable(trustedKeys, hexPublic, manifest2, 0, {});
1150 std::string const siteUri =
"testUpdateTrusted.test";
1154 auto& app = env.
app();
1171 while (cfgKeys.
size() != maxKeys)
1175 if (cfgKeys.
size() <= maxKeys - 5)
1185 BEAST_EXPECT(trustedKeysOuter->load({}, cfgKeys, cfgPublishersOuter));
1189 TrustChanges changes = trustedKeysOuter->updateTrusted(
1190 activeValidatorsOuter,
1196 for (
auto const& val : unseenValidators)
1197 activeValidatorsOuter.
emplace(val);
1199 BEAST_EXPECT(changes.
added == activeValidatorsOuter);
1200 BEAST_EXPECT(changes.
removed.empty());
1201 BEAST_EXPECT(trustedKeysOuter->quorum() ==
std::ceil(cfgKeys.
size() * 0.8f));
1202 for (
auto const& val : cfgKeys)
1206 BEAST_EXPECT(trustedKeysOuter->listed(*valKey));
1207 BEAST_EXPECT(trustedKeysOuter->trusted(*valKey));
1215 changes = trustedKeysOuter->updateTrusted(
1216 activeValidatorsOuter,
1221 BEAST_EXPECT(changes.
added.empty());
1222 BEAST_EXPECT(changes.
removed.empty());
1223 BEAST_EXPECT(trustedKeysOuter->quorum() ==
std::ceil(cfgKeys.
size() * 0.8f));
1232 BEAST_EXPECT(trustedKeysOuter->load({}, cfgKeys, cfgPublishersOuter));
1235 auto const signingPublic1 = signingKeys1.first;
1239 TrustChanges changes = trustedKeysOuter->updateTrusted(
1240 activeValidatorsOuter,
1246 BEAST_EXPECT(changes.
removed.empty());
1247 BEAST_EXPECT(trustedKeysOuter->quorum() ==
std::ceil((maxKeys + 1) * 0.8f));
1248 BEAST_EXPECT(trustedKeysOuter->listed(masterPublic));
1249 BEAST_EXPECT(trustedKeysOuter->trusted(masterPublic));
1250 BEAST_EXPECT(!trustedKeysOuter->listed(signingPublic1));
1251 BEAST_EXPECT(!trustedKeysOuter->trusted(signingPublic1));
1255 masterPublic, masterPrivate, signingPublic1, signingKeys1.second, 1));
1261 BEAST_EXPECT(trustedKeysOuter->listed(masterPublic));
1262 BEAST_EXPECT(trustedKeysOuter->trusted(masterPublic));
1263 BEAST_EXPECT(trustedKeysOuter->listed(signingPublic1));
1264 BEAST_EXPECT(trustedKeysOuter->trusted(signingPublic1));
1269 auto const signingPublic2 = signingKeys2.first;
1271 masterPublic, masterPrivate, signingPublic2, signingKeys2.second, 2));
1276 BEAST_EXPECT(trustedKeysOuter->listed(masterPublic));
1277 BEAST_EXPECT(trustedKeysOuter->trusted(masterPublic));
1278 BEAST_EXPECT(trustedKeysOuter->listed(signingPublic2));
1279 BEAST_EXPECT(trustedKeysOuter->trusted(signingPublic2));
1280 BEAST_EXPECT(!trustedKeysOuter->listed(signingPublic1));
1281 BEAST_EXPECT(!trustedKeysOuter->trusted(signingPublic1));
1285 auto const signingPublicMax = signingKeysMax.first;
1290 BEAST_EXPECT(max->revoked());
1296 BEAST_EXPECT(manifestsOuter.
getSigningKey(masterPublic) == masterPublic);
1297 BEAST_EXPECT(manifestsOuter.
revoked(masterPublic));
1300 BEAST_EXPECT(trustedKeysOuter->listed(masterPublic));
1301 BEAST_EXPECT(trustedKeysOuter->trusted(masterPublic));
1303 changes = trustedKeysOuter->updateTrusted(
1304 activeValidatorsOuter,
1310 BEAST_EXPECT(changes.
added.empty());
1311 BEAST_EXPECT(trustedKeysOuter->quorum() ==
std::ceil(maxKeys * 0.8f));
1312 BEAST_EXPECT(trustedKeysOuter->listed(masterPublic));
1313 BEAST_EXPECT(!trustedKeysOuter->trusted(masterPublic));
1314 BEAST_EXPECT(!trustedKeysOuter->listed(signingPublicMax));
1315 BEAST_EXPECT(!trustedKeysOuter->trusted(signingPublicMax));
1316 BEAST_EXPECT(!trustedKeysOuter->listed(signingPublic2));
1317 BEAST_EXPECT(!trustedKeysOuter->trusted(signingPublic2));
1318 BEAST_EXPECT(!trustedKeysOuter->listed(signingPublic1));
1319 BEAST_EXPECT(!trustedKeysOuter->trusted(signingPublic1));
1336 BEAST_EXPECT(trustedKeys->load({}, emptyCfgKeys, cfgPublishers));
1338 TrustChanges const changes = trustedKeys->updateTrusted(
1339 activeValidatorsOuter,
1344 BEAST_EXPECT(changes.
removed.empty());
1345 BEAST_EXPECT(changes.
added.empty());
1368 BEAST_EXPECT(trustedKeys->load({}, cfgKeys, cfgPublishers,
std::size_t(2)));
1370 TrustChanges const changes = trustedKeys->updateTrusted(
1371 activeValidatorsOuter,
1376 BEAST_EXPECT(changes.
removed.empty());
1377 BEAST_EXPECT(changes.
added.size() == 1);
1378 BEAST_EXPECT(trustedKeys->listed(masterPublic));
1379 BEAST_EXPECT(trustedKeys->trusted(masterPublic));
1400 while (cfgKeys.
size() < n)
1415 BEAST_EXPECT(trustedKeys->load({}, cfgKeys, cfgPublishersOuter));
1423 BEAST_EXPECT(changes.
removed.empty());
1424 BEAST_EXPECT(changes.
added == expectedTrusted);
1425 BEAST_EXPECT(trustedKeys->quorum() == minQuorum);
1428 activeValidators.
emplace(toBeSeen);
1429 changes = trustedKeys->updateTrusted(
1435 BEAST_EXPECT(changes.
removed.empty());
1436 BEAST_EXPECT(changes.
added.empty());
1437 BEAST_EXPECT(trustedKeys->quorum() == minQuorum);
1452 publisherKeys.first,
1453 publisherKeys.second,
1454 pubSigningKeys.first,
1455 pubSigningKeys.second,
1460 BEAST_EXPECT(trustedKeys->load({}, emptyCfgKeys, cfgPublisherKeys));
1464 asNodeIDs({list[0].masterPublic, list[1].masterPublic}));
1467 auto const version = 1;
1468 auto const sequence = 1;
1469 using namespace std::chrono_literals;
1472 auto const sig =
signList(blob, pubSigningKeys);
1476 trustedKeys->applyLists(manifest, version, {{blob, sig, {}}}, siteUri)
1477 .bestDisposition());
1485 BEAST_EXPECT(changes.
removed.empty());
1486 BEAST_EXPECT(changes.
added == activeValidators);
1489 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
1490 BEAST_EXPECT(trustedKeys->trusted(val.signingPublic));
1492 BEAST_EXPECT(trustedKeys->quorum() == 2);
1495 changes = trustedKeys->updateTrusted(
1501 BEAST_EXPECT(changes.
removed == activeValidators);
1502 BEAST_EXPECT(changes.
added.empty());
1503 BEAST_EXPECT(!trustedKeys->trusted(list[0].masterPublic));
1504 BEAST_EXPECT(!trustedKeys->trusted(list[1].masterPublic));
1510 auto const sequence2 = 2;
1513 auto const sig2 =
signList(blob2, pubSigningKeys);
1517 trustedKeys->applyLists(manifest, version, {{blob2, sig2, {}}}, siteUri)
1518 .bestDisposition());
1520 changes = trustedKeys->updateTrusted(
1522 env.timeKeeper().now(),
1524 env.app().getOverlay(),
1525 env.app().getHashRouter());
1526 BEAST_EXPECT(changes.removed.empty());
1528 changes.added == asNodeIDs({list2[0].masterPublic, list2[1].masterPublic}));
1529 for (Validator
const& val : list2)
1531 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
1532 BEAST_EXPECT(trustedKeys->trusted(val.signingPublic));
1534 BEAST_EXPECT(!trustedKeys->trusted(list[1].masterPublic));
1535 BEAST_EXPECT(!trustedKeys->trusted(list[1].signingPublic));
1536 BEAST_EXPECT(trustedKeys->quorum() == 2);
1544 app.config().legacy(Sections::kDatabasePath),
1548 HashSet<NodeID> activeValidators;
1549 HashSet<PublicKey> activeKeys;
1556 auto const valKey = randomNode();
1558 activeValidators.emplace(
calcNodeID(valKey));
1559 activeKeys.emplace(valKey);
1560 BEAST_EXPECT(trustedKeys->load({}, cfgKeys, cfgPublishers));
1561 TrustChanges
const changes = trustedKeys->updateTrusted(
1563 env.timeKeeper().now(),
1565 env.app().getOverlay(),
1566 env.app().getHashRouter());
1567 BEAST_EXPECT(changes.removed.empty());
1568 BEAST_EXPECT(changes.added == asNodeIDs({valKey}));
1569 BEAST_EXPECT(trustedKeys->quorum() ==
std::ceil(cfgKeys.
size() * 0.8f));
1570 for (
auto const& key : activeKeys)
1571 BEAST_EXPECT(trustedKeys->trusted(key));
1580 app.config().legacy(Sections::kDatabasePath),
1583 auto const localKey = randomNode();
1585 HashSet<NodeID> activeValidators;
1586 HashSet<PublicKey> activeKeys;
1592 auto const valKey = randomNode();
1594 activeValidators.emplace(
calcNodeID(valKey));
1595 activeKeys.emplace(valKey);
1597 BEAST_EXPECT(trustedKeys->load(localKey, cfgKeys, cfgPublishers));
1598 TrustChanges
const changes = trustedKeys->updateTrusted(
1600 env.timeKeeper().now(),
1602 env.app().getOverlay(),
1603 env.app().getHashRouter());
1604 BEAST_EXPECT(changes.removed.empty());
1605 if (cfgKeys.
size() > 2)
1607 BEAST_EXPECT(changes.added == asNodeIDs({valKey}));
1611 BEAST_EXPECT(changes.added == asNodeIDs({localKey, valKey}));
1614 BEAST_EXPECT(trustedKeys->quorum() ==
std::ceil(cfgKeys.
size() * 0.8f));
1616 for (
auto const& key : activeKeys)
1617 BEAST_EXPECT(trustedKeys->trusted(key));
1622 ManifestCache manifests;
1627 app.config().legacy(Sections::kDatabasePath),
1630 HashSet<NodeID> activeValidators;
1634 while (valKeys.
size() != maxKeys)
1637 activeValidators.emplace(
calcNodeID(valKeys.
back().masterPublic));
1643 static constexpr int kPublishers = 3;
1645 std::pair<
decltype(valKeys)::const_iterator,
decltype(valKeys)::const_iterator>,
1653 auto const addPublishedList = [&,
this](
int i) {
1660 pubSigningKeys.first,
1661 pubSigningKeys.second,
1664 std::vector<std::string>
const cfgPublishers({
strHex(publisherPublic)});
1665 std::vector<std::string>
const emptyCfgKeys;
1668 BEAST_EXPECT(trustedKeys->load({}, emptyCfgKeys, cfgPublishers, std::size_t(1)));
1670 auto const version = 1;
1671 auto const sequence = 1;
1672 using namespace std::chrono_literals;
1674 std::vector<Validator>
const localKeys{locals[i].first, locals[i].second};
1676 makeList(localKeys, sequence, validUntil.time_since_epoch().count());
1677 auto const sig = signList(blob, pubSigningKeys);
1681 trustedKeys->applyLists(manifest, version, {{blob, sig, {}}}, siteUri)
1682 .bestDisposition());
1686 for (
auto i = 0; i < kPublishers; ++i)
1687 addPublishedList(i);
1688 BEAST_EXPECT(trustedKeys->getListThreshold() == 1);
1690 TrustChanges
const changes = trustedKeys->updateTrusted(
1692 env.timeKeeper().now(),
1694 env.app().getOverlay(),
1695 env.app().getHashRouter());
1697 BEAST_EXPECT(trustedKeys->quorum() ==
std::ceil(valKeys.
size() * 0.8f));
1700 for (
auto const& val : valKeys)
1702 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
1705 BEAST_EXPECT(changes.added == added);
1706 BEAST_EXPECT(changes.removed.empty());
1710 ManifestCache manifests;
1719 std::vector<Validator> valKeys;
1722 while (valKeys.
size() != maxKeys)
1725 activeValidators.emplace(
calcNodeID(valKeys.
back().masterPublic));
1733 static constexpr int kPublishers = 3;
1735 std::pair<
decltype(valKeys)::const_iterator,
decltype(valKeys)::const_iterator>,
1743 auto const addPublishedList =
1752 pubSigningKeys.first,
1753 pubSigningKeys.second,
1756 std::vector<std::string>
const cfgPublishers({
strHex(publisherPublic)});
1757 std::vector<std::string>
const emptyCfgKeys;
1759 BEAST_EXPECT(trustedKeys->load({}, emptyCfgKeys, cfgPublishers));
1761 auto const version = 1;
1762 auto const sequence = 1;
1763 using namespace std::chrono_literals;
1781 validUntil1 = validUntil;
1785 validUntil2 = validUntil;
1787 std::vector<Validator>
const localKeys{locals[i].first, locals[i].second};
1789 makeList(localKeys, sequence, validUntil.time_since_epoch().count());
1790 auto const sig = signList(blob, pubSigningKeys);
1794 trustedKeys->applyLists(manifest, version, {{blob, sig, {}}}, siteUri)
1795 .bestDisposition());
1801 for (
auto i = 0; i < kPublishers; ++i)
1802 addPublishedList(i, validUntil1, validUntil2);
1803 BEAST_EXPECT(trustedKeys->getListThreshold() == 2);
1805 TrustChanges changes = trustedKeys->updateTrusted(
1807 env.timeKeeper().now(),
1809 env.app().getOverlay(),
1810 env.app().getHashRouter());
1812 BEAST_EXPECT(trustedKeys->quorum() ==
std::ceil((valKeys.
size() - 3) * 0.8f));
1814 for (
auto const& val : valKeys)
1815 BEAST_EXPECT(trustedKeys->listed(val.masterPublic));
1818 for (std::size_t i = 0; i < maxKeys; ++i)
1820 auto const& val = valKeys[i];
1821 if (i >= 1 && i < maxKeys - 2)
1823 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
1828 BEAST_EXPECT(!trustedKeys->trusted(val.masterPublic));
1831 BEAST_EXPECT(changes.added == added);
1832 BEAST_EXPECT(changes.removed.empty());
1835 env.timeKeeper().set(validUntil1);
1836 changes = trustedKeys->updateTrusted(
1838 env.timeKeeper().now(),
1840 env.app().getOverlay(),
1841 env.app().getHashRouter());
1843 BEAST_EXPECT(trustedKeys->quorum() ==
std::ceil((valKeys.size() - 6) * 0.8f));
1845 for (
auto const& val : valKeys)
1846 BEAST_EXPECT(trustedKeys->listed(val.masterPublic));
1849 for (std::size_t i = 0; i < maxKeys; ++i)
1851 auto const& val = valKeys[i];
1852 if (i >= 2 && i < maxKeys - 4)
1854 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
1858 BEAST_EXPECT(!trustedKeys->trusted(val.masterPublic));
1859 if (i >= 1 && i < maxKeys - 2)
1860 removed.insert(
calcNodeID(val.masterPublic));
1864 BEAST_EXPECT(changes.added.empty());
1865 BEAST_EXPECT(changes.removed == removed);
1868 env.timeKeeper().set(validUntil2);
1869 changes = trustedKeys->updateTrusted(
1871 env.timeKeeper().now(),
1873 env.app().getOverlay(),
1874 env.app().getHashRouter());
1879 for (std::size_t i = 0; i < maxKeys; ++i)
1881 auto const& val = valKeys[i];
1882 if (i < maxKeys - 4)
1884 BEAST_EXPECT(trustedKeys->listed(val.masterPublic));
1888 BEAST_EXPECT(!trustedKeys->listed(val.masterPublic));
1891 BEAST_EXPECT(!trustedKeys->trusted(val.masterPublic));
1892 if (i >= 2 && i < maxKeys - 4)
1893 removed.insert(
calcNodeID(val.masterPublic));
1896 BEAST_EXPECT(changes.added.empty());
1897 BEAST_EXPECT(changes.removed == removed);
2520 std::string const siteUri =
"testQuorumDisabled.test";
2522 auto& app = env.
app();
2527 while (valKeys.
size() != kMaxKeys)
2544 auto const makeValidatorList = [&,
this](
2572 pubSigningKeys.first,
2573 pubSigningKeys.second,
2574 i < countRevoked ? kRevoked : 1));
2575 publishers.push_back(
2577 .revoked = i < countRevoked,
2578 .pubKey = publisherPublic,
2579 .signingKeys = pubSigningKeys,
2580 .manifest = manifest,
2585 auto const threshold = listThreshold > 0 ?
std::optional(listThreshold) : std::nullopt;
2588 valManifests.applyManifest(
2592 result->load(self->signingPublic, emptyCfgKeys, cfgPublishers, threshold));
2596 BEAST_EXPECT(result->load({}, emptyCfgKeys, cfgPublishers, threshold));
2601 using namespace std::chrono_literals;
2602 publishers[i].expiry = env.
timeKeeper().
now() + (i == countTotal - 1 ? 60s : 3600s);
2604 makeList(valKeys, 1, publishers[i].expiry.time_since_epoch().count());
2605 auto const sig =
signList(blob, publishers[i].signingKeys);
2608 result->applyLists(publishers[i].manifest, 1, {{blob, sig, {}}}, siteUri)
2609 .bestDisposition() ==
2625 auto const self = randomValidator();
2626 auto const keysTotal = valKeys.size() + 1;
2627 auto trustedKeys = makeValidatorList(
2635 BEAST_EXPECT(trustedKeys->getListThreshold() == 5);
2636 for (
auto const& p : publishers)
2637 BEAST_EXPECT(trustedKeys->trustedPublisher(p.pubKey));
2641 env.timeKeeper().now(),
2643 env.app().getOverlay(),
2644 env.app().getHashRouter());
2645 BEAST_EXPECT(trustedKeys->quorum() ==
std::ceil(keysTotal * 0.8f));
2646 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
2650 for (
auto const& val : valKeys)
2652 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
2655 BEAST_EXPECT(changes.
added == added);
2656 BEAST_EXPECT(changes.
removed.empty());
2659 env.timeKeeper().set(publishers.back().expiry);
2660 changes = trustedKeys->updateTrusted(
2662 env.timeKeeper().now(),
2664 env.app().getOverlay(),
2665 env.app().getHashRouter());
2666 BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled);
2667 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == 1);
2670 BEAST_EXPECT(trustedKeys->trusted(self.masterPublic));
2671 for (
auto const& val : valKeys)
2673 BEAST_EXPECT(trustedKeys->listed(val.masterPublic));
2674 BEAST_EXPECT(!trustedKeys->trusted(val.masterPublic));
2677 BEAST_EXPECT(changes.
added.empty());
2678 BEAST_EXPECT(changes.
removed == removed);
2682 ManifestCache pubManifests;
2683 ManifestCache valManifests;
2684 std::vector<Publisher> publishers;
2685 auto const keysTotal = valKeys.size();
2686 auto trustedKeys = makeValidatorList(
2694 BEAST_EXPECT(trustedKeys->getListThreshold() == 5);
2695 for (
auto const& p : publishers)
2696 BEAST_EXPECT(trustedKeys->trustedPublisher(p.pubKey));
2698 TrustChanges changes = trustedKeys->updateTrusted(
2700 env.timeKeeper().now(),
2702 env.app().getOverlay(),
2703 env.app().getHashRouter());
2704 BEAST_EXPECT(trustedKeys->quorum() ==
std::ceil(keysTotal * 0.8f));
2705 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
2708 for (
auto const& val : valKeys)
2710 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
2713 BEAST_EXPECT(changes.added == added);
2714 BEAST_EXPECT(changes.removed.empty());
2717 env.timeKeeper().set(publishers.back().expiry);
2718 changes = trustedKeys->updateTrusted(
2720 env.timeKeeper().now(),
2722 env.app().getOverlay(),
2723 env.app().getHashRouter());
2724 BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled);
2725 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().empty());
2728 for (
auto const& val : valKeys)
2730 BEAST_EXPECT(trustedKeys->listed(val.masterPublic));
2731 BEAST_EXPECT(!trustedKeys->trusted(val.masterPublic));
2732 removed.insert(
calcNodeID(val.masterPublic));
2734 BEAST_EXPECT(changes.added.empty());
2735 BEAST_EXPECT(changes.removed == removed);
2739 ManifestCache pubManifests;
2740 ManifestCache valManifests;
2741 std::vector<Publisher> publishers;
2743 auto const self = valKeys[1];
2744 auto const keysTotal = valKeys.size();
2745 auto trustedKeys = makeValidatorList(
2753 BEAST_EXPECT(trustedKeys->getListThreshold() == 4);
2754 int untrustedCount = 0;
2755 for (
auto const& p : publishers)
2757 bool const trusted = trustedKeys->trustedPublisher(p.pubKey);
2758 BEAST_EXPECT(p.revoked ^ trusted);
2759 untrustedCount += trusted ? 0 : 1;
2761 BEAST_EXPECT(untrustedCount == 1);
2763 TrustChanges changes = trustedKeys->updateTrusted(
2765 env.timeKeeper().now(),
2767 env.app().getOverlay(),
2768 env.app().getHashRouter());
2769 BEAST_EXPECT(trustedKeys->quorum() ==
std::ceil(keysTotal * 0.8f));
2770 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
2773 for (
auto const& val : valKeys)
2775 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
2778 BEAST_EXPECT(changes.added == added);
2779 BEAST_EXPECT(changes.removed.empty());
2782 env.timeKeeper().set(publishers.back().expiry);
2783 changes = trustedKeys->updateTrusted(
2785 env.timeKeeper().now(),
2787 env.app().getOverlay(),
2788 env.app().getHashRouter());
2789 BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled);
2790 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == 1);
2793 BEAST_EXPECT(trustedKeys->trusted(self.masterPublic));
2794 for (
auto const& val : valKeys)
2796 BEAST_EXPECT(trustedKeys->listed(val.masterPublic));
2797 if (val.masterPublic != self.masterPublic)
2799 BEAST_EXPECT(!trustedKeys->trusted(val.masterPublic));
2800 removed.insert(
calcNodeID(val.masterPublic));
2803 BEAST_EXPECT(changes.added.empty());
2804 BEAST_EXPECT(changes.removed == removed);
2808 ManifestCache pubManifests;
2809 ManifestCache valManifests;
2810 std::vector<Publisher> publishers;
2812 auto const self = randomValidator();
2813 auto const keysTotal = valKeys.size() + 1;
2814 auto trustedKeys = makeValidatorList(
2822 BEAST_EXPECT(trustedKeys->getListThreshold() == 3);
2823 int untrustedCount = 0;
2824 for (
auto const& p : publishers)
2826 bool const trusted = trustedKeys->trustedPublisher(p.pubKey);
2827 BEAST_EXPECT(p.revoked ^ trusted);
2828 untrustedCount += trusted ? 0 : 1;
2830 BEAST_EXPECT(untrustedCount == 2);
2832 TrustChanges changes = trustedKeys->updateTrusted(
2834 env.timeKeeper().now(),
2836 env.app().getOverlay(),
2837 env.app().getHashRouter());
2838 BEAST_EXPECT(trustedKeys->quorum() ==
std::ceil(keysTotal * 0.8f));
2839 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
2843 for (
auto const& val : valKeys)
2845 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
2848 BEAST_EXPECT(changes.added == added);
2849 BEAST_EXPECT(changes.removed.empty());
2852 env.timeKeeper().set(publishers.back().expiry);
2853 changes = trustedKeys->updateTrusted(
2855 env.timeKeeper().now(),
2857 env.app().getOverlay(),
2858 env.app().getHashRouter());
2859 BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled);
2860 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == 1);
2863 BEAST_EXPECT(trustedKeys->trusted(self.masterPublic));
2864 for (
auto const& val : valKeys)
2866 BEAST_EXPECT(trustedKeys->listed(val.masterPublic));
2867 BEAST_EXPECT(!trustedKeys->trusted(val.masterPublic));
2868 removed.insert(
calcNodeID(val.masterPublic));
2870 BEAST_EXPECT(changes.added.empty());
2871 BEAST_EXPECT(changes.removed == removed);
2875 ManifestCache pubManifests;
2876 ManifestCache valManifests;
2877 std::vector<Publisher> publishers;
2879 auto const self = valKeys[5];
2880 auto const keysTotal = valKeys.size();
2881 auto trustedKeys = makeValidatorList(
2889 BEAST_EXPECT(trustedKeys->getListThreshold() == 3);
2890 int untrustedCount = 0;
2891 for (
auto const& p : publishers)
2893 bool const trusted = trustedKeys->trustedPublisher(p.pubKey);
2894 BEAST_EXPECT(p.revoked ^ trusted);
2895 untrustedCount += trusted ? 0 : 1;
2897 BEAST_EXPECT(untrustedCount == 2);
2899 TrustChanges changes = trustedKeys->updateTrusted(
2901 env.timeKeeper().now(),
2903 env.app().getOverlay(),
2904 env.app().getHashRouter());
2905 BEAST_EXPECT(trustedKeys->quorum() ==
std::ceil(keysTotal * 0.8f));
2906 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
2909 for (
auto const& val : valKeys)
2911 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
2914 BEAST_EXPECT(changes.added == added);
2915 BEAST_EXPECT(changes.removed.empty());
2918 env.timeKeeper().set(publishers.back().expiry);
2919 changes = trustedKeys->updateTrusted(
2921 env.timeKeeper().now(),
2923 env.app().getOverlay(),
2924 env.app().getHashRouter());
2925 BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled);
2926 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == 1);
2929 BEAST_EXPECT(trustedKeys->trusted(self.masterPublic));
2930 for (
auto const& val : valKeys)
2932 BEAST_EXPECT(trustedKeys->listed(val.masterPublic));
2933 if (val.masterPublic != self.masterPublic)
2935 BEAST_EXPECT(!trustedKeys->trusted(val.masterPublic));
2936 removed.insert(
calcNodeID(val.masterPublic));
2939 BEAST_EXPECT(changes.added.empty());
2940 BEAST_EXPECT(changes.removed == removed);
2944 ManifestCache pubManifests;
2945 ManifestCache valManifests;
2946 std::vector<Publisher> publishers;
2947 auto const keysTotal = valKeys.size();
2948 auto trustedKeys = makeValidatorList(
2956 BEAST_EXPECT(trustedKeys->getListThreshold() == 3);
2957 int untrustedCount = 0;
2958 for (
auto const& p : publishers)
2960 bool const trusted = trustedKeys->trustedPublisher(p.pubKey);
2961 BEAST_EXPECT(p.revoked ^ trusted);
2962 untrustedCount += trusted ? 0 : 1;
2964 BEAST_EXPECT(untrustedCount == 2);
2966 TrustChanges changes = trustedKeys->updateTrusted(
2968 env.timeKeeper().now(),
2970 env.app().getOverlay(),
2971 env.app().getHashRouter());
2972 BEAST_EXPECT(trustedKeys->quorum() ==
std::ceil(keysTotal * 0.8f));
2973 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
2976 for (
auto const& val : valKeys)
2978 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
2981 BEAST_EXPECT(changes.added == added);
2982 BEAST_EXPECT(changes.removed.empty());
2985 env.timeKeeper().set(publishers.back().expiry);
2986 changes = trustedKeys->updateTrusted(
2988 env.timeKeeper().now(),
2990 env.app().getOverlay(),
2991 env.app().getHashRouter());
2992 BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled);
2993 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().empty());
2996 for (
auto const& val : valKeys)
2998 BEAST_EXPECT(trustedKeys->listed(val.masterPublic));
2999 BEAST_EXPECT(!trustedKeys->trusted(val.masterPublic));
3000 removed.insert(
calcNodeID(val.masterPublic));
3002 BEAST_EXPECT(changes.added.empty());
3003 BEAST_EXPECT(changes.removed == removed);
3007 ManifestCache pubManifests;
3008 ManifestCache valManifests;
3009 std::vector<Publisher> publishers;
3011 auto const self = randomValidator();
3012 auto const keysTotal = valKeys.size() + 1;
3013 auto trustedKeys = makeValidatorList(
3021 BEAST_EXPECT(trustedKeys->getListThreshold() == 2);
3022 int untrustedCount = 0;
3023 for (
auto const& p : publishers)
3025 bool const trusted = trustedKeys->trustedPublisher(p.pubKey);
3026 BEAST_EXPECT(p.revoked ^ trusted);
3027 untrustedCount += trusted ? 0 : 1;
3029 BEAST_EXPECT(untrustedCount == 1);
3031 TrustChanges changes = trustedKeys->updateTrusted(
3033 env.timeKeeper().now(),
3035 env.app().getOverlay(),
3036 env.app().getHashRouter());
3037 BEAST_EXPECT(trustedKeys->quorum() ==
std::ceil(keysTotal * 0.8f));
3038 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
3042 for (
auto const& val : valKeys)
3044 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
3047 BEAST_EXPECT(changes.added == added);
3048 BEAST_EXPECT(changes.removed.empty());
3051 env.timeKeeper().set(publishers.back().expiry);
3052 changes = trustedKeys->updateTrusted(
3054 env.timeKeeper().now(),
3056 env.app().getOverlay(),
3057 env.app().getHashRouter());
3058 BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled);
3059 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
3061 BEAST_EXPECT(trustedKeys->trusted(self.masterPublic));
3062 for (
auto const& val : valKeys)
3064 BEAST_EXPECT(trustedKeys->listed(val.masterPublic));
3065 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
3067 BEAST_EXPECT(changes.added.empty());
3068 BEAST_EXPECT(changes.removed.empty());
3072 ManifestCache pubManifests;
3073 ManifestCache valManifests;
3074 std::vector<Publisher> publishers;
3076 auto const self = randomValidator();
3077 auto const keysTotal = valKeys.size() + 1;
3078 auto trustedKeys = makeValidatorList(
3086 BEAST_EXPECT(trustedKeys->getListThreshold() == 1);
3087 for (
auto const& p : publishers)
3088 BEAST_EXPECT(trustedKeys->trustedPublisher(p.pubKey));
3090 TrustChanges changes = trustedKeys->updateTrusted(
3092 env.timeKeeper().now(),
3094 env.app().getOverlay(),
3095 env.app().getHashRouter());
3096 BEAST_EXPECT(trustedKeys->quorum() ==
std::ceil(keysTotal * 0.8f));
3097 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
3101 for (
auto const& val : valKeys)
3103 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
3106 BEAST_EXPECT(changes.added == added);
3107 BEAST_EXPECT(changes.removed.empty());
3110 env.timeKeeper().set(publishers.back().expiry);
3111 changes = trustedKeys->updateTrusted(
3113 env.timeKeeper().now(),
3115 env.app().getOverlay(),
3116 env.app().getHashRouter());
3117 BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled);
3118 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
3120 BEAST_EXPECT(trustedKeys->trusted(self.masterPublic));
3121 for (
auto const& val : valKeys)
3123 BEAST_EXPECT(trustedKeys->listed(val.masterPublic));
3124 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
3126 BEAST_EXPECT(changes.added.empty());
3127 BEAST_EXPECT(changes.removed.empty());
3131 ManifestCache pubManifests;
3132 ManifestCache valManifests;
3133 std::vector<Publisher> publishers;
3135 auto const self = valKeys[7];
3136 auto const keysTotal = valKeys.size();
3137 auto trustedKeys = makeValidatorList(
3145 BEAST_EXPECT(trustedKeys->getListThreshold() == 1);
3146 for (
auto const& p : publishers)
3147 BEAST_EXPECT(trustedKeys->trustedPublisher(p.pubKey));
3149 TrustChanges changes = trustedKeys->updateTrusted(
3151 env.timeKeeper().now(),
3153 env.app().getOverlay(),
3154 env.app().getHashRouter());
3155 BEAST_EXPECT(trustedKeys->quorum() ==
std::ceil(keysTotal * 0.8f));
3156 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
3159 for (
auto const& val : valKeys)
3161 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
3164 BEAST_EXPECT(changes.added == added);
3165 BEAST_EXPECT(changes.removed.empty());
3168 env.timeKeeper().set(publishers.back().expiry);
3169 changes = trustedKeys->updateTrusted(
3171 env.timeKeeper().now(),
3173 env.app().getOverlay(),
3174 env.app().getHashRouter());
3175 BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled);
3176 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
3178 BEAST_EXPECT(trustedKeys->trusted(self.masterPublic));
3179 for (
auto const& val : valKeys)
3181 BEAST_EXPECT(trustedKeys->listed(val.masterPublic));
3182 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
3184 BEAST_EXPECT(changes.added.empty());
3185 BEAST_EXPECT(changes.removed.empty());
3189 ManifestCache pubManifests;
3190 ManifestCache valManifests;
3191 std::vector<Publisher> publishers;
3192 auto const keysTotal = valKeys.size();
3193 auto trustedKeys = makeValidatorList(
3201 BEAST_EXPECT(trustedKeys->getListThreshold() == 1);
3202 for (
auto const& p : publishers)
3203 BEAST_EXPECT(trustedKeys->trustedPublisher(p.pubKey));
3205 TrustChanges changes = trustedKeys->updateTrusted(
3207 env.timeKeeper().now(),
3209 env.app().getOverlay(),
3210 env.app().getHashRouter());
3211 BEAST_EXPECT(trustedKeys->quorum() ==
std::ceil(keysTotal * 0.8f));
3212 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
3215 for (
auto const& val : valKeys)
3217 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
3220 BEAST_EXPECT(changes.added == added);
3221 BEAST_EXPECT(changes.removed.empty());
3224 env.timeKeeper().set(publishers.back().expiry);
3225 changes = trustedKeys->updateTrusted(
3227 env.timeKeeper().now(),
3229 env.app().getOverlay(),
3230 env.app().getHashRouter());
3231 BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled);
3232 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
3234 for (
auto const& val : valKeys)
3236 BEAST_EXPECT(trustedKeys->listed(val.masterPublic));
3237 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
3239 BEAST_EXPECT(changes.added.empty());
3240 BEAST_EXPECT(changes.removed.empty());
3246 ManifestCache pubManifests;
3247 ManifestCache valManifests;
3248 std::vector<Publisher> publishers;
3250 auto const self = randomValidator();
3251 auto const keysTotal = valKeys.size() + 1;
3252 auto trustedKeys = makeValidatorList(
3260 BEAST_EXPECT(trustedKeys->getListThreshold() == 1);
3261 int untrustedCount = 0;
3262 for (
auto const& p : publishers)
3264 bool const trusted = trustedKeys->trustedPublisher(p.pubKey);
3265 BEAST_EXPECT(p.revoked ^ trusted);
3266 untrustedCount += trusted ? 0 : 1;
3268 BEAST_EXPECT(untrustedCount == 1);
3270 TrustChanges changes = trustedKeys->updateTrusted(
3272 env.timeKeeper().now(),
3274 env.app().getOverlay(),
3275 env.app().getHashRouter());
3276 BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled);
3277 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
3281 for (
auto const& val : valKeys)
3283 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
3286 BEAST_EXPECT(changes.added == added);
3287 BEAST_EXPECT(changes.removed.empty());
3290 env.timeKeeper().set(publishers.back().expiry);
3291 changes = trustedKeys->updateTrusted(
3293 env.timeKeeper().now(),
3295 env.app().getOverlay(),
3296 env.app().getHashRouter());
3297 BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled);
3298 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == 1);
3301 BEAST_EXPECT(trustedKeys->trusted(self.masterPublic));
3302 for (
auto const& val : valKeys)
3304 BEAST_EXPECT(!trustedKeys->listed(val.masterPublic));
3305 BEAST_EXPECT(!trustedKeys->trusted(val.masterPublic));
3306 removed.insert(
calcNodeID(val.masterPublic));
3308 BEAST_EXPECT(changes.added.empty());
3309 BEAST_EXPECT(changes.removed == removed);
3313 ManifestCache pubManifests;
3314 ManifestCache valManifests;
3315 std::vector<Publisher> publishers;
3317 auto const self = valKeys[5];
3318 auto const keysTotal = valKeys.size();
3319 auto trustedKeys = makeValidatorList(
3327 BEAST_EXPECT(trustedKeys->getListThreshold() == 1);
3328 int untrustedCount = 0;
3329 for (
auto const& p : publishers)
3331 bool const trusted = trustedKeys->trustedPublisher(p.pubKey);
3332 BEAST_EXPECT(p.revoked ^ trusted);
3333 untrustedCount += trusted ? 0 : 1;
3335 BEAST_EXPECT(untrustedCount == 1);
3337 TrustChanges changes = trustedKeys->updateTrusted(
3339 env.timeKeeper().now(),
3341 env.app().getOverlay(),
3342 env.app().getHashRouter());
3343 BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled);
3344 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
3347 for (
auto const& val : valKeys)
3349 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
3352 BEAST_EXPECT(changes.added == added);
3353 BEAST_EXPECT(changes.removed.empty());
3356 env.timeKeeper().set(publishers.back().expiry);
3357 changes = trustedKeys->updateTrusted(
3359 env.timeKeeper().now(),
3361 env.app().getOverlay(),
3362 env.app().getHashRouter());
3363 BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled);
3364 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == 1);
3367 BEAST_EXPECT(trustedKeys->trusted(self.masterPublic));
3368 for (
auto const& val : valKeys)
3370 if (val.masterPublic != self.masterPublic)
3372 BEAST_EXPECT(!trustedKeys->listed(val.masterPublic));
3373 BEAST_EXPECT(!trustedKeys->trusted(val.masterPublic));
3374 removed.insert(
calcNodeID(val.masterPublic));
3377 BEAST_EXPECT(changes.added.empty());
3378 BEAST_EXPECT(changes.removed == removed);
3382 ManifestCache pubManifests;
3383 ManifestCache valManifests;
3384 std::vector<Publisher> publishers;
3385 auto const keysTotal = valKeys.size();
3386 auto trustedKeys = makeValidatorList(
3394 BEAST_EXPECT(trustedKeys->getListThreshold() == 1);
3395 int untrustedCount = 0;
3396 for (
auto const& p : publishers)
3398 bool const trusted = trustedKeys->trustedPublisher(p.pubKey);
3399 BEAST_EXPECT(p.revoked ^ trusted);
3400 untrustedCount += trusted ? 0 : 1;
3402 BEAST_EXPECT(untrustedCount == 1);
3404 TrustChanges changes = trustedKeys->updateTrusted(
3406 env.timeKeeper().now(),
3408 env.app().getOverlay(),
3409 env.app().getHashRouter());
3410 BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled);
3411 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
3414 for (
auto const& val : valKeys)
3416 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
3419 BEAST_EXPECT(changes.added == added);
3420 BEAST_EXPECT(changes.removed.empty());
3423 env.timeKeeper().set(publishers.back().expiry);
3424 changes = trustedKeys->updateTrusted(
3426 env.timeKeeper().now(),
3428 env.app().getOverlay(),
3429 env.app().getHashRouter());
3430 BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled);
3431 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().empty());
3434 for (
auto const& val : valKeys)
3436 BEAST_EXPECT(!trustedKeys->listed(val.masterPublic));
3437 BEAST_EXPECT(!trustedKeys->trusted(val.masterPublic));
3438 removed.insert(
calcNodeID(val.masterPublic));
3440 BEAST_EXPECT(changes.added.empty());
3441 BEAST_EXPECT(changes.removed == removed);
3445 ManifestCache pubManifests;
3446 ManifestCache valManifests;
3447 std::vector<Publisher> publishers;
3449 auto const self = randomValidator();
3450 auto const keysTotal = valKeys.size() + 1;
3451 auto trustedKeys = makeValidatorList(
3459 BEAST_EXPECT(trustedKeys->getListThreshold() == 2);
3460 for (
auto const& p : publishers)
3461 BEAST_EXPECT(trustedKeys->trustedPublisher(p.pubKey));
3463 TrustChanges changes = trustedKeys->updateTrusted(
3465 env.timeKeeper().now(),
3467 env.app().getOverlay(),
3468 env.app().getHashRouter());
3469 BEAST_EXPECT(trustedKeys->quorum() ==
std::ceil(keysTotal * 0.8f));
3470 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
3474 for (
auto const& val : valKeys)
3476 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
3479 BEAST_EXPECT(changes.added == added);
3480 BEAST_EXPECT(changes.removed.empty());
3483 env.timeKeeper().set(publishers.back().expiry);
3484 changes = trustedKeys->updateTrusted(
3486 env.timeKeeper().now(),
3488 env.app().getOverlay(),
3489 env.app().getHashRouter());
3490 BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled);
3491 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == 1);
3494 BEAST_EXPECT(trustedKeys->trusted(self.masterPublic));
3495 for (
auto const& val : valKeys)
3497 BEAST_EXPECT(trustedKeys->listed(val.masterPublic));
3498 BEAST_EXPECT(!trustedKeys->trusted(val.masterPublic));
3499 removed.insert(
calcNodeID(val.masterPublic));
3501 BEAST_EXPECT(changes.added.empty());
3502 BEAST_EXPECT(changes.removed == removed);
3506 ManifestCache pubManifests;
3507 ManifestCache valManifests;
3508 std::vector<Publisher> publishers;
3510 auto const self = valKeys[5];
3511 auto const keysTotal = valKeys.size();
3512 auto trustedKeys = makeValidatorList(
3520 BEAST_EXPECT(trustedKeys->getListThreshold() == 2);
3521 for (
auto const& p : publishers)
3522 BEAST_EXPECT(trustedKeys->trustedPublisher(p.pubKey));
3524 TrustChanges changes = trustedKeys->updateTrusted(
3526 env.timeKeeper().now(),
3528 env.app().getOverlay(),
3529 env.app().getHashRouter());
3530 BEAST_EXPECT(trustedKeys->quorum() ==
std::ceil(keysTotal * 0.8f));
3531 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
3535 for (
auto const& val : valKeys)
3537 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
3540 BEAST_EXPECT(changes.added == added);
3541 BEAST_EXPECT(changes.removed.empty());
3544 env.timeKeeper().set(publishers.back().expiry);
3545 changes = trustedKeys->updateTrusted(
3547 env.timeKeeper().now(),
3549 env.app().getOverlay(),
3550 env.app().getHashRouter());
3551 BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled);
3552 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == 1);
3555 BEAST_EXPECT(trustedKeys->trusted(self.masterPublic));
3556 for (
auto const& val : valKeys)
3558 if (val.masterPublic != self.masterPublic)
3560 BEAST_EXPECT(trustedKeys->listed(val.masterPublic));
3561 BEAST_EXPECT(!trustedKeys->trusted(val.masterPublic));
3562 removed.insert(
calcNodeID(val.masterPublic));
3565 BEAST_EXPECT(changes.added.empty());
3566 BEAST_EXPECT(changes.removed == removed);
3570 ManifestCache pubManifests;
3571 ManifestCache valManifests;
3572 std::vector<Publisher> publishers;
3573 auto const keysTotal = valKeys.size();
3574 auto trustedKeys = makeValidatorList(
3582 BEAST_EXPECT(trustedKeys->getListThreshold() == 2);
3583 for (
auto const& p : publishers)
3584 BEAST_EXPECT(trustedKeys->trustedPublisher(p.pubKey));
3586 TrustChanges changes = trustedKeys->updateTrusted(
3588 env.timeKeeper().now(),
3590 env.app().getOverlay(),
3591 env.app().getHashRouter());
3592 BEAST_EXPECT(trustedKeys->quorum() ==
std::ceil(keysTotal * 0.8f));
3593 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
3596 for (
auto const& val : valKeys)
3598 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
3601 BEAST_EXPECT(changes.added == added);
3602 BEAST_EXPECT(changes.removed.empty());
3605 env.timeKeeper().set(publishers.back().expiry);
3606 changes = trustedKeys->updateTrusted(
3608 env.timeKeeper().now(),
3610 env.app().getOverlay(),
3611 env.app().getHashRouter());
3612 BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled);
3613 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().empty());
3616 for (
auto const& val : valKeys)
3618 BEAST_EXPECT(trustedKeys->listed(val.masterPublic));
3619 BEAST_EXPECT(!trustedKeys->trusted(val.masterPublic));
3620 removed.insert(
calcNodeID(val.masterPublic));
3622 BEAST_EXPECT(changes.added.empty());
3623 BEAST_EXPECT(changes.removed == removed);
3629 ManifestCache pubManifests;
3630 ManifestCache valManifests;
3631 std::vector<Publisher> publishers;
3633 auto const self = randomValidator();
3634 auto const keysTotal = valKeys.size() + 1;
3635 auto trustedKeys = makeValidatorList(
3643 BEAST_EXPECT(trustedKeys->getListThreshold() == 1);
3644 for (
auto const& p : publishers)
3645 BEAST_EXPECT(trustedKeys->trustedPublisher(p.pubKey));
3647 TrustChanges changes = trustedKeys->updateTrusted(
3649 env.timeKeeper().now(),
3651 env.app().getOverlay(),
3652 env.app().getHashRouter());
3653 BEAST_EXPECT(trustedKeys->quorum() ==
std::ceil(keysTotal * 0.8f));
3654 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
3658 for (
auto const& val : valKeys)
3660 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
3663 BEAST_EXPECT(changes.added == added);
3664 BEAST_EXPECT(changes.removed.empty());
3667 env.timeKeeper().set(publishers.back().expiry);
3668 changes = trustedKeys->updateTrusted(
3670 env.timeKeeper().now(),
3672 env.app().getOverlay(),
3673 env.app().getHashRouter());
3674 BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled);
3675 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == 1);
3678 BEAST_EXPECT(trustedKeys->trusted(self.masterPublic));
3679 for (
auto const& val : valKeys)
3681 BEAST_EXPECT(!trustedKeys->listed(val.masterPublic));
3682 BEAST_EXPECT(!trustedKeys->trusted(val.masterPublic));
3683 removed.insert(
calcNodeID(val.masterPublic));
3685 BEAST_EXPECT(changes.added.empty());
3686 BEAST_EXPECT(changes.removed == removed);
3692 ManifestCache pubManifests;
3693 ManifestCache valManifests;
3694 std::vector<Publisher> publishers;
3696 auto const self = valKeys[2];
3697 auto const keysTotal = valKeys.size();
3698 auto trustedKeys = makeValidatorList(
3706 BEAST_EXPECT(trustedKeys->getListThreshold() == 2);
3707 for (
auto const& p : publishers)
3708 BEAST_EXPECT(trustedKeys->trustedPublisher(p.pubKey));
3710 TrustChanges
const changes = trustedKeys->updateTrusted(
3712 env.timeKeeper().now(),
3714 env.app().getOverlay(),
3715 env.app().getHashRouter());
3716 BEAST_EXPECT(trustedKeys->quorum() ==
std::ceil(keysTotal * 0.8f));
3717 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
3720 for (
auto const& val : valKeys)
3722 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
3725 BEAST_EXPECT(changes.added == added);
3726 BEAST_EXPECT(changes.removed.empty());
3732 ManifestCache pubManifests;
3733 ManifestCache valManifests;
3734 std::vector<Publisher> publishers;
3735 auto const keysTotal = valKeys.size();
3736 auto trustedKeys = makeValidatorList(
3744 BEAST_EXPECT(trustedKeys->getListThreshold() == 3);
3745 for (
auto const& p : publishers)
3746 BEAST_EXPECT(trustedKeys->trustedPublisher(p.pubKey));
3748 TrustChanges
const changes = trustedKeys->updateTrusted(
3750 env.timeKeeper().now(),
3752 env.app().getOverlay(),
3753 env.app().getHashRouter());
3754 BEAST_EXPECT(trustedKeys->quorum() ==
std::ceil(keysTotal * 0.8f));
3755 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
3758 for (
auto const& val : valKeys)
3760 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
3763 BEAST_EXPECT(changes.added == added);
3764 BEAST_EXPECT(changes.removed.empty());
3770 ManifestCache pubManifests;
3771 ManifestCache valManifests;
3772 std::vector<Publisher> publishers;
3774 auto const self = randomValidator();
3775 auto const keysTotal = valKeys.size() + 1;
3776 auto trustedKeys = makeValidatorList(
3784 BEAST_EXPECT(trustedKeys->getListThreshold() == 4);
3785 int untrustedCount = 0;
3786 for (
auto const& p : publishers)
3788 bool const trusted = trustedKeys->trustedPublisher(p.pubKey);
3789 BEAST_EXPECT(p.revoked ^ trusted);
3790 untrustedCount += trusted ? 0 : 1;
3792 BEAST_EXPECT(untrustedCount == 2);
3794 TrustChanges changes = trustedKeys->updateTrusted(
3796 env.timeKeeper().now(),
3798 env.app().getOverlay(),
3799 env.app().getHashRouter());
3800 BEAST_EXPECT(trustedKeys->quorum() ==
std::ceil(keysTotal * 0.8f));
3801 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
3805 for (
auto const& val : valKeys)
3807 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
3810 BEAST_EXPECT(changes.added == added);
3811 BEAST_EXPECT(changes.removed.empty());
3814 env.timeKeeper().set(publishers.back().expiry);
3815 changes = trustedKeys->updateTrusted(
3817 env.timeKeeper().now(),
3819 env.app().getOverlay(),
3820 env.app().getHashRouter());
3821 BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled);
3822 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == 1);
3825 BEAST_EXPECT(trustedKeys->trusted(self.masterPublic));
3826 for (
auto const& val : valKeys)
3828 BEAST_EXPECT(trustedKeys->listed(val.masterPublic));
3829 BEAST_EXPECT(!trustedKeys->trusted(val.masterPublic));
3830 removed.insert(
calcNodeID(val.masterPublic));
3832 BEAST_EXPECT(changes.added.empty());
3833 BEAST_EXPECT(changes.removed == removed);
3839 ManifestCache pubManifests;
3840 ManifestCache valManifests;
3841 std::vector<Publisher> publishers;
3843 auto const self = valKeys[2];
3844 auto const keysTotal = valKeys.size();
3845 auto trustedKeys = makeValidatorList(
3853 BEAST_EXPECT(trustedKeys->getListThreshold() == 4);
3854 int untrustedCount = 0;
3855 for (
auto const& p : publishers)
3857 bool const trusted = trustedKeys->trustedPublisher(p.pubKey);
3858 BEAST_EXPECT(p.revoked ^ trusted);
3859 untrustedCount += trusted ? 0 : 1;
3861 BEAST_EXPECT(untrustedCount == 3);
3863 TrustChanges changes = trustedKeys->updateTrusted(
3865 env.timeKeeper().now(),
3867 env.app().getOverlay(),
3868 env.app().getHashRouter());
3869 BEAST_EXPECT(trustedKeys->quorum() ==
std::ceil(keysTotal * 0.8f));
3870 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == keysTotal);
3873 for (
auto const& val : valKeys)
3875 BEAST_EXPECT(trustedKeys->trusted(val.masterPublic));
3878 BEAST_EXPECT(changes.added == added);
3879 BEAST_EXPECT(changes.removed.empty());
3882 env.timeKeeper().set(publishers.back().expiry);
3883 changes = trustedKeys->updateTrusted(
3885 env.timeKeeper().now(),
3887 env.app().getOverlay(),
3888 env.app().getHashRouter());
3889 BEAST_EXPECT(trustedKeys->quorum() == kQuorumDisabled);
3890 BEAST_EXPECT(trustedKeys->getTrustedMasterKeys().size() == 1);
3893 BEAST_EXPECT(trustedKeys->trusted(self.masterPublic));
3894 for (
auto const& val : valKeys)
3896 if (val.masterPublic != self.masterPublic)
3898 BEAST_EXPECT(trustedKeys->listed(val.masterPublic));
3899 BEAST_EXPECT(!trustedKeys->trusted(val.masterPublic));
3900 removed.insert(
calcNodeID(val.masterPublic));
3903 BEAST_EXPECT(changes.added.empty());
3904 BEAST_EXPECT(changes.removed == removed);