diff --git a/AmendmentTable_8cpp_source.html b/AmendmentTable_8cpp_source.html index d742f7f5a4..5ed84cc687 100644 --- a/AmendmentTable_8cpp_source.html +++ b/AmendmentTable_8cpp_source.html @@ -422,602 +422,609 @@ $(function() {
388  Json::Value& v,
389  uint256 const& amendment,
390  AmendmentState const& state,
-
391  std::lock_guard<std::mutex> const& lock) const;
-
392 
-
393  void
-
394  persistVote(
-
395  uint256 const& amendment,
-
396  std::string const& name,
-
397  AmendmentVote vote) const;
-
398 
-
399 public:
-
400  AmendmentTableImpl(
-
401  Application& app,
-
402  std::chrono::seconds majorityTime,
-
403  std::vector<FeatureInfo> const& supported,
-
404  Section const& enabled,
-
405  Section const& vetoed,
-
406  beast::Journal journal);
-
407 
-
408  uint256
-
409  find(std::string const& name) const override;
-
410 
-
411  bool
-
412  veto(uint256 const& amendment) override;
-
413  bool
-
414  unVeto(uint256 const& amendment) override;
-
415 
-
416  bool
-
417  enable(uint256 const& amendment) override;
-
418 
-
419  bool
-
420  isEnabled(uint256 const& amendment) const override;
-
421  bool
-
422  isSupported(uint256 const& amendment) const override;
-
423 
-
424  bool
-
425  hasUnsupportedEnabled() const override;
-
426 
-
427  std::optional<NetClock::time_point>
-
428  firstUnsupportedExpected() const override;
-
429 
-
430  Json::Value
-
431  getJson() const override;
-
432  Json::Value
-
433  getJson(uint256 const&) const override;
-
434 
-
435  bool
-
436  needValidatedLedger(LedgerIndex seq) const override;
-
437 
-
438  void
-
439  doValidatedLedger(
-
440  LedgerIndex seq,
-
441  std::set<uint256> const& enabled,
-
442  majorityAmendments_t const& majority) override;
-
443 
-
444  void
-
445  trustChanged(hash_set<PublicKey> const& allTrusted) override;
-
446 
-
447  std::vector<uint256>
-
448  doValidation(std::set<uint256> const& enabledAmendments) const override;
-
449 
-
450  std::vector<uint256>
-
451  getDesired() const override;
-
452 
-
453  std::map<uint256, std::uint32_t>
-
454  doVoting(
-
455  Rules const& rules,
-
456  NetClock::time_point closeTime,
-
457  std::set<uint256> const& enabledAmendments,
-
458  majorityAmendments_t const& majorityAmendments,
-
459  std::vector<std::shared_ptr<STValidation>> const& validations) override;
-
460 };
-
461 
-
462 //------------------------------------------------------------------------------
-
463 
-
464 AmendmentTableImpl::AmendmentTableImpl(
-
465  Application& app,
-
466  std::chrono::seconds majorityTime,
-
467  std::vector<FeatureInfo> const& supported,
-
468  Section const& enabled,
-
469  Section const& vetoed,
-
470  beast::Journal journal)
-
471  : lastUpdateSeq_(0)
-
472  , majorityTime_(majorityTime)
-
473  , unsupportedEnabled_(false)
-
474  , j_(journal)
-
475  , db_(app.getWalletDB())
-
476 {
-
477  std::lock_guard lock(mutex_);
-
478 
-
479  // Find out if the FeatureVotes table exists in WalletDB
-
480  bool const featureVotesExist = [this]() {
-
481  auto db = db_.checkoutDb();
-
482  return createFeatureVotes(*db);
-
483  }();
-
484 
-
485  // Parse supported amendments
-
486  for (auto const& [name, amendment, votebehavior] : supported)
-
487  {
-
488  AmendmentState& s = add(amendment, lock);
-
489 
-
490  s.name = name;
-
491  s.supported = true;
-
492  switch (votebehavior)
-
493  {
-
494  case VoteBehavior::DefaultYes:
-
495  s.vote = AmendmentVote::up;
-
496  break;
-
497 
-
498  case VoteBehavior::DefaultNo:
-
499  s.vote = AmendmentVote::down;
-
500  break;
-
501 
-
502  case VoteBehavior::Obsolete:
-
503  s.vote = AmendmentVote::obsolete;
-
504  break;
-
505  }
-
506 
-
507  JLOG(j_.debug()) << "Amendment " << amendment << " (" << s.name
-
508  << ") is supported and will be "
-
509  << (s.vote == AmendmentVote::up ? "up" : "down")
-
510  << " voted by default if not enabled on the ledger.";
-
511  }
-
512 
-
513  hash_set<uint256> detect_conflict;
-
514  // Parse enabled amendments from config
-
515  for (std::pair<uint256, std::string> const& a : parseSection(enabled))
-
516  {
-
517  if (featureVotesExist)
-
518  { // If the table existed, warn about duplicate config info
-
519  JLOG(j_.warn()) << "[amendments] section in config file ignored"
-
520  " in favor of data in db/wallet.db.";
-
521  break;
-
522  }
-
523  else
-
524  { // Otherwise transfer config data into the table
-
525  detect_conflict.insert(a.first);
-
526  persistVote(a.first, a.second, AmendmentVote::up);
-
527  }
-
528  }
-
529 
-
530  // Parse vetoed amendments from config
-
531  for (auto const& a : parseSection(vetoed))
-
532  {
-
533  if (featureVotesExist)
-
534  { // If the table existed, warn about duplicate config info
-
535  JLOG(j_.warn())
-
536  << "[veto_amendments] section in config file ignored"
-
537  " in favor of data in db/wallet.db.";
-
538  break;
-
539  }
-
540  else
-
541  { // Otherwise transfer config data into the table
-
542  if (detect_conflict.count(a.first) == 0)
-
543  {
-
544  persistVote(a.first, a.second, AmendmentVote::down);
-
545  }
-
546  else
-
547  {
-
548  JLOG(j_.warn())
-
549  << "[veto_amendments] section in config has amendment "
-
550  << '(' << a.first << ", " << a.second
-
551  << ") both [veto_amendments] and [amendments].";
-
552  }
-
553  }
-
554  }
-
555 
-
556  // Read amendment votes from wallet.db
-
557  auto db = db_.checkoutDb();
-
558  readAmendments(
-
559  *db,
-
560  [&](boost::optional<std::string> amendment_hash,
-
561  boost::optional<std::string> amendment_name,
-
562  boost::optional<AmendmentVote> vote) {
-
563  uint256 amend_hash;
-
564  if (!amendment_hash || !amendment_name || !vote)
-
565  {
-
566  // These fields should never have nulls, but check
-
567  Throw<std::runtime_error>(
-
568  "Invalid FeatureVotes row in wallet.db");
-
569  }
-
570  if (!amend_hash.parseHex(*amendment_hash))
-
571  {
-
572  Throw<std::runtime_error>(
-
573  "Invalid amendment ID '" + *amendment_hash +
-
574  " in wallet.db");
-
575  }
-
576  if (*vote == AmendmentVote::down)
-
577  {
-
578  // Unknown amendments are effectively vetoed already
-
579  if (auto s = get(amend_hash, lock))
-
580  {
-
581  JLOG(j_.info()) << "Amendment {" << *amendment_name << ", "
-
582  << amend_hash << "} is downvoted.";
-
583  if (!amendment_name->empty())
-
584  s->name = *amendment_name;
-
585  // An obsolete amendment's vote can never be changed
-
586  if (s->vote != AmendmentVote::obsolete)
-
587  s->vote = *vote;
-
588  }
-
589  }
-
590  else // up-vote
-
591  {
-
592  AmendmentState& s = add(amend_hash, lock);
-
593 
-
594  JLOG(j_.debug()) << "Amendment {" << *amendment_name << ", "
-
595  << amend_hash << "} is upvoted.";
-
596  if (!amendment_name->empty())
-
597  s.name = *amendment_name;
-
598  // An obsolete amendment's vote can never be changed
-
599  if (s.vote != AmendmentVote::obsolete)
-
600  s.vote = *vote;
-
601  }
-
602  });
-
603 }
-
604 
-
605 AmendmentState&
-
606 AmendmentTableImpl::add(
-
607  uint256 const& amendmentHash,
-
608  std::lock_guard<std::mutex> const&)
-
609 {
-
610  // call with the mutex held
-
611  return amendmentMap_[amendmentHash];
-
612 }
-
613 
-
614 AmendmentState*
-
615 AmendmentTableImpl::get(
-
616  uint256 const& amendmentHash,
-
617  std::lock_guard<std::mutex> const& lock)
-
618 {
-
619  // Forward to the const version of get.
-
620  return const_cast<AmendmentState*>(
-
621  std::as_const(*this).get(amendmentHash, lock));
-
622 }
-
623 
-
624 AmendmentState const*
-
625 AmendmentTableImpl::get(
-
626  uint256 const& amendmentHash,
-
627  std::lock_guard<std::mutex> const&) const
-
628 {
-
629  // call with the mutex held
-
630  auto ret = amendmentMap_.find(amendmentHash);
-
631 
-
632  if (ret == amendmentMap_.end())
-
633  return nullptr;
-
634 
-
635  return &ret->second;
-
636 }
-
637 
-
638 uint256
-
639 AmendmentTableImpl::find(std::string const& name) const
-
640 {
-
641  std::lock_guard lock(mutex_);
-
642 
-
643  for (auto const& e : amendmentMap_)
-
644  {
-
645  if (name == e.second.name)
-
646  return e.first;
-
647  }
-
648 
-
649  return {};
-
650 }
-
651 
-
652 void
-
653 AmendmentTableImpl::persistVote(
-
654  uint256 const& amendment,
-
655  std::string const& name,
-
656  AmendmentVote vote) const
-
657 {
-
658  assert(vote != AmendmentVote::obsolete);
-
659  auto db = db_.checkoutDb();
-
660  voteAmendment(*db, amendment, name, vote);
-
661 }
-
662 
-
663 bool
-
664 AmendmentTableImpl::veto(uint256 const& amendment)
-
665 {
-
666  std::lock_guard lock(mutex_);
-
667  AmendmentState& s = add(amendment, lock);
-
668 
-
669  if (s.vote != AmendmentVote::up)
-
670  return false;
-
671  s.vote = AmendmentVote::down;
-
672  persistVote(amendment, s.name, s.vote);
-
673  return true;
-
674 }
-
675 
-
676 bool
-
677 AmendmentTableImpl::unVeto(uint256 const& amendment)
-
678 {
-
679  std::lock_guard lock(mutex_);
-
680  AmendmentState* const s = get(amendment, lock);
-
681 
-
682  if (!s || s->vote != AmendmentVote::down)
-
683  return false;
-
684  s->vote = AmendmentVote::up;
-
685  persistVote(amendment, s->name, s->vote);
-
686  return true;
-
687 }
-
688 
-
689 bool
-
690 AmendmentTableImpl::enable(uint256 const& amendment)
-
691 {
-
692  std::lock_guard lock(mutex_);
-
693  AmendmentState& s = add(amendment, lock);
-
694 
-
695  if (s.enabled)
-
696  return false;
-
697 
-
698  s.enabled = true;
-
699 
-
700  if (!s.supported)
-
701  {
-
702  JLOG(j_.error()) << "Unsupported amendment " << amendment
-
703  << " activated.";
-
704  unsupportedEnabled_ = true;
-
705  }
-
706 
-
707  return true;
-
708 }
-
709 
-
710 bool
-
711 AmendmentTableImpl::isEnabled(uint256 const& amendment) const
-
712 {
-
713  std::lock_guard lock(mutex_);
-
714  AmendmentState const* s = get(amendment, lock);
-
715  return s && s->enabled;
-
716 }
-
717 
-
718 bool
-
719 AmendmentTableImpl::isSupported(uint256 const& amendment) const
-
720 {
-
721  std::lock_guard lock(mutex_);
-
722  AmendmentState const* s = get(amendment, lock);
-
723  return s && s->supported;
-
724 }
-
725 
-
726 bool
-
727 AmendmentTableImpl::hasUnsupportedEnabled() const
-
728 {
-
729  std::lock_guard lock(mutex_);
-
730  return unsupportedEnabled_;
-
731 }
-
732 
-
733 std::optional<NetClock::time_point>
-
734 AmendmentTableImpl::firstUnsupportedExpected() const
-
735 {
-
736  std::lock_guard lock(mutex_);
-
737  return firstUnsupportedExpected_;
-
738 }
-
739 
-
740 std::vector<uint256>
-
741 AmendmentTableImpl::doValidation(std::set<uint256> const& enabled) const
-
742 {
-
743  // Get the list of amendments we support and do not
-
744  // veto, but that are not already enabled
-
745  std::vector<uint256> amendments;
-
746 
-
747  {
-
748  std::lock_guard lock(mutex_);
-
749  amendments.reserve(amendmentMap_.size());
-
750  for (auto const& e : amendmentMap_)
-
751  {
-
752  if (e.second.supported && e.second.vote == AmendmentVote::up &&
-
753  (enabled.count(e.first) == 0))
-
754  {
-
755  amendments.push_back(e.first);
-
756  JLOG(j_.info()) << "Voting for amendment " << e.second.name;
-
757  }
-
758  }
-
759  }
-
760 
-
761  if (!amendments.empty())
-
762  std::sort(amendments.begin(), amendments.end());
-
763 
-
764  return amendments;
-
765 }
-
766 
-
767 std::vector<uint256>
-
768 AmendmentTableImpl::getDesired() const
-
769 {
-
770  // Get the list of amendments we support and do not veto
-
771  return doValidation({});
-
772 }
-
773 
-
774 std::map<uint256, std::uint32_t>
-
775 AmendmentTableImpl::doVoting(
-
776  Rules const& rules,
-
777  NetClock::time_point closeTime,
-
778  std::set<uint256> const& enabledAmendments,
-
779  majorityAmendments_t const& majorityAmendments,
-
780  std::vector<std::shared_ptr<STValidation>> const& valSet)
-
781 {
-
782  JLOG(j_.trace()) << "voting at " << closeTime.time_since_epoch().count()
-
783  << ": " << enabledAmendments.size() << ", "
-
784  << majorityAmendments.size() << ", " << valSet.size();
-
785 
-
786  std::lock_guard lock(mutex_);
-
787 
-
788  // Keep a record of the votes we received.
-
789  previousTrustedVotes_.recordVotes(rules, valSet, closeTime, lock);
-
790 
-
791  // Tally the most recent votes.
-
792  auto vote =
-
793  std::make_unique<AmendmentSet>(rules, previousTrustedVotes_, lock);
-
794  JLOG(j_.debug()) << "Received " << vote->trustedValidations()
-
795  << " trusted validations, threshold is: "
-
796  << vote->threshold();
-
797 
-
798  // Map of amendments to the action to be taken for each one. The action is
-
799  // the value of the flags in the pseudo-transaction
-
800  std::map<uint256, std::uint32_t> actions;
-
801 
-
802  // process all amendments we know of
-
803  for (auto const& entry : amendmentMap_)
-
804  {
-
805  NetClock::time_point majorityTime = {};
-
806 
-
807  bool const hasValMajority = vote->passes(entry.first);
-
808 
-
809  {
-
810  auto const it = majorityAmendments.find(entry.first);
-
811  if (it != majorityAmendments.end())
-
812  majorityTime = it->second;
-
813  }
-
814 
-
815  if (enabledAmendments.count(entry.first) != 0)
-
816  {
-
817  JLOG(j_.debug()) << entry.first << ": amendment already enabled";
-
818  }
-
819  else if (
-
820  hasValMajority && (majorityTime == NetClock::time_point{}) &&
-
821  entry.second.vote == AmendmentVote::up)
-
822  {
-
823  // Ledger says no majority, validators say yes
-
824  JLOG(j_.debug()) << entry.first << ": amendment got majority";
-
825  actions[entry.first] = tfGotMajority;
-
826  }
-
827  else if (!hasValMajority && (majorityTime != NetClock::time_point{}))
-
828  {
-
829  // Ledger says majority, validators say no
-
830  JLOG(j_.debug()) << entry.first << ": amendment lost majority";
-
831  actions[entry.first] = tfLostMajority;
-
832  }
-
833  else if (
-
834  (majorityTime != NetClock::time_point{}) &&
-
835  ((majorityTime + majorityTime_) <= closeTime) &&
-
836  entry.second.vote == AmendmentVote::up)
-
837  {
-
838  // Ledger says majority held
-
839  JLOG(j_.debug()) << entry.first << ": amendment majority held";
-
840  actions[entry.first] = 0;
-
841  }
-
842  }
-
843 
-
844  // Stash for reporting
-
845  lastVote_ = std::move(vote);
-
846  return actions;
-
847 }
-
848 
-
849 bool
-
850 AmendmentTableImpl::needValidatedLedger(LedgerIndex ledgerSeq) const
-
851 {
-
852  std::lock_guard lock(mutex_);
-
853 
-
854  // Is there a ledger in which an amendment could have been enabled
-
855  // between these two ledger sequences?
-
856 
-
857  return ((ledgerSeq - 1) / 256) != ((lastUpdateSeq_ - 1) / 256);
-
858 }
-
859 
-
860 void
-
861 AmendmentTableImpl::doValidatedLedger(
-
862  LedgerIndex ledgerSeq,
-
863  std::set<uint256> const& enabled,
-
864  majorityAmendments_t const& majority)
-
865 {
-
866  for (auto& e : enabled)
-
867  enable(e);
-
868 
-
869  std::lock_guard lock(mutex_);
-
870 
-
871  // Remember the ledger sequence of this update.
-
872  lastUpdateSeq_ = ledgerSeq;
-
873 
-
874  // Since we have the whole list in `majority`, reset the time flag, even
-
875  // if it's currently set. If it's not set when the loop is done, then any
-
876  // prior unknown amendments have lost majority.
-
877  firstUnsupportedExpected_.reset();
-
878  for (auto const& [hash, time] : majority)
-
879  {
-
880  AmendmentState& s = add(hash, lock);
-
881 
-
882  if (s.enabled)
-
883  continue;
-
884 
-
885  if (!s.supported)
-
886  {
-
887  JLOG(j_.info()) << "Unsupported amendment " << hash
-
888  << " reached majority at " << to_string(time);
-
889  if (!firstUnsupportedExpected_ || firstUnsupportedExpected_ > time)
-
890  firstUnsupportedExpected_ = time;
-
891  }
-
892  }
-
893  if (firstUnsupportedExpected_)
-
894  firstUnsupportedExpected_ = *firstUnsupportedExpected_ + majorityTime_;
-
895 }
-
896 
-
897 void
-
898 AmendmentTableImpl::trustChanged(hash_set<PublicKey> const& allTrusted)
-
899 {
-
900  std::lock_guard lock(mutex_);
-
901  previousTrustedVotes_.trustChanged(allTrusted, lock);
-
902 }
-
903 
-
904 void
-
905 AmendmentTableImpl::injectJson(
-
906  Json::Value& v,
-
907  const uint256& id,
-
908  const AmendmentState& fs,
-
909  std::lock_guard<std::mutex> const&) const
-
910 {
-
911  if (!fs.name.empty())
-
912  v[jss::name] = fs.name;
-
913 
-
914  v[jss::supported] = fs.supported;
-
915  if (!fs.enabled)
-
916  {
-
917  if (fs.vote == AmendmentVote::obsolete)
-
918  v[jss::vetoed] = "Obsolete";
-
919  else
-
920  v[jss::vetoed] = fs.vote == AmendmentVote::down;
-
921  }
-
922  v[jss::enabled] = fs.enabled;
-
923 
-
924  if (!fs.enabled && lastVote_)
-
925  {
-
926  auto const votesTotal = lastVote_->trustedValidations();
-
927  auto const votesNeeded = lastVote_->threshold();
-
928  auto const votesFor = lastVote_->votes(id);
-
929 
-
930  v[jss::count] = votesFor;
-
931  v[jss::validations] = votesTotal;
-
932 
-
933  if (votesNeeded)
-
934  v[jss::threshold] = votesNeeded;
-
935  }
-
936 }
-
937 
-
938 Json::Value
-
939 AmendmentTableImpl::getJson() const
-
940 {
-
941  Json::Value ret(Json::objectValue);
-
942  {
-
943  std::lock_guard lock(mutex_);
-
944  for (auto const& e : amendmentMap_)
-
945  {
-
946  injectJson(
-
947  ret[to_string(e.first)] = Json::objectValue,
-
948  e.first,
-
949  e.second,
-
950  lock);
-
951  }
-
952  }
-
953  return ret;
-
954 }
-
955 
-
956 Json::Value
-
957 AmendmentTableImpl::getJson(uint256 const& amendmentID) const
-
958 {
-
959  Json::Value ret = Json::objectValue;
-
960  Json::Value& jAmendment = (ret[to_string(amendmentID)] = Json::objectValue);
-
961 
-
962  {
-
963  std::lock_guard lock(mutex_);
-
964  AmendmentState const* a = get(amendmentID, lock);
-
965  if (a)
-
966  injectJson(jAmendment, amendmentID, *a, lock);
-
967  }
-
968 
-
969  return ret;
-
970 }
-
971 
-
972 std::unique_ptr<AmendmentTable>
-
973 make_AmendmentTable(
-
974  Application& app,
-
975  std::chrono::seconds majorityTime,
-
976  std::vector<AmendmentTable::FeatureInfo> const& supported,
-
977  Section const& enabled,
-
978  Section const& vetoed,
-
979  beast::Journal journal)
-
980 {
-
981  return std::make_unique<AmendmentTableImpl>(
-
982  app, majorityTime, supported, enabled, vetoed, journal);
-
983 }
-
984 
-
985 } // namespace ripple
+
391  bool isAdmin,
+
392  std::lock_guard<std::mutex> const& lock) const;
+
393 
+
394  void
+
395  persistVote(
+
396  uint256 const& amendment,
+
397  std::string const& name,
+
398  AmendmentVote vote) const;
+
399 
+
400 public:
+
401  AmendmentTableImpl(
+
402  Application& app,
+
403  std::chrono::seconds majorityTime,
+
404  std::vector<FeatureInfo> const& supported,
+
405  Section const& enabled,
+
406  Section const& vetoed,
+
407  beast::Journal journal);
+
408 
+
409  uint256
+
410  find(std::string const& name) const override;
+
411 
+
412  bool
+
413  veto(uint256 const& amendment) override;
+
414  bool
+
415  unVeto(uint256 const& amendment) override;
+
416 
+
417  bool
+
418  enable(uint256 const& amendment) override;
+
419 
+
420  bool
+
421  isEnabled(uint256 const& amendment) const override;
+
422  bool
+
423  isSupported(uint256 const& amendment) const override;
+
424 
+
425  bool
+
426  hasUnsupportedEnabled() const override;
+
427 
+
428  std::optional<NetClock::time_point>
+
429  firstUnsupportedExpected() const override;
+
430 
+
431  Json::Value
+
432  getJson(bool isAdmin) const override;
+
433  Json::Value
+
434  getJson(uint256 const&, bool isAdmin) const override;
+
435 
+
436  bool
+
437  needValidatedLedger(LedgerIndex seq) const override;
+
438 
+
439  void
+
440  doValidatedLedger(
+
441  LedgerIndex seq,
+
442  std::set<uint256> const& enabled,
+
443  majorityAmendments_t const& majority) override;
+
444 
+
445  void
+
446  trustChanged(hash_set<PublicKey> const& allTrusted) override;
+
447 
+
448  std::vector<uint256>
+
449  doValidation(std::set<uint256> const& enabledAmendments) const override;
+
450 
+
451  std::vector<uint256>
+
452  getDesired() const override;
+
453 
+
454  std::map<uint256, std::uint32_t>
+
455  doVoting(
+
456  Rules const& rules,
+
457  NetClock::time_point closeTime,
+
458  std::set<uint256> const& enabledAmendments,
+
459  majorityAmendments_t const& majorityAmendments,
+
460  std::vector<std::shared_ptr<STValidation>> const& validations) override;
+
461 };
+
462 
+
463 //------------------------------------------------------------------------------
+
464 
+
465 AmendmentTableImpl::AmendmentTableImpl(
+
466  Application& app,
+
467  std::chrono::seconds majorityTime,
+
468  std::vector<FeatureInfo> const& supported,
+
469  Section const& enabled,
+
470  Section const& vetoed,
+
471  beast::Journal journal)
+
472  : lastUpdateSeq_(0)
+
473  , majorityTime_(majorityTime)
+
474  , unsupportedEnabled_(false)
+
475  , j_(journal)
+
476  , db_(app.getWalletDB())
+
477 {
+
478  std::lock_guard lock(mutex_);
+
479 
+
480  // Find out if the FeatureVotes table exists in WalletDB
+
481  bool const featureVotesExist = [this]() {
+
482  auto db = db_.checkoutDb();
+
483  return createFeatureVotes(*db);
+
484  }();
+
485 
+
486  // Parse supported amendments
+
487  for (auto const& [name, amendment, votebehavior] : supported)
+
488  {
+
489  AmendmentState& s = add(amendment, lock);
+
490 
+
491  s.name = name;
+
492  s.supported = true;
+
493  switch (votebehavior)
+
494  {
+
495  case VoteBehavior::DefaultYes:
+
496  s.vote = AmendmentVote::up;
+
497  break;
+
498 
+
499  case VoteBehavior::DefaultNo:
+
500  s.vote = AmendmentVote::down;
+
501  break;
+
502 
+
503  case VoteBehavior::Obsolete:
+
504  s.vote = AmendmentVote::obsolete;
+
505  break;
+
506  }
+
507 
+
508  JLOG(j_.debug()) << "Amendment " << amendment << " (" << s.name
+
509  << ") is supported and will be "
+
510  << (s.vote == AmendmentVote::up ? "up" : "down")
+
511  << " voted by default if not enabled on the ledger.";
+
512  }
+
513 
+
514  hash_set<uint256> detect_conflict;
+
515  // Parse enabled amendments from config
+
516  for (std::pair<uint256, std::string> const& a : parseSection(enabled))
+
517  {
+
518  if (featureVotesExist)
+
519  { // If the table existed, warn about duplicate config info
+
520  JLOG(j_.warn()) << "[amendments] section in config file ignored"
+
521  " in favor of data in db/wallet.db.";
+
522  break;
+
523  }
+
524  else
+
525  { // Otherwise transfer config data into the table
+
526  detect_conflict.insert(a.first);
+
527  persistVote(a.first, a.second, AmendmentVote::up);
+
528  }
+
529  }
+
530 
+
531  // Parse vetoed amendments from config
+
532  for (auto const& a : parseSection(vetoed))
+
533  {
+
534  if (featureVotesExist)
+
535  { // If the table existed, warn about duplicate config info
+
536  JLOG(j_.warn())
+
537  << "[veto_amendments] section in config file ignored"
+
538  " in favor of data in db/wallet.db.";
+
539  break;
+
540  }
+
541  else
+
542  { // Otherwise transfer config data into the table
+
543  if (detect_conflict.count(a.first) == 0)
+
544  {
+
545  persistVote(a.first, a.second, AmendmentVote::down);
+
546  }
+
547  else
+
548  {
+
549  JLOG(j_.warn())
+
550  << "[veto_amendments] section in config has amendment "
+
551  << '(' << a.first << ", " << a.second
+
552  << ") both [veto_amendments] and [amendments].";
+
553  }
+
554  }
+
555  }
+
556 
+
557  // Read amendment votes from wallet.db
+
558  auto db = db_.checkoutDb();
+
559  readAmendments(
+
560  *db,
+
561  [&](boost::optional<std::string> amendment_hash,
+
562  boost::optional<std::string> amendment_name,
+
563  boost::optional<AmendmentVote> vote) {
+
564  uint256 amend_hash;
+
565  if (!amendment_hash || !amendment_name || !vote)
+
566  {
+
567  // These fields should never have nulls, but check
+
568  Throw<std::runtime_error>(
+
569  "Invalid FeatureVotes row in wallet.db");
+
570  }
+
571  if (!amend_hash.parseHex(*amendment_hash))
+
572  {
+
573  Throw<std::runtime_error>(
+
574  "Invalid amendment ID '" + *amendment_hash +
+
575  " in wallet.db");
+
576  }
+
577  if (*vote == AmendmentVote::down)
+
578  {
+
579  // Unknown amendments are effectively vetoed already
+
580  if (auto s = get(amend_hash, lock))
+
581  {
+
582  JLOG(j_.info()) << "Amendment {" << *amendment_name << ", "
+
583  << amend_hash << "} is downvoted.";
+
584  if (!amendment_name->empty())
+
585  s->name = *amendment_name;
+
586  // An obsolete amendment's vote can never be changed
+
587  if (s->vote != AmendmentVote::obsolete)
+
588  s->vote = *vote;
+
589  }
+
590  }
+
591  else // up-vote
+
592  {
+
593  AmendmentState& s = add(amend_hash, lock);
+
594 
+
595  JLOG(j_.debug()) << "Amendment {" << *amendment_name << ", "
+
596  << amend_hash << "} is upvoted.";
+
597  if (!amendment_name->empty())
+
598  s.name = *amendment_name;
+
599  // An obsolete amendment's vote can never be changed
+
600  if (s.vote != AmendmentVote::obsolete)
+
601  s.vote = *vote;
+
602  }
+
603  });
+
604 }
+
605 
+
606 AmendmentState&
+
607 AmendmentTableImpl::add(
+
608  uint256 const& amendmentHash,
+
609  std::lock_guard<std::mutex> const&)
+
610 {
+
611  // call with the mutex held
+
612  return amendmentMap_[amendmentHash];
+
613 }
+
614 
+
615 AmendmentState*
+
616 AmendmentTableImpl::get(
+
617  uint256 const& amendmentHash,
+
618  std::lock_guard<std::mutex> const& lock)
+
619 {
+
620  // Forward to the const version of get.
+
621  return const_cast<AmendmentState*>(
+
622  std::as_const(*this).get(amendmentHash, lock));
+
623 }
+
624 
+
625 AmendmentState const*
+
626 AmendmentTableImpl::get(
+
627  uint256 const& amendmentHash,
+
628  std::lock_guard<std::mutex> const&) const
+
629 {
+
630  // call with the mutex held
+
631  auto ret = amendmentMap_.find(amendmentHash);
+
632 
+
633  if (ret == amendmentMap_.end())
+
634  return nullptr;
+
635 
+
636  return &ret->second;
+
637 }
+
638 
+
639 uint256
+
640 AmendmentTableImpl::find(std::string const& name) const
+
641 {
+
642  std::lock_guard lock(mutex_);
+
643 
+
644  for (auto const& e : amendmentMap_)
+
645  {
+
646  if (name == e.second.name)
+
647  return e.first;
+
648  }
+
649 
+
650  return {};
+
651 }
+
652 
+
653 void
+
654 AmendmentTableImpl::persistVote(
+
655  uint256 const& amendment,
+
656  std::string const& name,
+
657  AmendmentVote vote) const
+
658 {
+
659  assert(vote != AmendmentVote::obsolete);
+
660  auto db = db_.checkoutDb();
+
661  voteAmendment(*db, amendment, name, vote);
+
662 }
+
663 
+
664 bool
+
665 AmendmentTableImpl::veto(uint256 const& amendment)
+
666 {
+
667  std::lock_guard lock(mutex_);
+
668  AmendmentState& s = add(amendment, lock);
+
669 
+
670  if (s.vote != AmendmentVote::up)
+
671  return false;
+
672  s.vote = AmendmentVote::down;
+
673  persistVote(amendment, s.name, s.vote);
+
674  return true;
+
675 }
+
676 
+
677 bool
+
678 AmendmentTableImpl::unVeto(uint256 const& amendment)
+
679 {
+
680  std::lock_guard lock(mutex_);
+
681  AmendmentState* const s = get(amendment, lock);
+
682 
+
683  if (!s || s->vote != AmendmentVote::down)
+
684  return false;
+
685  s->vote = AmendmentVote::up;
+
686  persistVote(amendment, s->name, s->vote);
+
687  return true;
+
688 }
+
689 
+
690 bool
+
691 AmendmentTableImpl::enable(uint256 const& amendment)
+
692 {
+
693  std::lock_guard lock(mutex_);
+
694  AmendmentState& s = add(amendment, lock);
+
695 
+
696  if (s.enabled)
+
697  return false;
+
698 
+
699  s.enabled = true;
+
700 
+
701  if (!s.supported)
+
702  {
+
703  JLOG(j_.error()) << "Unsupported amendment " << amendment
+
704  << " activated.";
+
705  unsupportedEnabled_ = true;
+
706  }
+
707 
+
708  return true;
+
709 }
+
710 
+
711 bool
+
712 AmendmentTableImpl::isEnabled(uint256 const& amendment) const
+
713 {
+
714  std::lock_guard lock(mutex_);
+
715  AmendmentState const* s = get(amendment, lock);
+
716  return s && s->enabled;
+
717 }
+
718 
+
719 bool
+
720 AmendmentTableImpl::isSupported(uint256 const& amendment) const
+
721 {
+
722  std::lock_guard lock(mutex_);
+
723  AmendmentState const* s = get(amendment, lock);
+
724  return s && s->supported;
+
725 }
+
726 
+
727 bool
+
728 AmendmentTableImpl::hasUnsupportedEnabled() const
+
729 {
+
730  std::lock_guard lock(mutex_);
+
731  return unsupportedEnabled_;
+
732 }
+
733 
+
734 std::optional<NetClock::time_point>
+
735 AmendmentTableImpl::firstUnsupportedExpected() const
+
736 {
+
737  std::lock_guard lock(mutex_);
+
738  return firstUnsupportedExpected_;
+
739 }
+
740 
+
741 std::vector<uint256>
+
742 AmendmentTableImpl::doValidation(std::set<uint256> const& enabled) const
+
743 {
+
744  // Get the list of amendments we support and do not
+
745  // veto, but that are not already enabled
+
746  std::vector<uint256> amendments;
+
747 
+
748  {
+
749  std::lock_guard lock(mutex_);
+
750  amendments.reserve(amendmentMap_.size());
+
751  for (auto const& e : amendmentMap_)
+
752  {
+
753  if (e.second.supported && e.second.vote == AmendmentVote::up &&
+
754  (enabled.count(e.first) == 0))
+
755  {
+
756  amendments.push_back(e.first);
+
757  JLOG(j_.info()) << "Voting for amendment " << e.second.name;
+
758  }
+
759  }
+
760  }
+
761 
+
762  if (!amendments.empty())
+
763  std::sort(amendments.begin(), amendments.end());
+
764 
+
765  return amendments;
+
766 }
+
767 
+
768 std::vector<uint256>
+
769 AmendmentTableImpl::getDesired() const
+
770 {
+
771  // Get the list of amendments we support and do not veto
+
772  return doValidation({});
+
773 }
+
774 
+
775 std::map<uint256, std::uint32_t>
+
776 AmendmentTableImpl::doVoting(
+
777  Rules const& rules,
+
778  NetClock::time_point closeTime,
+
779  std::set<uint256> const& enabledAmendments,
+
780  majorityAmendments_t const& majorityAmendments,
+
781  std::vector<std::shared_ptr<STValidation>> const& valSet)
+
782 {
+
783  JLOG(j_.trace()) << "voting at " << closeTime.time_since_epoch().count()
+
784  << ": " << enabledAmendments.size() << ", "
+
785  << majorityAmendments.size() << ", " << valSet.size();
+
786 
+
787  std::lock_guard lock(mutex_);
+
788 
+
789  // Keep a record of the votes we received.
+
790  previousTrustedVotes_.recordVotes(rules, valSet, closeTime, lock);
+
791 
+
792  // Tally the most recent votes.
+
793  auto vote =
+
794  std::make_unique<AmendmentSet>(rules, previousTrustedVotes_, lock);
+
795  JLOG(j_.debug()) << "Received " << vote->trustedValidations()
+
796  << " trusted validations, threshold is: "
+
797  << vote->threshold();
+
798 
+
799  // Map of amendments to the action to be taken for each one. The action is
+
800  // the value of the flags in the pseudo-transaction
+
801  std::map<uint256, std::uint32_t> actions;
+
802 
+
803  // process all amendments we know of
+
804  for (auto const& entry : amendmentMap_)
+
805  {
+
806  NetClock::time_point majorityTime = {};
+
807 
+
808  bool const hasValMajority = vote->passes(entry.first);
+
809 
+
810  {
+
811  auto const it = majorityAmendments.find(entry.first);
+
812  if (it != majorityAmendments.end())
+
813  majorityTime = it->second;
+
814  }
+
815 
+
816  if (enabledAmendments.count(entry.first) != 0)
+
817  {
+
818  JLOG(j_.debug()) << entry.first << ": amendment already enabled";
+
819  }
+
820  else if (
+
821  hasValMajority && (majorityTime == NetClock::time_point{}) &&
+
822  entry.second.vote == AmendmentVote::up)
+
823  {
+
824  // Ledger says no majority, validators say yes
+
825  JLOG(j_.debug()) << entry.first << ": amendment got majority";
+
826  actions[entry.first] = tfGotMajority;
+
827  }
+
828  else if (!hasValMajority && (majorityTime != NetClock::time_point{}))
+
829  {
+
830  // Ledger says majority, validators say no
+
831  JLOG(j_.debug()) << entry.first << ": amendment lost majority";
+
832  actions[entry.first] = tfLostMajority;
+
833  }
+
834  else if (
+
835  (majorityTime != NetClock::time_point{}) &&
+
836  ((majorityTime + majorityTime_) <= closeTime) &&
+
837  entry.second.vote == AmendmentVote::up)
+
838  {
+
839  // Ledger says majority held
+
840  JLOG(j_.debug()) << entry.first << ": amendment majority held";
+
841  actions[entry.first] = 0;
+
842  }
+
843  }
+
844 
+
845  // Stash for reporting
+
846  lastVote_ = std::move(vote);
+
847  return actions;
+
848 }
+
849 
+
850 bool
+
851 AmendmentTableImpl::needValidatedLedger(LedgerIndex ledgerSeq) const
+
852 {
+
853  std::lock_guard lock(mutex_);
+
854 
+
855  // Is there a ledger in which an amendment could have been enabled
+
856  // between these two ledger sequences?
+
857 
+
858  return ((ledgerSeq - 1) / 256) != ((lastUpdateSeq_ - 1) / 256);
+
859 }
+
860 
+
861 void
+
862 AmendmentTableImpl::doValidatedLedger(
+
863  LedgerIndex ledgerSeq,
+
864  std::set<uint256> const& enabled,
+
865  majorityAmendments_t const& majority)
+
866 {
+
867  for (auto& e : enabled)
+
868  enable(e);
+
869 
+
870  std::lock_guard lock(mutex_);
+
871 
+
872  // Remember the ledger sequence of this update.
+
873  lastUpdateSeq_ = ledgerSeq;
+
874 
+
875  // Since we have the whole list in `majority`, reset the time flag, even
+
876  // if it's currently set. If it's not set when the loop is done, then any
+
877  // prior unknown amendments have lost majority.
+
878  firstUnsupportedExpected_.reset();
+
879  for (auto const& [hash, time] : majority)
+
880  {
+
881  AmendmentState& s = add(hash, lock);
+
882 
+
883  if (s.enabled)
+
884  continue;
+
885 
+
886  if (!s.supported)
+
887  {
+
888  JLOG(j_.info()) << "Unsupported amendment " << hash
+
889  << " reached majority at " << to_string(time);
+
890  if (!firstUnsupportedExpected_ || firstUnsupportedExpected_ > time)
+
891  firstUnsupportedExpected_ = time;
+
892  }
+
893  }
+
894  if (firstUnsupportedExpected_)
+
895  firstUnsupportedExpected_ = *firstUnsupportedExpected_ + majorityTime_;
+
896 }
+
897 
+
898 void
+
899 AmendmentTableImpl::trustChanged(hash_set<PublicKey> const& allTrusted)
+
900 {
+
901  std::lock_guard lock(mutex_);
+
902  previousTrustedVotes_.trustChanged(allTrusted, lock);
+
903 }
+
904 
+
905 void
+
906 AmendmentTableImpl::injectJson(
+
907  Json::Value& v,
+
908  const uint256& id,
+
909  const AmendmentState& fs,
+
910  bool isAdmin,
+
911  std::lock_guard<std::mutex> const&) const
+
912 {
+
913  if (!fs.name.empty())
+
914  v[jss::name] = fs.name;
+
915 
+
916  v[jss::supported] = fs.supported;
+
917  if (!fs.enabled && isAdmin)
+
918  {
+
919  if (fs.vote == AmendmentVote::obsolete)
+
920  v[jss::vetoed] = "Obsolete";
+
921  else
+
922  v[jss::vetoed] = fs.vote == AmendmentVote::down;
+
923  }
+
924  v[jss::enabled] = fs.enabled;
+
925 
+
926  if (!fs.enabled && lastVote_ && isAdmin)
+
927  {
+
928  auto const votesTotal = lastVote_->trustedValidations();
+
929  auto const votesNeeded = lastVote_->threshold();
+
930  auto const votesFor = lastVote_->votes(id);
+
931 
+
932  v[jss::count] = votesFor;
+
933  v[jss::validations] = votesTotal;
+
934 
+
935  if (votesNeeded)
+
936  v[jss::threshold] = votesNeeded;
+
937  }
+
938 }
+
939 
+
940 Json::Value
+
941 AmendmentTableImpl::getJson(bool isAdmin) const
+
942 {
+
943  Json::Value ret(Json::objectValue);
+
944  {
+
945  std::lock_guard lock(mutex_);
+
946  for (auto const& e : amendmentMap_)
+
947  {
+
948  injectJson(
+
949  ret[to_string(e.first)] = Json::objectValue,
+
950  e.first,
+
951  e.second,
+
952  isAdmin,
+
953  lock);
+
954  }
+
955  }
+
956  return ret;
+
957 }
+
958 
+
959 Json::Value
+
960 AmendmentTableImpl::getJson(uint256 const& amendmentID, bool isAdmin) const
+
961 {
+
962  Json::Value ret = Json::objectValue;
+
963 
+
964  {
+
965  std::lock_guard lock(mutex_);
+
966  AmendmentState const* a = get(amendmentID, lock);
+
967  if (a)
+
968  {
+
969  Json::Value& jAmendment =
+
970  (ret[to_string(amendmentID)] = Json::objectValue);
+
971  injectJson(jAmendment, amendmentID, *a, isAdmin, lock);
+
972  }
+
973  }
+
974 
+
975  return ret;
+
976 }
+
977 
+
978 std::unique_ptr<AmendmentTable>
+
979 make_AmendmentTable(
+
980  Application& app,
+
981  std::chrono::seconds majorityTime,
+
982  std::vector<AmendmentTable::FeatureInfo> const& supported,
+
983  Section const& enabled,
+
984  Section const& vetoed,
+
985  beast::Journal journal)
+
986 {
+
987  return std::make_unique<AmendmentTableImpl>(
+
988  app, majorityTime, supported, enabled, vetoed, journal);
+
989 }
+
990 
+
991 } // namespace ripple
+
ripple::isAdmin
bool isAdmin(Port const &port, Json::Value const &params, beast::IP::Address const &remoteIp)
Definition: Role.cpp:84
ripple::tfGotMajority
constexpr std::uint32_t tfGotMajority
Definition: TxFlags.h:119
ripple::Section
Holds a collection of configuration values.
Definition: BasicConfig.h:42
ripple::Application
Definition: Application.h:116
@@ -1036,24 +1043,25 @@ $(function() {
ripple::AmendmentVote::obsolete
@ obsolete
ripple::AmendmentTableImpl::firstUnsupportedExpected_
std::optional< NetClock::time_point > firstUnsupportedExpected_
Definition: AmendmentTable.cpp:366
std::unordered_set
STL class.
-
ripple::AmendmentTableImpl::getDesired
std::vector< uint256 > getDesired() const override
Definition: AmendmentTable.cpp:768
+
ripple::AmendmentTableImpl::getDesired
std::vector< uint256 > getDesired() const override
Definition: AmendmentTable.cpp:769
std::pair
ripple::AmendmentTableImpl::mutex_
std::mutex mutex_
Definition: AmendmentTable.cpp:345
ripple::AmendmentTableImpl::unsupportedEnabled_
bool unsupportedEnabled_
Definition: AmendmentTable.cpp:361
-
ripple::AmendmentTableImpl::doValidation
std::vector< uint256 > doValidation(std::set< uint256 > const &enabledAmendments) const override
Definition: AmendmentTable.cpp:741
+
ripple::AmendmentTableImpl::doValidation
std::vector< uint256 > doValidation(std::set< uint256 > const &enabledAmendments) const override
Definition: AmendmentTable.cpp:742
ripple::createFeatureVotes
bool createFeatureVotes(soci::session &session)
createFeatureVotes Creates the FeatureVote table if it does not exist.
Definition: Wallet.cpp:225
std::vector
STL class.
std::unordered_map::find
T find(T... args)
std::unordered_set::size
T size(T... args)
ripple::VoteBehavior::DefaultNo
@ DefaultNo
std::chrono::duration
-
ripple::AmendmentTableImpl::find
uint256 find(std::string const &name) const override
Definition: AmendmentTable.cpp:639
+
ripple::AmendmentTableImpl::find
uint256 find(std::string const &name) const override
Definition: AmendmentTable.cpp:640
beast::Journal::warn
Stream warn() const
Definition: Journal.h:326
ripple::AmendmentSet::votes_
hash_map< uint256, int > votes_
Definition: AmendmentTable.cpp:249
std::lock_guard
STL class.
-
ripple::AmendmentTableImpl::unVeto
bool unVeto(uint256 const &amendment) override
Definition: AmendmentTable.cpp:677
+
ripple::AmendmentTableImpl::unVeto
bool unVeto(uint256 const &amendment) override
Definition: AmendmentTable.cpp:678
ripple::AmendmentState::vote
AmendmentVote vote
If an amendment is down-voted, a server will not vote to enable it.
Definition: AmendmentTable.cpp:226
ripple::AmendmentSet
The status of all amendments requested in a given window.
Definition: AmendmentTable.cpp:245
+
ripple::AmendmentTableImpl::getJson
Json::Value getJson(bool isAdmin) const override
Definition: AmendmentTable.cpp:941
ripple::TrustedVotes::recordedVotes_
hash_map< PublicKey, UpvotesAndTimeout > recordedVotes_
Definition: AmendmentTable.cpp:101
std::as_const
T as_const(T... args)
ripple::AmendmentTableImpl
Track the list of "amendments".
Definition: AmendmentTable.cpp:342
@@ -1066,20 +1074,21 @@ $(function() {
ripple::AmendmentVote::down
@ down
ripple::base_uint< 256 >
ripple::Section::name
std::string const & name() const
Returns the name of this section.
Definition: BasicConfig.h:59
+
ripple::AmendmentTableImpl::injectJson
void injectJson(Json::Value &v, uint256 const &amendment, AmendmentState const &state, bool isAdmin, std::lock_guard< std::mutex > const &lock) const
Definition: AmendmentTable.cpp:906
std::chrono::time_point::time_since_epoch
T time_since_epoch(T... args)
ripple::AmendmentSet::threshold
int threshold() const
Definition: AmendmentTable.cpp:328
ripple::DatabaseCon::checkoutDb
LockedSociSession checkoutDb()
Definition: DatabaseCon.h:178
Json::objectValue
@ objectValue
object value (collection of name/value pairs).
Definition: json_value.h:43
-
ripple::AmendmentTableImpl::firstUnsupportedExpected
std::optional< NetClock::time_point > firstUnsupportedExpected() const override
Definition: AmendmentTable.cpp:734
+
ripple::AmendmentTableImpl::firstUnsupportedExpected
std::optional< NetClock::time_point > firstUnsupportedExpected() const override
Definition: AmendmentTable.cpp:735
ripple::preFixAmendmentMajorityCalcThreshold
constexpr std::ratio< 204, 256 > preFixAmendmentMajorityCalcThreshold
The minimum amount of support an amendment should have.
Definition: SystemParameters.h:83
ripple::fixAmendmentMajorityCalc
const uint256 fixAmendmentMajorityCalc
-
ripple::AmendmentTableImpl::AmendmentTableImpl
AmendmentTableImpl(Application &app, std::chrono::seconds majorityTime, std::vector< FeatureInfo > const &supported, Section const &enabled, Section const &vetoed, beast::Journal journal)
Definition: AmendmentTable.cpp:464
+
ripple::AmendmentTableImpl::AmendmentTableImpl
AmendmentTableImpl(Application &app, std::chrono::seconds majorityTime, std::vector< FeatureInfo > const &supported, Section const &enabled, Section const &vetoed, beast::Journal journal)
Definition: AmendmentTable.cpp:465
ripple::TrustedVotes::maxTimeout
static constexpr NetClock::time_point maxTimeout
Definition: AmendmentTable.cpp:91
-
ripple::AmendmentTableImpl::doVoting
std::map< uint256, std::uint32_t > doVoting(Rules const &rules, NetClock::time_point closeTime, std::set< uint256 > const &enabledAmendments, majorityAmendments_t const &majorityAmendments, std::vector< std::shared_ptr< STValidation >> const &validations) override
Definition: AmendmentTable.cpp:775
+
ripple::AmendmentTableImpl::doVoting
std::map< uint256, std::uint32_t > doVoting(Rules const &rules, NetClock::time_point closeTime, std::set< uint256 > const &enabledAmendments, majorityAmendments_t const &majorityAmendments, std::vector< std::shared_ptr< STValidation >> const &validations) override
Definition: AmendmentTable.cpp:776
ripple::readAmendments
void readAmendments(soci::session &session, std::function< void(boost::optional< std::string > amendment_hash, boost::optional< std::string > amendment_name, boost::optional< AmendmentVote > vote)> const &callback)
readAmendments Reads all amendments from the FeatureVotes table.
Definition: Wallet.cpp:249
ripple::AmendmentSet::rules_
Rules const & rules_
Definition: AmendmentTable.cpp:250
-
ripple::AmendmentTableImpl::get
AmendmentState * get(uint256 const &amendment, std::lock_guard< std::mutex > const &lock)
Definition: AmendmentTable.cpp:615
-
ripple::AmendmentTableImpl::isSupported
bool isSupported(uint256 const &amendment) const override
Definition: AmendmentTable.cpp:719
+
ripple::AmendmentTableImpl::get
AmendmentState * get(uint256 const &amendment, std::lock_guard< std::mutex > const &lock)
Definition: AmendmentTable.cpp:616
+
ripple::AmendmentTableImpl::isSupported
bool isSupported(uint256 const &amendment) const override
Definition: AmendmentTable.cpp:720
beast::Journal::error
Stream error() const
Definition: Journal.h:332
beast::Journal::info
Stream info() const
Definition: Journal.h:320
std::chrono::time_point
@@ -1092,14 +1101,13 @@ $(function() {
ripple::TrustedVotes::UpvotesAndTimeout
Definition: AmendmentTable.cpp:96
ripple::TrustedVotes::operator=
TrustedVotes & operator=(TrustedVotes const &rhs)=delete
ripple::AmendmentTableImpl::previousTrustedVotes_
TrustedVotes previousTrustedVotes_
Definition: AmendmentTable.cpp:351
-
ripple::AmendmentTableImpl::veto
bool veto(uint256 const &amendment) override
Definition: AmendmentTable.cpp:664
+
ripple::AmendmentTableImpl::veto
bool veto(uint256 const &amendment) override
Definition: AmendmentTable.cpp:665
ripple::TrustedVotes::UpvotesAndTimeout::upVotes
std::vector< uint256 > upVotes
Definition: AmendmentTable.cpp:98
std::unordered_map::swap
T swap(T... args)
ripple::getJson
Json::Value getJson(LedgerFill const &fill)
Return a new Json::Value representing the ledger with given options.
Definition: LedgerToJson.cpp:357
ripple::TrustedVotes::recordVotes
void recordVotes(Rules const &rules, std::vector< std::shared_ptr< STValidation >> const &valSet, NetClock::time_point const closeTime, std::lock_guard< std::mutex > const &lock)
Definition: AmendmentTable.cpp:146
ripple::TrustedVotes::UpvotesAndTimeout::timeout
NetClock::time_point timeout
Definition: AmendmentTable.cpp:99
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
-
ripple::AmendmentTableImpl::injectJson
void injectJson(Json::Value &v, uint256 const &amendment, AmendmentState const &state, std::lock_guard< std::mutex > const &lock) const
Definition: AmendmentTable.cpp:905
ripple::AmendmentSet::computeThreshold
void computeThreshold(int trustedValidations, Rules const &rules)
Definition: AmendmentTable.cpp:257
ripple::AmendmentTableImpl::amendmentMap_
hash_map< uint256, AmendmentState > amendmentMap_
Definition: AmendmentTable.cpp:347
ripple::AmendmentTableImpl::lastVote_
std::unique_ptr< AmendmentSet > lastVote_
Definition: AmendmentTable.cpp:358
@@ -1107,7 +1115,6 @@ $(function() {
ripple::AmendmentTableImpl::majorityTime_
const std::chrono::seconds majorityTime_
Definition: AmendmentTable.cpp:354
ripple::voteAmendment
void voteAmendment(soci::session &session, uint256 const &amendment, std::string const &name, AmendmentVote vote)
voteAmendment Set the veto value for a particular amendment.
Definition: Wallet.cpp:285
ripple::AmendmentState::enabled
bool enabled
Indicates that the amendment has been enabled.
Definition: AmendmentTable.cpp:233
-
ripple::AmendmentTableImpl::getJson
Json::Value getJson() const override
Definition: AmendmentTable.cpp:939
ripple::DatabaseCon
Definition: DatabaseCon.h:81
ripple::AmendmentState::name
std::string name
The name of this amendment, possibly empty.
Definition: AmendmentTable.cpp:239
std::unordered_set::count
T count(T... args)
@@ -1119,31 +1126,31 @@ $(function() {
beast::Journal::debug
Stream debug() const
Definition: Journal.h:314
ripple::TrustedVotes::TrustedVotes
TrustedVotes()=default
ripple::to_string
std::string to_string(Manifest const &m)
Format the specified manifest to a string for debugging purposes.
Definition: app/misc/impl/Manifest.cpp:38
-
ripple::make_AmendmentTable
std::unique_ptr< AmendmentTable > make_AmendmentTable(Application &app, std::chrono::seconds majorityTime, std::vector< AmendmentTable::FeatureInfo > const &supported, Section const &enabled, Section const &vetoed, beast::Journal journal)
Definition: AmendmentTable.cpp:973
+
ripple::make_AmendmentTable
std::unique_ptr< AmendmentTable > make_AmendmentTable(Application &app, std::chrono::seconds majorityTime, std::vector< AmendmentTable::FeatureInfo > const &supported, Section const &enabled, Section const &vetoed, beast::Journal journal)
Definition: AmendmentTable.cpp:979
std::make_pair
T make_pair(T... args)
std::unordered_map::end
T end(T... args)
-
ripple::AmendmentTableImpl::add
AmendmentState & add(uint256 const &amendment, std::lock_guard< std::mutex > const &lock)
Definition: AmendmentTable.cpp:606
+
ripple::AmendmentTableImpl::add
AmendmentState & add(uint256 const &amendment, std::lock_guard< std::mutex > const &lock)
Definition: AmendmentTable.cpp:607
ripple::AmendmentSet::trustedValidations
int trustedValidations() const
Definition: AmendmentTable.cpp:322
-
ripple::AmendmentTableImpl::isEnabled
bool isEnabled(uint256 const &amendment) const override
Definition: AmendmentTable.cpp:711
+
ripple::AmendmentTableImpl::isEnabled
bool isEnabled(uint256 const &amendment) const override
Definition: AmendmentTable.cpp:712
std::chrono::time_point::max
T max(T... args)
ripple::base_uint::parseHex
constexpr bool parseHex(std::string_view sv)
Parse a hex string into a base_uint.
Definition: base_uint.h:496
ripple::AmendmentTableImpl::j_
const beast::Journal j_
Definition: AmendmentTable.cpp:368
ripple::AmendmentTable
The amendment table stores the list of enabled and potential amendments.
Definition: AmendmentTable.h:37
-
ripple::AmendmentTableImpl::needValidatedLedger
bool needValidatedLedger(LedgerIndex seq) const override
Called to determine whether the amendment logic needs to process a new validated ledger.
Definition: AmendmentTable.cpp:850
+
ripple::AmendmentTableImpl::needValidatedLedger
bool needValidatedLedger(LedgerIndex seq) const override
Called to determine whether the amendment logic needs to process a new validated ledger.
Definition: AmendmentTable.cpp:851
ripple::AmendmentSet::votes
int votes(uint256 const &amendment) const
Definition: AmendmentTable.cpp:311
std::unique_ptr
STL class.
ripple::TrustedVotes
TrustedVotes records the most recent votes from trusted validators.
Definition: AmendmentTable.cpp:88
std::unordered_map
STL class.
-
ripple::AmendmentTableImpl::trustChanged
void trustChanged(hash_set< PublicKey > const &allTrusted) override
Definition: AmendmentTable.cpp:898
-
ripple::AmendmentTableImpl::persistVote
void persistVote(uint256 const &amendment, std::string const &name, AmendmentVote vote) const
Definition: AmendmentTable.cpp:653
+
ripple::AmendmentTableImpl::trustChanged
void trustChanged(hash_set< PublicKey > const &allTrusted) override
Definition: AmendmentTable.cpp:899
+
ripple::AmendmentTableImpl::persistVote
void persistVote(uint256 const &amendment, std::string const &name, AmendmentVote vote) const
Definition: AmendmentTable.cpp:654
std::set
STL class.
ripple::postFixAmendmentMajorityCalcThreshold
constexpr std::ratio< 80, 100 > postFixAmendmentMajorityCalcThreshold
Definition: SystemParameters.h:85
-
ripple::AmendmentTableImpl::doValidatedLedger
void doValidatedLedger(LedgerIndex seq, std::set< uint256 > const &enabled, majorityAmendments_t const &majority) override
Definition: AmendmentTable.cpp:861
-
ripple::AmendmentTableImpl::enable
bool enable(uint256 const &amendment) override
Definition: AmendmentTable.cpp:690
+
ripple::AmendmentTableImpl::doValidatedLedger
void doValidatedLedger(LedgerIndex seq, std::set< uint256 > const &enabled, majorityAmendments_t const &majority) override
Definition: AmendmentTable.cpp:862
+
ripple::AmendmentTableImpl::enable
bool enable(uint256 const &amendment) override
Definition: AmendmentTable.cpp:691
Json::Value
Represents a JSON value.
Definition: json_value.h:145
ripple::sfAmendments
const SF_VECTOR256 sfAmendments
ripple::get
T & get(EitherAmount &amt)
Definition: AmountSpec.h:118
-
ripple::AmendmentTableImpl::hasUnsupportedEnabled
bool hasUnsupportedEnabled() const override
returns true if one or more amendments on the network have been enabled that this server does not sup...
Definition: AmendmentTable.cpp:727
+
ripple::AmendmentTableImpl::hasUnsupportedEnabled
bool hasUnsupportedEnabled() const override
returns true if one or more amendments on the network have been enabled that this server does not sup...
Definition: AmendmentTable.cpp:728
ripple::VoteBehavior::DefaultYes
@ DefaultYes
diff --git a/AmendmentTable_8h_source.html b/AmendmentTable_8h_source.html index 161d1fa3ba..3464de10b4 100644 --- a/AmendmentTable_8h_source.html +++ b/AmendmentTable_8h_source.html @@ -142,10 +142,10 @@ $(function() {
81  firstUnsupportedExpected() const = 0;
82 
83  virtual Json::Value
-
84  getJson() const = 0;
+
84  getJson(bool isAdmin) const = 0;
85 
87  virtual Json::Value
-
88  getJson(uint256 const& amendment) const = 0;
+
88  getJson(uint256 const& amendment, bool isAdmin) const = 0;
89 
91  void
92  doValidatedLedger(
@@ -250,6 +250,8 @@ $(function() {
194 
195 #endif
+
ripple::AmendmentTable::getJson
virtual Json::Value getJson(bool isAdmin) const =0
+
ripple::isAdmin
bool isAdmin(Port const &port, Json::Value const &params, beast::IP::Address const &remoteIp)
Definition: Role.cpp:84
ripple::getMajorityAmendments
majorityAmendments_t getMajorityAmendments(ReadView const &view)
Definition: View.cpp:638
@@ -267,7 +269,6 @@ $(function() {
ripple::AmendmentTable::trustChanged
virtual void trustChanged(hash_set< PublicKey > const &allTrusted)=0
ripple::AmendmentTable::doValidatedLedger
void doValidatedLedger(std::shared_ptr< ReadView const > const &lastValidatedLedger)
Called when a new fully-validated ledger is accepted.
Definition: AmendmentTable.h:92
-
ripple::AmendmentTable::getJson
virtual Json::Value getJson() const =0
ripple::ttAMENDMENT
@ ttAMENDMENT
This system-generated transaction type is used to update the status of the various amendments.
Definition: TxFormats.h:204
ripple::base_uint< 256 >
@@ -294,7 +295,7 @@ $(function() {
ripple::Rules
Rules controlling protocol behavior.
Definition: Rules.h:33
-
ripple::make_AmendmentTable
std::unique_ptr< AmendmentTable > make_AmendmentTable(Application &app, std::chrono::seconds majorityTime, std::vector< AmendmentTable::FeatureInfo > const &supported, Section const &enabled, Section const &vetoed, beast::Journal journal)
Definition: AmendmentTable.cpp:973
+
ripple::make_AmendmentTable
std::unique_ptr< AmendmentTable > make_AmendmentTable(Application &app, std::chrono::seconds majorityTime, std::vector< AmendmentTable::FeatureInfo > const &supported, Section const &enabled, Section const &vetoed, beast::Journal journal)
Definition: AmendmentTable.cpp:979
ripple::AmendmentTable::FeatureInfo::FeatureInfo
FeatureInfo(std::string const &n, uint256 const &f, VoteBehavior v)
Definition: AmendmentTable.h:43
ripple::AmendmentTable
The amendment table stores the list of enabled and potential amendments.
Definition: AmendmentTable.h:37
std::unique_ptr
STL class.
diff --git a/AmendmentTable__test_8cpp_source.html b/AmendmentTable__test_8cpp_source.html index df7e7f3806..50f21a6694 100644 --- a/AmendmentTable__test_8cpp_source.html +++ b/AmendmentTable__test_8cpp_source.html @@ -359,7 +359,7 @@ $(function() {
288  uint256 const unsupportedID = amendmentId(unsupported_[0]);
289  {
290  Json::Value const unsupp =
-
291  table->getJson(unsupportedID)[to_string(unsupportedID)];
+
291  table->getJson(unsupportedID, true)[to_string(unsupportedID)];
292  BEAST_EXPECT(unsupp.size() == 0);
293  }
294 
@@ -367,7 +367,7 @@ $(function() {
296  table->veto(unsupportedID);
297  {
298  Json::Value const unsupp =
-
299  table->getJson(unsupportedID)[to_string(unsupportedID)];
+
299  table->getJson(unsupportedID, true)[to_string(unsupportedID)];
300  BEAST_EXPECT(unsupp[jss::vetoed].asBool());
301  }
302  }
@@ -709,28 +709,28 @@ $(function() {
638  BEAST_EXPECT(enabled.empty());
639  BEAST_EXPECT(majority.empty());
640 
-
641  votes.emplace_back(testAmendment, validators.size());
-
642 
-
643  doRound(
-
644  env.current()->rules(),
-
645  *table,
-
646  weeks{2},
-
647  validators,
-
648  votes,
-
649  ourVotes,
-
650  enabled,
-
651  majority);
-
652  BEAST_EXPECT(ourVotes.empty());
-
653  BEAST_EXPECT(enabled.empty());
+
641  uint256 const unsupportedID = amendmentId(unsupported_[0]);
+
642  {
+
643  Json::Value const unsupp =
+
644  table->getJson(unsupportedID, false)[to_string(unsupportedID)];
+
645  BEAST_EXPECT(unsupp.size() == 0);
+
646  }
+
647 
+
648  table->veto(unsupportedID);
+
649  {
+
650  Json::Value const unsupp =
+
651  table->getJson(unsupportedID, false)[to_string(unsupportedID)];
+
652  BEAST_EXPECT(!unsupp[jss::vetoed].asBool());
+
653  }
654 
-
655  majority[testAmendment] = hourTime(weeks{1});
+
655  votes.emplace_back(testAmendment, validators.size());
656 
-
657  // Note that the simulation code assumes others behave as we do,
-
658  // so the amendment won't get enabled
+
657  votes.emplace_back(testAmendment, validators.size());
+
658 
659  doRound(
660  env.current()->rules(),
661  *table,
-
662  weeks{5},
+
662  weeks{2},
663  validators,
664  votes,
665  ourVotes,
@@ -738,625 +738,641 @@ $(function() {
667  majority);
668  BEAST_EXPECT(ourVotes.empty());
669  BEAST_EXPECT(enabled.empty());
-
670  }
-
671 
-
672  // No vote on vetoed amendment
-
673  void
-
674  testNoOnVetoed(FeatureBitset const& feat)
-
675  {
-
676  testcase("Vote NO on vetoed");
-
677 
-
678  auto const testAmendment = amendmentId("vetoedAmendment");
-
679 
-
680  test::jtx::Env env{*this, feat};
-
681  auto table = makeTable(
-
682  env,
-
683  weeks(2),
-
684  emptyYes_,
-
685  emptySection_,
-
686  makeSection(testAmendment));
+
670 
+
671  majority[testAmendment] = hourTime(weeks{1});
+
672 
+
673  // Note that the simulation code assumes others behave as we do,
+
674  // so the amendment won't get enabled
+
675  doRound(
+
676  env.current()->rules(),
+
677  *table,
+
678  weeks{5},
+
679  validators,
+
680  votes,
+
681  ourVotes,
+
682  enabled,
+
683  majority);
+
684  BEAST_EXPECT(ourVotes.empty());
+
685  BEAST_EXPECT(enabled.empty());
+
686  }
687 
-
688  auto const validators = makeValidators(10, table);
-
689 
-
690  std::vector<std::pair<uint256, int>> votes;
-
691  std::vector<uint256> ourVotes;
-
692  std::set<uint256> enabled;
-
693  majorityAmendments_t majority;
-
694 
-
695  doRound(
-
696  env.current()->rules(),
-
697  *table,
-
698  weeks{1},
-
699  validators,
-
700  votes,
-
701  ourVotes,
-
702  enabled,
-
703  majority);
-
704  BEAST_EXPECT(ourVotes.empty());
-
705  BEAST_EXPECT(enabled.empty());
-
706  BEAST_EXPECT(majority.empty());
-
707 
-
708  votes.emplace_back(testAmendment, validators.size());
-
709 
-
710  doRound(
-
711  env.current()->rules(),
-
712  *table,
-
713  weeks{2},
-
714  validators,
-
715  votes,
-
716  ourVotes,
-
717  enabled,
-
718  majority);
-
719  BEAST_EXPECT(ourVotes.empty());
-
720  BEAST_EXPECT(enabled.empty());
-
721 
-
722  majority[testAmendment] = hourTime(weeks{1});
+
688  // No vote on vetoed amendment
+
689  void
+
690  testNoOnVetoed(FeatureBitset const& feat)
+
691  {
+
692  testcase("Vote NO on vetoed");
+
693 
+
694  auto const testAmendment = amendmentId("vetoedAmendment");
+
695 
+
696  test::jtx::Env env{*this, feat};
+
697  auto table = makeTable(
+
698  env,
+
699  weeks(2),
+
700  emptyYes_,
+
701  emptySection_,
+
702  makeSection(testAmendment));
+
703 
+
704  auto const validators = makeValidators(10, table);
+
705 
+
706  std::vector<std::pair<uint256, int>> votes;
+
707  std::vector<uint256> ourVotes;
+
708  std::set<uint256> enabled;
+
709  majorityAmendments_t majority;
+
710 
+
711  doRound(
+
712  env.current()->rules(),
+
713  *table,
+
714  weeks{1},
+
715  validators,
+
716  votes,
+
717  ourVotes,
+
718  enabled,
+
719  majority);
+
720  BEAST_EXPECT(ourVotes.empty());
+
721  BEAST_EXPECT(enabled.empty());
+
722  BEAST_EXPECT(majority.empty());
723 
-
724  doRound(
-
725  env.current()->rules(),
-
726  *table,
-
727  weeks{5},
-
728  validators,
-
729  votes,
-
730  ourVotes,
-
731  enabled,
-
732  majority);
-
733  BEAST_EXPECT(ourVotes.empty());
-
734  BEAST_EXPECT(enabled.empty());
-
735  }
-
736 
-
737  // Vote on and enable known, not-enabled amendment
-
738  void
-
739  testVoteEnable(FeatureBitset const& feat)
-
740  {
-
741  testcase("voteEnable");
-
742 
-
743  test::jtx::Env env{*this, feat};
-
744  auto table = makeTable(
-
745  env, weeks(2), makeDefaultYes(yes_), emptySection_, emptySection_);
-
746 
-
747  auto const validators = makeValidators(10, table);
-
748 
-
749  std::vector<std::pair<uint256, int>> votes;
-
750  std::vector<uint256> ourVotes;
-
751  std::set<uint256> enabled;
-
752  majorityAmendments_t majority;
-
753 
-
754  // Week 1: We should vote for all known amendments not enabled
-
755  doRound(
-
756  env.current()->rules(),
-
757  *table,
-
758  weeks{1},
-
759  validators,
-
760  votes,
-
761  ourVotes,
-
762  enabled,
-
763  majority);
-
764  BEAST_EXPECT(ourVotes.size() == yes_.size());
-
765  BEAST_EXPECT(enabled.empty());
-
766  for (auto const& i : yes_)
-
767  BEAST_EXPECT(majority.find(amendmentId(i)) == majority.end());
-
768 
-
769  // Now, everyone votes for this feature
-
770  for (auto const& i : yes_)
-
771  votes.emplace_back(amendmentId(i), validators.size());
-
772 
-
773  // Week 2: We should recognize a majority
-
774  doRound(
-
775  env.current()->rules(),
-
776  *table,
-
777  weeks{2},
-
778  validators,
-
779  votes,
-
780  ourVotes,
-
781  enabled,
-
782  majority);
-
783  BEAST_EXPECT(ourVotes.size() == yes_.size());
-
784  BEAST_EXPECT(enabled.empty());
-
785 
+
724  votes.emplace_back(testAmendment, validators.size());
+
725 
+
726  doRound(
+
727  env.current()->rules(),
+
728  *table,
+
729  weeks{2},
+
730  validators,
+
731  votes,
+
732  ourVotes,
+
733  enabled,
+
734  majority);
+
735  BEAST_EXPECT(ourVotes.empty());
+
736  BEAST_EXPECT(enabled.empty());
+
737 
+
738  majority[testAmendment] = hourTime(weeks{1});
+
739 
+
740  doRound(
+
741  env.current()->rules(),
+
742  *table,
+
743  weeks{5},
+
744  validators,
+
745  votes,
+
746  ourVotes,
+
747  enabled,
+
748  majority);
+
749  BEAST_EXPECT(ourVotes.empty());
+
750  BEAST_EXPECT(enabled.empty());
+
751  }
+
752 
+
753  // Vote on and enable known, not-enabled amendment
+
754  void
+
755  testVoteEnable(FeatureBitset const& feat)
+
756  {
+
757  testcase("voteEnable");
+
758 
+
759  test::jtx::Env env{*this, feat};
+
760  auto table = makeTable(
+
761  env, weeks(2), makeDefaultYes(yes_), emptySection_, emptySection_);
+
762 
+
763  auto const validators = makeValidators(10, table);
+
764 
+
765  std::vector<std::pair<uint256, int>> votes;
+
766  std::vector<uint256> ourVotes;
+
767  std::set<uint256> enabled;
+
768  majorityAmendments_t majority;
+
769 
+
770  // Week 1: We should vote for all known amendments not enabled
+
771  doRound(
+
772  env.current()->rules(),
+
773  *table,
+
774  weeks{1},
+
775  validators,
+
776  votes,
+
777  ourVotes,
+
778  enabled,
+
779  majority);
+
780  BEAST_EXPECT(ourVotes.size() == yes_.size());
+
781  BEAST_EXPECT(enabled.empty());
+
782  for (auto const& i : yes_)
+
783  BEAST_EXPECT(majority.find(amendmentId(i)) == majority.end());
+
784 
+
785  // Now, everyone votes for this feature
786  for (auto const& i : yes_)
-
787  BEAST_EXPECT(majority[amendmentId(i)] == hourTime(weeks{2}));
+
787  votes.emplace_back(amendmentId(i), validators.size());
788 
-
789  // Week 5: We should enable the amendment
+
789  // Week 2: We should recognize a majority
790  doRound(
791  env.current()->rules(),
792  *table,
-
793  weeks{5},
+
793  weeks{2},
794  validators,
795  votes,
796  ourVotes,
797  enabled,
798  majority);
-
799  BEAST_EXPECT(enabled.size() == yes_.size());
-
800 
-
801  // Week 6: We should remove it from our votes and from having a majority
-
802  doRound(
-
803  env.current()->rules(),
-
804  *table,
-
805  weeks{6},
-
806  validators,
-
807  votes,
-
808  ourVotes,
-
809  enabled,
-
810  majority);
-
811  BEAST_EXPECT(enabled.size() == yes_.size());
-
812  BEAST_EXPECT(ourVotes.empty());
-
813  for (auto const& i : yes_)
-
814  BEAST_EXPECT(majority.find(amendmentId(i)) == majority.end());
-
815  }
+
799  BEAST_EXPECT(ourVotes.size() == yes_.size());
+
800  BEAST_EXPECT(enabled.empty());
+
801 
+
802  for (auto const& i : yes_)
+
803  BEAST_EXPECT(majority[amendmentId(i)] == hourTime(weeks{2}));
+
804 
+
805  // Week 5: We should enable the amendment
+
806  doRound(
+
807  env.current()->rules(),
+
808  *table,
+
809  weeks{5},
+
810  validators,
+
811  votes,
+
812  ourVotes,
+
813  enabled,
+
814  majority);
+
815  BEAST_EXPECT(enabled.size() == yes_.size());
816 
-
817  // Detect majority at 80%, enable later
-
818  void
-
819  testDetectMajority(FeatureBitset const& feat)
-
820  {
-
821  testcase("detectMajority");
-
822 
-
823  auto const testAmendment = amendmentId("detectMajority");
-
824  test::jtx::Env env{*this, feat};
-
825  auto table = makeTable(
-
826  env,
-
827  weeks(2),
-
828  makeDefaultYes(testAmendment),
-
829  emptySection_,
-
830  emptySection_);
-
831 
-
832  auto const validators = makeValidators(16, table);
-
833 
-
834  std::set<uint256> enabled;
-
835  majorityAmendments_t majority;
-
836 
-
837  for (int i = 0; i <= 17; ++i)
-
838  {
-
839  std::vector<std::pair<uint256, int>> votes;
-
840  std::vector<uint256> ourVotes;
-
841 
-
842  if ((i > 0) && (i < 17))
-
843  votes.emplace_back(testAmendment, i);
-
844 
-
845  doRound(
-
846  env.current()->rules(),
-
847  *table,
-
848  weeks{i},
-
849  validators,
-
850  votes,
-
851  ourVotes,
-
852  enabled,
-
853  majority);
-
854 
-
855  if (i < 13) // 13 => 13/16 = 0.8125 => > 80%
-
856  {
-
857  // We are voting yes, not enabled, no majority
-
858  BEAST_EXPECT(!ourVotes.empty());
-
859  BEAST_EXPECT(enabled.empty());
-
860  BEAST_EXPECT(majority.empty());
-
861  }
-
862  else if (i < 15)
-
863  {
-
864  // We have a majority, not enabled, keep voting
-
865  BEAST_EXPECT(!ourVotes.empty());
-
866  BEAST_EXPECT(!majority.empty());
-
867  BEAST_EXPECT(enabled.empty());
-
868  }
-
869  else if (i == 15)
-
870  {
-
871  // enable, keep voting, remove from majority
-
872  BEAST_EXPECT(!ourVotes.empty());
-
873  BEAST_EXPECT(majority.empty());
-
874  BEAST_EXPECT(!enabled.empty());
-
875  }
-
876  else
-
877  {
-
878  // Done, we should be enabled and not voting
-
879  BEAST_EXPECT(ourVotes.empty());
-
880  BEAST_EXPECT(majority.empty());
-
881  BEAST_EXPECT(!enabled.empty());
-
882  }
-
883  }
-
884  }
-
885 
-
886  // Detect loss of majority
-
887  void
-
888  testLostMajority(FeatureBitset const& feat)
-
889  {
-
890  testcase("lostMajority");
-
891 
-
892  auto const testAmendment = amendmentId("lostMajority");
-
893 
-
894  test::jtx::Env env{*this, feat};
-
895  auto table = makeTable(
-
896  env,
-
897  weeks(8),
-
898  makeDefaultYes(testAmendment),
-
899  emptySection_,
-
900  emptySection_);
+
817  // Week 6: We should remove it from our votes and from having a majority
+
818  doRound(
+
819  env.current()->rules(),
+
820  *table,
+
821  weeks{6},
+
822  validators,
+
823  votes,
+
824  ourVotes,
+
825  enabled,
+
826  majority);
+
827  BEAST_EXPECT(enabled.size() == yes_.size());
+
828  BEAST_EXPECT(ourVotes.empty());
+
829  for (auto const& i : yes_)
+
830  BEAST_EXPECT(majority.find(amendmentId(i)) == majority.end());
+
831  }
+
832 
+
833  // Detect majority at 80%, enable later
+
834  void
+
835  testDetectMajority(FeatureBitset const& feat)
+
836  {
+
837  testcase("detectMajority");
+
838 
+
839  auto const testAmendment = amendmentId("detectMajority");
+
840  test::jtx::Env env{*this, feat};
+
841  auto table = makeTable(
+
842  env,
+
843  weeks(2),
+
844  makeDefaultYes(testAmendment),
+
845  emptySection_,
+
846  emptySection_);
+
847 
+
848  auto const validators = makeValidators(16, table);
+
849 
+
850  std::set<uint256> enabled;
+
851  majorityAmendments_t majority;
+
852 
+
853  for (int i = 0; i <= 17; ++i)
+
854  {
+
855  std::vector<std::pair<uint256, int>> votes;
+
856  std::vector<uint256> ourVotes;
+
857 
+
858  if ((i > 0) && (i < 17))
+
859  votes.emplace_back(testAmendment, i);
+
860 
+
861  doRound(
+
862  env.current()->rules(),
+
863  *table,
+
864  weeks{i},
+
865  validators,
+
866  votes,
+
867  ourVotes,
+
868  enabled,
+
869  majority);
+
870 
+
871  if (i < 13) // 13 => 13/16 = 0.8125 => > 80%
+
872  {
+
873  // We are voting yes, not enabled, no majority
+
874  BEAST_EXPECT(!ourVotes.empty());
+
875  BEAST_EXPECT(enabled.empty());
+
876  BEAST_EXPECT(majority.empty());
+
877  }
+
878  else if (i < 15)
+
879  {
+
880  // We have a majority, not enabled, keep voting
+
881  BEAST_EXPECT(!ourVotes.empty());
+
882  BEAST_EXPECT(!majority.empty());
+
883  BEAST_EXPECT(enabled.empty());
+
884  }
+
885  else if (i == 15)
+
886  {
+
887  // enable, keep voting, remove from majority
+
888  BEAST_EXPECT(!ourVotes.empty());
+
889  BEAST_EXPECT(majority.empty());
+
890  BEAST_EXPECT(!enabled.empty());
+
891  }
+
892  else
+
893  {
+
894  // Done, we should be enabled and not voting
+
895  BEAST_EXPECT(ourVotes.empty());
+
896  BEAST_EXPECT(majority.empty());
+
897  BEAST_EXPECT(!enabled.empty());
+
898  }
+
899  }
+
900  }
901 
-
902  auto const validators = makeValidators(16, table);
-
903 
-
904  std::set<uint256> enabled;
-
905  majorityAmendments_t majority;
-
906 
-
907  {
-
908  // establish majority
-
909  std::vector<std::pair<uint256, int>> votes;
-
910  std::vector<uint256> ourVotes;
-
911 
-
912  votes.emplace_back(testAmendment, validators.size());
-
913 
-
914  doRound(
-
915  env.current()->rules(),
-
916  *table,
-
917  weeks{1},
-
918  validators,
-
919  votes,
-
920  ourVotes,
-
921  enabled,
-
922  majority);
-
923 
-
924  BEAST_EXPECT(enabled.empty());
-
925  BEAST_EXPECT(!majority.empty());
-
926  }
+
902  // Detect loss of majority
+
903  void
+
904  testLostMajority(FeatureBitset const& feat)
+
905  {
+
906  testcase("lostMajority");
+
907 
+
908  auto const testAmendment = amendmentId("lostMajority");
+
909 
+
910  test::jtx::Env env{*this, feat};
+
911  auto table = makeTable(
+
912  env,
+
913  weeks(8),
+
914  makeDefaultYes(testAmendment),
+
915  emptySection_,
+
916  emptySection_);
+
917 
+
918  auto const validators = makeValidators(16, table);
+
919 
+
920  std::set<uint256> enabled;
+
921  majorityAmendments_t majority;
+
922 
+
923  {
+
924  // establish majority
+
925  std::vector<std::pair<uint256, int>> votes;
+
926  std::vector<uint256> ourVotes;
927 
-
928  for (int i = 1; i < 8; ++i)
-
929  {
-
930  std::vector<std::pair<uint256, int>> votes;
-
931  std::vector<uint256> ourVotes;
-
932 
-
933  // Gradually reduce support
-
934  votes.emplace_back(testAmendment, validators.size() - i);
-
935 
-
936  doRound(
-
937  env.current()->rules(),
-
938  *table,
-
939  weeks{i + 1},
-
940  validators,
-
941  votes,
-
942  ourVotes,
-
943  enabled,
-
944  majority);
-
945 
-
946  if (i < 4) // 16 - 3 = 13 => 13/16 = 0.8125 => > 80%
-
947  { // 16 - 4 = 12 => 12/16 = 0.75 => < 80%
-
948  // We are voting yes, not enabled, majority
-
949  BEAST_EXPECT(!ourVotes.empty());
-
950  BEAST_EXPECT(enabled.empty());
-
951  BEAST_EXPECT(!majority.empty());
-
952  }
-
953  else
-
954  {
-
955  // No majority, not enabled, keep voting
-
956  BEAST_EXPECT(!ourVotes.empty());
-
957  BEAST_EXPECT(majority.empty());
-
958  BEAST_EXPECT(enabled.empty());
-
959  }
-
960  }
-
961  }
-
962 
-
963  // Exercise the UNL changing while voting is in progress.
-
964  void
-
965  testChangedUNL(FeatureBitset const& feat)
-
966  {
-
967  // This test doesn't work without fixAmendmentMajorityCalc enabled.
-
968  if (!feat[fixAmendmentMajorityCalc])
-
969  return;
-
970 
-
971  testcase("changedUNL");
-
972 
-
973  auto const testAmendment = amendmentId("changedUNL");
-
974  test::jtx::Env env{*this, feat};
-
975  auto table = makeTable(
-
976  env,
-
977  weeks(8),
-
978  makeDefaultYes(testAmendment),
-
979  emptySection_,
-
980  emptySection_);
-
981 
-
982  std::vector<std::pair<PublicKey, SecretKey>> validators =
-
983  makeValidators(10, table);
-
984 
-
985  std::set<uint256> enabled;
-
986  majorityAmendments_t majority;
-
987 
-
988  {
-
989  // 10 validators with 2 voting against won't get majority.
-
990  std::vector<std::pair<uint256, int>> votes;
-
991  std::vector<uint256> ourVotes;
-
992 
-
993  votes.emplace_back(testAmendment, validators.size() - 2);
-
994 
-
995  doRound(
-
996  env.current()->rules(),
-
997  *table,
-
998  weeks{1},
-
999  validators,
-
1000  votes,
-
1001  ourVotes,
-
1002  enabled,
-
1003  majority);
-
1004 
-
1005  BEAST_EXPECT(enabled.empty());
-
1006  BEAST_EXPECT(majority.empty());
-
1007  }
+
928  votes.emplace_back(testAmendment, validators.size());
+
929 
+
930  doRound(
+
931  env.current()->rules(),
+
932  *table,
+
933  weeks{1},
+
934  validators,
+
935  votes,
+
936  ourVotes,
+
937  enabled,
+
938  majority);
+
939 
+
940  BEAST_EXPECT(enabled.empty());
+
941  BEAST_EXPECT(!majority.empty());
+
942  }
+
943 
+
944  for (int i = 1; i < 8; ++i)
+
945  {
+
946  std::vector<std::pair<uint256, int>> votes;
+
947  std::vector<uint256> ourVotes;
+
948 
+
949  // Gradually reduce support
+
950  votes.emplace_back(testAmendment, validators.size() - i);
+
951 
+
952  doRound(
+
953  env.current()->rules(),
+
954  *table,
+
955  weeks{i + 1},
+
956  validators,
+
957  votes,
+
958  ourVotes,
+
959  enabled,
+
960  majority);
+
961 
+
962  if (i < 4) // 16 - 3 = 13 => 13/16 = 0.8125 => > 80%
+
963  { // 16 - 4 = 12 => 12/16 = 0.75 => < 80%
+
964  // We are voting yes, not enabled, majority
+
965  BEAST_EXPECT(!ourVotes.empty());
+
966  BEAST_EXPECT(enabled.empty());
+
967  BEAST_EXPECT(!majority.empty());
+
968  }
+
969  else
+
970  {
+
971  // No majority, not enabled, keep voting
+
972  BEAST_EXPECT(!ourVotes.empty());
+
973  BEAST_EXPECT(majority.empty());
+
974  BEAST_EXPECT(enabled.empty());
+
975  }
+
976  }
+
977  }
+
978 
+
979  // Exercise the UNL changing while voting is in progress.
+
980  void
+
981  testChangedUNL(FeatureBitset const& feat)
+
982  {
+
983  // This test doesn't work without fixAmendmentMajorityCalc enabled.
+
984  if (!feat[fixAmendmentMajorityCalc])
+
985  return;
+
986 
+
987  testcase("changedUNL");
+
988 
+
989  auto const testAmendment = amendmentId("changedUNL");
+
990  test::jtx::Env env{*this, feat};
+
991  auto table = makeTable(
+
992  env,
+
993  weeks(8),
+
994  makeDefaultYes(testAmendment),
+
995  emptySection_,
+
996  emptySection_);
+
997 
+
998  std::vector<std::pair<PublicKey, SecretKey>> validators =
+
999  makeValidators(10, table);
+
1000 
+
1001  std::set<uint256> enabled;
+
1002  majorityAmendments_t majority;
+
1003 
+
1004  {
+
1005  // 10 validators with 2 voting against won't get majority.
+
1006  std::vector<std::pair<uint256, int>> votes;
+
1007  std::vector<uint256> ourVotes;
1008 
-
1009  // Add one new validator to the UNL.
-
1010  validators.emplace_back(randomKeyPair(KeyType::secp256k1));
-
1011 
-
1012  // A lambda that updates the AmendmentTable with the latest
-
1013  // trusted validators.
-
1014  auto callTrustChanged =
-
1015  [](std::vector<std::pair<PublicKey, SecretKey>> const& validators,
-
1016  std::unique_ptr<AmendmentTable> const& table) {
-
1017  // We need a hash_set to pass to trustChanged.
-
1018  hash_set<PublicKey> trustedValidators;
-
1019  trustedValidators.reserve(validators.size());
-
1020  std::for_each(
-
1021  validators.begin(),
-
1022  validators.end(),
-
1023  [&trustedValidators](auto const& val) {
-
1024  trustedValidators.insert(val.first);
-
1025  });
-
1026 
-
1027  // Tell the AmendmentTable that the UNL changed.
-
1028  table->trustChanged(trustedValidators);
-
1029  };
-
1030 
-
1031  // Tell the table that there's been a change in trusted validators.
-
1032  callTrustChanged(validators, table);
-
1033 
-
1034  {
-
1035  // 11 validators with 2 voting against gains majority.
-
1036  std::vector<std::pair<uint256, int>> votes;
-
1037  std::vector<uint256> ourVotes;
-
1038 
-
1039  votes.emplace_back(testAmendment, validators.size() - 2);
-
1040 
-
1041  doRound(
-
1042  env.current()->rules(),
-
1043  *table,
-
1044  weeks{2},
-
1045  validators,
-
1046  votes,
-
1047  ourVotes,
-
1048  enabled,
-
1049  majority);
-
1050 
-
1051  BEAST_EXPECT(enabled.empty());
-
1052  BEAST_EXPECT(!majority.empty());
-
1053  }
-
1054  {
-
1055  // One of the validators goes flaky and doesn't send validations
-
1056  // (without the UNL changing) so the amendment loses majority.
-
1057  std::pair<PublicKey, SecretKey> const savedValidator =
-
1058  validators.front();
-
1059  validators.erase(validators.begin());
-
1060 
-
1061  std::vector<std::pair<uint256, int>> votes;
-
1062  std::vector<uint256> ourVotes;
-
1063 
-
1064  votes.emplace_back(testAmendment, validators.size() - 2);
-
1065 
-
1066  doRound(
-
1067  env.current()->rules(),
-
1068  *table,
-
1069  weeks{3},
-
1070  validators,
-
1071  votes,
-
1072  ourVotes,
-
1073  enabled,
-
1074  majority);
-
1075 
-
1076  BEAST_EXPECT(enabled.empty());
-
1077  BEAST_EXPECT(majority.empty());
-
1078 
-
1079  // Simulate the validator re-syncing to the network by adding it
-
1080  // back to the validators vector
-
1081  validators.insert(validators.begin(), savedValidator);
-
1082 
-
1083  votes.front().second = validators.size() - 2;
-
1084 
-
1085  doRound(
-
1086  env.current()->rules(),
-
1087  *table,
-
1088  weeks{4},
-
1089  validators,
-
1090  votes,
-
1091  ourVotes,
-
1092  enabled,
-
1093  majority);
+
1009  votes.emplace_back(testAmendment, validators.size() - 2);
+
1010 
+
1011  doRound(
+
1012  env.current()->rules(),
+
1013  *table,
+
1014  weeks{1},
+
1015  validators,
+
1016  votes,
+
1017  ourVotes,
+
1018  enabled,
+
1019  majority);
+
1020 
+
1021  BEAST_EXPECT(enabled.empty());
+
1022  BEAST_EXPECT(majority.empty());
+
1023  }
+
1024 
+
1025  // Add one new validator to the UNL.
+
1026  validators.emplace_back(randomKeyPair(KeyType::secp256k1));
+
1027 
+
1028  // A lambda that updates the AmendmentTable with the latest
+
1029  // trusted validators.
+
1030  auto callTrustChanged =
+
1031  [](std::vector<std::pair<PublicKey, SecretKey>> const& validators,
+
1032  std::unique_ptr<AmendmentTable> const& table) {
+
1033  // We need a hash_set to pass to trustChanged.
+
1034  hash_set<PublicKey> trustedValidators;
+
1035  trustedValidators.reserve(validators.size());
+
1036  std::for_each(
+
1037  validators.begin(),
+
1038  validators.end(),
+
1039  [&trustedValidators](auto const& val) {
+
1040  trustedValidators.insert(val.first);
+
1041  });
+
1042 
+
1043  // Tell the AmendmentTable that the UNL changed.
+
1044  table->trustChanged(trustedValidators);
+
1045  };
+
1046 
+
1047  // Tell the table that there's been a change in trusted validators.
+
1048  callTrustChanged(validators, table);
+
1049 
+
1050  {
+
1051  // 11 validators with 2 voting against gains majority.
+
1052  std::vector<std::pair<uint256, int>> votes;
+
1053  std::vector<uint256> ourVotes;
+
1054 
+
1055  votes.emplace_back(testAmendment, validators.size() - 2);
+
1056 
+
1057  doRound(
+
1058  env.current()->rules(),
+
1059  *table,
+
1060  weeks{2},
+
1061  validators,
+
1062  votes,
+
1063  ourVotes,
+
1064  enabled,
+
1065  majority);
+
1066 
+
1067  BEAST_EXPECT(enabled.empty());
+
1068  BEAST_EXPECT(!majority.empty());
+
1069  }
+
1070  {
+
1071  // One of the validators goes flaky and doesn't send validations
+
1072  // (without the UNL changing) so the amendment loses majority.
+
1073  std::pair<PublicKey, SecretKey> const savedValidator =
+
1074  validators.front();
+
1075  validators.erase(validators.begin());
+
1076 
+
1077  std::vector<std::pair<uint256, int>> votes;
+
1078  std::vector<uint256> ourVotes;
+
1079 
+
1080  votes.emplace_back(testAmendment, validators.size() - 2);
+
1081 
+
1082  doRound(
+
1083  env.current()->rules(),
+
1084  *table,
+
1085  weeks{3},
+
1086  validators,
+
1087  votes,
+
1088  ourVotes,
+
1089  enabled,
+
1090  majority);
+
1091 
+
1092  BEAST_EXPECT(enabled.empty());
+
1093  BEAST_EXPECT(majority.empty());
1094 
-
1095  BEAST_EXPECT(enabled.empty());
-
1096  BEAST_EXPECT(!majority.empty());
-
1097 
-
1098  // Finally, remove one validator from the UNL and see that majority
-
1099  // is lost.
-
1100  validators.erase(validators.begin());
-
1101 
-
1102  // Tell the table that there's been a change in trusted validators.
-
1103  callTrustChanged(validators, table);
-
1104 
-
1105  votes.front().second = validators.size() - 2;
-
1106 
-
1107  doRound(
-
1108  env.current()->rules(),
-
1109  *table,
-
1110  weeks{5},
-
1111  validators,
-
1112  votes,
-
1113  ourVotes,
-
1114  enabled,
-
1115  majority);
-
1116 
-
1117  BEAST_EXPECT(enabled.empty());
-
1118  BEAST_EXPECT(majority.empty());
-
1119  }
-
1120  }
-
1121 
-
1122  // Exercise a validator losing connectivity and then regaining it after
-
1123  // extended delays. Depending on how long that delay is an amendment
-
1124  // either will or will not go live.
-
1125  void
-
1126  testValidatorFlapping(FeatureBitset const& feat)
-
1127  {
-
1128  // This test doesn't work without fixAmendmentMajorityCalc enabled.
-
1129  if (!feat[fixAmendmentMajorityCalc])
-
1130  return;
-
1131 
-
1132  testcase("validatorFlapping");
-
1133 
-
1134  // We run a test where a validator flaps on and off every 23 hours
-
1135  // and another one one where it flaps on and off every 25 hours.
-
1136  //
-
1137  // Since the local validator vote record expires after 24 hours,
-
1138  // with 23 hour flapping the amendment will go live. But with 25
-
1139  // hour flapping the amendment will not go live.
-
1140  for (int flapRateHours : {23, 25})
-
1141  {
-
1142  test::jtx::Env env{*this, feat};
-
1143  auto const testAmendment = amendmentId("validatorFlapping");
-
1144  auto table = makeTable(
-
1145  env,
-
1146  weeks(1),
-
1147  makeDefaultYes(testAmendment),
-
1148  emptySection_,
-
1149  emptySection_);
-
1150 
-
1151  // Make two lists of validators, one with a missing validator, to
-
1152  // make it easy to simulate validator flapping.
-
1153  auto const allValidators = makeValidators(11, table);
-
1154  decltype(allValidators) const mostValidators(
-
1155  allValidators.begin() + 1, allValidators.end());
-
1156  BEAST_EXPECT(allValidators.size() == mostValidators.size() + 1);
-
1157 
-
1158  std::set<uint256> enabled;
-
1159  majorityAmendments_t majority;
-
1160 
-
1161  std::vector<std::pair<uint256, int>> votes;
-
1162  std::vector<uint256> ourVotes;
-
1163 
-
1164  votes.emplace_back(testAmendment, allValidators.size() - 2);
-
1165 
-
1166  int delay = flapRateHours;
-
1167  // Loop for 1 week plus a day.
-
1168  for (int hour = 1; hour < (24 * 8); ++hour)
-
1169  {
-
1170  decltype(allValidators) const& thisHoursValidators =
-
1171  (delay < flapRateHours) ? mostValidators : allValidators;
-
1172  delay = delay == flapRateHours ? 0 : delay + 1;
+
1095  // Simulate the validator re-syncing to the network by adding it
+
1096  // back to the validators vector
+
1097  validators.insert(validators.begin(), savedValidator);
+
1098 
+
1099  votes.front().second = validators.size() - 2;
+
1100 
+
1101  doRound(
+
1102  env.current()->rules(),
+
1103  *table,
+
1104  weeks{4},
+
1105  validators,
+
1106  votes,
+
1107  ourVotes,
+
1108  enabled,
+
1109  majority);
+
1110 
+
1111  BEAST_EXPECT(enabled.empty());
+
1112  BEAST_EXPECT(!majority.empty());
+
1113 
+
1114  // Finally, remove one validator from the UNL and see that majority
+
1115  // is lost.
+
1116  validators.erase(validators.begin());
+
1117 
+
1118  // Tell the table that there's been a change in trusted validators.
+
1119  callTrustChanged(validators, table);
+
1120 
+
1121  votes.front().second = validators.size() - 2;
+
1122 
+
1123  doRound(
+
1124  env.current()->rules(),
+
1125  *table,
+
1126  weeks{5},
+
1127  validators,
+
1128  votes,
+
1129  ourVotes,
+
1130  enabled,
+
1131  majority);
+
1132 
+
1133  BEAST_EXPECT(enabled.empty());
+
1134  BEAST_EXPECT(majority.empty());
+
1135  }
+
1136  }
+
1137 
+
1138  // Exercise a validator losing connectivity and then regaining it after
+
1139  // extended delays. Depending on how long that delay is an amendment
+
1140  // either will or will not go live.
+
1141  void
+
1142  testValidatorFlapping(FeatureBitset const& feat)
+
1143  {
+
1144  // This test doesn't work without fixAmendmentMajorityCalc enabled.
+
1145  if (!feat[fixAmendmentMajorityCalc])
+
1146  return;
+
1147 
+
1148  testcase("validatorFlapping");
+
1149 
+
1150  // We run a test where a validator flaps on and off every 23 hours
+
1151  // and another one one where it flaps on and off every 25 hours.
+
1152  //
+
1153  // Since the local validator vote record expires after 24 hours,
+
1154  // with 23 hour flapping the amendment will go live. But with 25
+
1155  // hour flapping the amendment will not go live.
+
1156  for (int flapRateHours : {23, 25})
+
1157  {
+
1158  test::jtx::Env env{*this, feat};
+
1159  auto const testAmendment = amendmentId("validatorFlapping");
+
1160  auto table = makeTable(
+
1161  env,
+
1162  weeks(1),
+
1163  makeDefaultYes(testAmendment),
+
1164  emptySection_,
+
1165  emptySection_);
+
1166 
+
1167  // Make two lists of validators, one with a missing validator, to
+
1168  // make it easy to simulate validator flapping.
+
1169  auto const allValidators = makeValidators(11, table);
+
1170  decltype(allValidators) const mostValidators(
+
1171  allValidators.begin() + 1, allValidators.end());
+
1172  BEAST_EXPECT(allValidators.size() == mostValidators.size() + 1);
1173 
-
1174  votes.front().second = thisHoursValidators.size() - 2;
-
1175 
-
1176  using namespace std::chrono;
-
1177  doRound(
-
1178  env.current()->rules(),
-
1179  *table,
-
1180  hours(hour),
-
1181  thisHoursValidators,
-
1182  votes,
-
1183  ourVotes,
-
1184  enabled,
-
1185  majority);
-
1186 
-
1187  if (hour <= (24 * 7) || flapRateHours > 24)
-
1188  {
-
1189  // The amendment should not be enabled under any
-
1190  // circumstance until one week has elapsed.
-
1191  BEAST_EXPECT(enabled.empty());
-
1192 
-
1193  // If flapping is less than 24 hours, there should be
-
1194  // no flapping. Otherwise we should only have majority
-
1195  // if allValidators vote -- which means there are no
-
1196  // missing validators.
-
1197  bool const expectMajority = (delay <= 24)
-
1198  ? true
-
1199  : &thisHoursValidators == &allValidators;
-
1200  BEAST_EXPECT(majority.empty() != expectMajority);
-
1201  }
-
1202  else
-
1203  {
-
1204  // We're...
-
1205  // o Past one week, and
-
1206  // o AmendmentFlapping was less than 24 hours.
-
1207  // The amendment should be enabled.
-
1208  BEAST_EXPECT(!enabled.empty());
-
1209  BEAST_EXPECT(majority.empty());
-
1210  }
-
1211  }
-
1212  }
-
1213  }
-
1214 
-
1215  void
-
1216  testHasUnsupported()
-
1217  {
-
1218  testcase("hasUnsupportedEnabled");
-
1219 
-
1220  using namespace std::chrono_literals;
-
1221  weeks constexpr w(1);
-
1222  test::jtx::Env env{*this, makeConfig()};
-
1223  auto table = makeTable(env, w);
-
1224  BEAST_EXPECT(!table->hasUnsupportedEnabled());
-
1225  BEAST_EXPECT(!table->firstUnsupportedExpected());
-
1226  BEAST_EXPECT(table->needValidatedLedger(1));
-
1227 
-
1228  std::set<uint256> enabled;
-
1229  std::for_each(
-
1230  unsupported_.begin(),
-
1231  unsupported_.end(),
-
1232  [&enabled](auto const& s) { enabled.insert(amendmentId(s)); });
-
1233 
-
1234  majorityAmendments_t majority;
-
1235  table->doValidatedLedger(1, enabled, majority);
-
1236  BEAST_EXPECT(table->hasUnsupportedEnabled());
-
1237  BEAST_EXPECT(!table->firstUnsupportedExpected());
-
1238 
-
1239  NetClock::duration t{1000s};
-
1240  std::for_each(
-
1241  unsupportedMajority_.begin(),
-
1242  unsupportedMajority_.end(),
-
1243  [&majority, &t](auto const& s) {
-
1244  majority[amendmentId(s)] = NetClock::time_point{--t};
-
1245  });
-
1246 
-
1247  table->doValidatedLedger(1, enabled, majority);
-
1248  BEAST_EXPECT(table->hasUnsupportedEnabled());
-
1249  BEAST_EXPECT(
-
1250  table->firstUnsupportedExpected() &&
-
1251  *table->firstUnsupportedExpected() == NetClock::time_point{t} + w);
-
1252 
-
1253  // Make sure the table knows when it needs an update.
-
1254  BEAST_EXPECT(!table->needValidatedLedger(256));
-
1255  BEAST_EXPECT(table->needValidatedLedger(257));
-
1256  }
-
1257 
-
1258  void
-
1259  testFeature(FeatureBitset const& feat)
-
1260  {
-
1261  testNoOnUnknown(feat);
-
1262  testNoOnVetoed(feat);
-
1263  testVoteEnable(feat);
-
1264  testDetectMajority(feat);
-
1265  testLostMajority(feat);
-
1266  testChangedUNL(feat);
-
1267  testValidatorFlapping(feat);
-
1268  }
-
1269 
-
1270  void
-
1271  run() override
-
1272  {
-
1273  FeatureBitset const all{test::jtx::supported_amendments()};
-
1274  FeatureBitset const fixMajorityCalc{fixAmendmentMajorityCalc};
-
1275 
-
1276  testConstruct();
-
1277  testGet();
-
1278  testBadConfig();
-
1279  testEnableVeto();
-
1280  testHasUnsupported();
-
1281  testFeature(all - fixMajorityCalc);
-
1282  testFeature(all);
-
1283  }
-
1284 };
+
1174  std::set<uint256> enabled;
+
1175  majorityAmendments_t majority;
+
1176 
+
1177  std::vector<std::pair<uint256, int>> votes;
+
1178  std::vector<uint256> ourVotes;
+
1179 
+
1180  votes.emplace_back(testAmendment, allValidators.size() - 2);
+
1181 
+
1182  int delay = flapRateHours;
+
1183  // Loop for 1 week plus a day.
+
1184  for (int hour = 1; hour < (24 * 8); ++hour)
+
1185  {
+
1186  decltype(allValidators) const& thisHoursValidators =
+
1187  (delay < flapRateHours) ? mostValidators : allValidators;
+
1188  delay = delay == flapRateHours ? 0 : delay + 1;
+
1189 
+
1190  votes.front().second = thisHoursValidators.size() - 2;
+
1191 
+
1192  using namespace std::chrono;
+
1193  doRound(
+
1194  env.current()->rules(),
+
1195  *table,
+
1196  hours(hour),
+
1197  thisHoursValidators,
+
1198  votes,
+
1199  ourVotes,
+
1200  enabled,
+
1201  majority);
+
1202 
+
1203  if (hour <= (24 * 7) || flapRateHours > 24)
+
1204  {
+
1205  // The amendment should not be enabled under any
+
1206  // circumstance until one week has elapsed.
+
1207  BEAST_EXPECT(enabled.empty());
+
1208 
+
1209  // If flapping is less than 24 hours, there should be
+
1210  // no flapping. Otherwise we should only have majority
+
1211  // if allValidators vote -- which means there are no
+
1212  // missing validators.
+
1213  bool const expectMajority = (delay <= 24)
+
1214  ? true
+
1215  : &thisHoursValidators == &allValidators;
+
1216  BEAST_EXPECT(majority.empty() != expectMajority);
+
1217  }
+
1218  else
+
1219  {
+
1220  // We're...
+
1221  // o Past one week, and
+
1222  // o AmendmentFlapping was less than 24 hours.
+
1223  // The amendment should be enabled.
+
1224  BEAST_EXPECT(!enabled.empty());
+
1225  BEAST_EXPECT(majority.empty());
+
1226  }
+
1227  }
+
1228  }
+
1229  }
+
1230 
+
1231  void
+
1232  testHasUnsupported()
+
1233  {
+
1234  testcase("hasUnsupportedEnabled");
+
1235 
+
1236  using namespace std::chrono_literals;
+
1237  weeks constexpr w(1);
+
1238  test::jtx::Env env{*this, makeConfig()};
+
1239  auto table = makeTable(env, w);
+
1240  BEAST_EXPECT(!table->hasUnsupportedEnabled());
+
1241  BEAST_EXPECT(!table->firstUnsupportedExpected());
+
1242  BEAST_EXPECT(table->needValidatedLedger(1));
+
1243 
+
1244  std::set<uint256> enabled;
+
1245  std::for_each(
+
1246  unsupported_.begin(),
+
1247  unsupported_.end(),
+
1248  [&enabled](auto const& s) { enabled.insert(amendmentId(s)); });
+
1249 
+
1250  majorityAmendments_t majority;
+
1251  table->doValidatedLedger(1, enabled, majority);
+
1252  BEAST_EXPECT(table->hasUnsupportedEnabled());
+
1253  BEAST_EXPECT(!table->firstUnsupportedExpected());
+
1254 
+
1255  NetClock::duration t{1000s};
+
1256  std::for_each(
+
1257  unsupportedMajority_.begin(),
+
1258  unsupportedMajority_.end(),
+
1259  [&majority, &t](auto const& s) {
+
1260  majority[amendmentId(s)] = NetClock::time_point{--t};
+
1261  });
+
1262 
+
1263  table->doValidatedLedger(1, enabled, majority);
+
1264  BEAST_EXPECT(table->hasUnsupportedEnabled());
+
1265  BEAST_EXPECT(
+
1266  table->firstUnsupportedExpected() &&
+
1267  *table->firstUnsupportedExpected() == NetClock::time_point{t} + w);
+
1268 
+
1269  // Make sure the table knows when it needs an update.
+
1270  BEAST_EXPECT(!table->needValidatedLedger(256));
+
1271  BEAST_EXPECT(table->needValidatedLedger(257));
+
1272  }
+
1273 
+
1274  void
+
1275  testFeature(FeatureBitset const& feat)
+
1276  {
+
1277  testNoOnUnknown(feat);
+
1278  testNoOnVetoed(feat);
+
1279  testVoteEnable(feat);
+
1280  testDetectMajority(feat);
+
1281  testLostMajority(feat);
+
1282  testChangedUNL(feat);
+
1283  testValidatorFlapping(feat);
+
1284  }
1285 
-
1286 BEAST_DEFINE_TESTSUITE(AmendmentTable, app, ripple);
-
1287 
-
1288 } // namespace ripple
+
1286  void
+
1287  run() override
+
1288  {
+
1289  FeatureBitset const all{test::jtx::supported_amendments()};
+
1290  FeatureBitset const fixMajorityCalc{fixAmendmentMajorityCalc};
+
1291 
+
1292  testConstruct();
+
1293  testGet();
+
1294  testBadConfig();
+
1295  testEnableVeto();
+
1296  testHasUnsupported();
+
1297  testFeature(all - fixMajorityCalc);
+
1298  testFeature(all);
+
1299  }
+
1300 };
+
1301 
+
1302 BEAST_DEFINE_TESTSUITE(AmendmentTable, app, ripple);
+
1303 
+
1304 } // namespace ripple
ripple::tfGotMajority
constexpr std::uint32_t tfGotMajority
Definition: TxFlags.h:119
ripple::Section
Holds a collection of configuration values.
Definition: BasicConfig.h:42
@@ -1376,7 +1392,7 @@ $(function() {
ripple::calcNodeID
NodeID calcNodeID(PublicKey const &pk)
Calculate the 160-bit node ID from a node public key.
Definition: PublicKey.cpp:303
ripple::AmendmentTable_test::makeSection
static Section makeSection(uint256 const &amendment)
Definition: AmendmentTable_test.cpp:71
ripple::sfLedgerSequence
const SF_UINT32 sfLedgerSequence
-
ripple::AmendmentTable_test::testValidatorFlapping
void testValidatorFlapping(FeatureBitset const &feat)
Definition: AmendmentTable_test.cpp:1126
+
ripple::AmendmentTable_test::testValidatorFlapping
void testValidatorFlapping(FeatureBitset const &feat)
Definition: AmendmentTable_test.cpp:1142
std::vector::reserve
T reserve(T... args)
@@ -1389,11 +1405,11 @@ $(function() {
std::back_inserter
T back_inserter(T... args)
ripple::AmendmentTable_test::makeDefaultYes
static std::vector< AmendmentTable::FeatureInfo > makeDefaultYes(uint256 const amendment)
Definition: AmendmentTable_test.cpp:110
-
ripple::AmendmentTable_test::testChangedUNL
void testChangedUNL(FeatureBitset const &feat)
Definition: AmendmentTable_test.cpp:965
+
ripple::AmendmentTable_test::testChangedUNL
void testChangedUNL(FeatureBitset const &feat)
Definition: AmendmentTable_test.cpp:981
ripple::AmendmentTable_test::testNoOnUnknown
void testNoOnUnknown(FeatureBitset const &feat)
Definition: AmendmentTable_test.cpp:611
ripple::test::jtx::Env::app
Application & app()
Definition: Env.h:241
-
ripple::AmendmentTable_test::testHasUnsupported
void testHasUnsupported()
Definition: AmendmentTable_test.cpp:1216
+
ripple::AmendmentTable_test::testHasUnsupported
void testHasUnsupported()
Definition: AmendmentTable_test.cpp:1232
ripple::test::jtx::envconfig
std::unique_ptr< Config > envconfig()
creates and initializes a default configuration for jtx::Env
Definition: envconfig.h:54
std::vector::front
T front(T... args)
ripple::base_uint::data
pointer data()
Definition: base_uint.h:122
@@ -1409,7 +1425,7 @@ $(function() {
ripple::AmendmentTable::doValidation
virtual std::vector< uint256 > doValidation(std::set< uint256 > const &enabled) const =0
ripple::AmendmentTable_test::testEnableVeto
void testEnableVeto()
Definition: AmendmentTable_test.cpp:411
ripple::weeks
std::chrono::duration< int, std::ratio_multiply< days::period, std::ratio< 7 > >> weeks
Definition: chrono.h:44
-
ripple::AmendmentTable_test::testNoOnVetoed
void testNoOnVetoed(FeatureBitset const &feat)
Definition: AmendmentTable_test.cpp:674
+
ripple::AmendmentTable_test::testNoOnVetoed
void testNoOnVetoed(FeatureBitset const &feat)
Definition: AmendmentTable_test.cpp:690
ripple::VoteBehavior
VoteBehavior
Definition: Feature.h:69
ripple::AmendmentTable_test::totalsize
static size_t totalsize(std::vector< Arg > const &src, Args const &... args)
Definition: AmendmentTable_test.cpp:131
ripple::AmendmentTable_test::makeTable
std::unique_ptr< AmendmentTable > makeTable(test::jtx::Env &env, std::chrono::seconds majorityTime)
Definition: AmendmentTable_test.cpp:216
@@ -1419,7 +1435,7 @@ $(function() {
Json::Value::size
UInt size() const
Number of values in array or object.
Definition: json_value.cpp:706
std::map::erase
T erase(T... args)
std::copy
T copy(T... args)
-
ripple::AmendmentTable_test::testFeature
void testFeature(FeatureBitset const &feat)
Definition: AmendmentTable_test.cpp:1259
+
ripple::AmendmentTable_test::testFeature
void testFeature(FeatureBitset const &feat)
Definition: AmendmentTable_test.cpp:1275
ripple::AmendmentTable_test::yes_
const std::vector< std::string > yes_
Definition: AmendmentTable_test.cpp:172
ripple::test::jtx::supported_amendments
FeatureBitset supported_amendments()
Definition: Env.h:70
ripple::AmendmentTable_test::makeObsolete
static std::vector< AmendmentTable::FeatureInfo > makeObsolete(std::vector< std::string > const &amendments)
Definition: AmendmentTable_test.cpp:124
@@ -1449,12 +1465,12 @@ $(function() {
ripple::AmendmentTable_test::combine
static std::vector< Arg > combine(std::vector< Arg > left, std::vector< Arg > const &right, Args const &... args)
Definition: AmendmentTable_test.cpp:153
ripple::to_string
std::string to_string(Manifest const &m)
Format the specified manifest to a string for debugging purposes.
Definition: app/misc/impl/Manifest.cpp:38
std::memcpy
T memcpy(T... args)
-
ripple::make_AmendmentTable
std::unique_ptr< AmendmentTable > make_AmendmentTable(Application &app, std::chrono::seconds majorityTime, std::vector< AmendmentTable::FeatureInfo > const &supported, Section const &enabled, Section const &vetoed, beast::Journal journal)
Definition: AmendmentTable.cpp:973
+
ripple::make_AmendmentTable
std::unique_ptr< AmendmentTable > make_AmendmentTable(Application &app, std::chrono::seconds majorityTime, std::vector< AmendmentTable::FeatureInfo > const &supported, Section const &enabled, Section const &vetoed, beast::Journal journal)
Definition: AmendmentTable.cpp:979
ripple::AmendmentTable_test::makeFeatureInfo
static std::vector< AmendmentTable::FeatureInfo > makeFeatureInfo(std::vector< std::string > const &amendments, VoteBehavior voteBehavior)
Definition: AmendmentTable_test.cpp:90
std::vector::end
T end(T... args)
-
ripple::AmendmentTable_test::testVoteEnable
void testVoteEnable(FeatureBitset const &feat)
Definition: AmendmentTable_test.cpp:739
-
ripple::AmendmentTable_test::testDetectMajority
void testDetectMajority(FeatureBitset const &feat)
Definition: AmendmentTable_test.cpp:819
-
ripple::AmendmentTable_test::testLostMajority
void testLostMajority(FeatureBitset const &feat)
Definition: AmendmentTable_test.cpp:888
+
ripple::AmendmentTable_test::testVoteEnable
void testVoteEnable(FeatureBitset const &feat)
Definition: AmendmentTable_test.cpp:755
+
ripple::AmendmentTable_test::testDetectMajority
void testDetectMajority(FeatureBitset const &feat)
Definition: AmendmentTable_test.cpp:835
+
ripple::AmendmentTable_test::testLostMajority
void testLostMajority(FeatureBitset const &feat)
Definition: AmendmentTable_test.cpp:904
ripple::AmendmentTable_test
Definition: AmendmentTable_test.cpp:38
ripple::AmendmentTable_test::makeTable
std::unique_ptr< AmendmentTable > makeTable(Application &app, std::chrono::seconds majorityTime, std::vector< AmendmentTable::FeatureInfo > const &supported, Section const &enabled, Section const &vetoed)
Definition: AmendmentTable_test.cpp:193
ripple::AmendmentTable_test::makeDefaultYes
static std::vector< AmendmentTable::FeatureInfo > makeDefaultYes(std::vector< std::string > const &amendments)
Definition: AmendmentTable_test.cpp:104
@@ -1465,7 +1481,7 @@ $(function() {
ripple::AmendmentTable_test::AmendmentTable_test
AmendmentTable_test()
Definition: AmendmentTable_test.cpp:188
ripple::AmendmentTable_test::testBadConfig
void testBadConfig()
Definition: AmendmentTable_test.cpp:305
std::set
STL class.
-
ripple::AmendmentTable_test::run
void run() override
Definition: AmendmentTable_test.cpp:1271
+
ripple::AmendmentTable_test::run
void run() override
Definition: AmendmentTable_test.cpp:1287
ripple::AmendmentTable_test::amendmentId
static uint256 amendmentId(std::string in)
Definition: AmendmentTable_test.cpp:42
ripple::AmendmentTable_test::enabled_
const std::vector< std::string > enabled_
Definition: AmendmentTable_test.cpp:174
ripple::test::jtx::Env
A transaction testing environment.
Definition: Env.h:116
diff --git a/Application_8cpp_source.html b/Application_8cpp_source.html index 33eed09dd2..bb9a81a612 100644 --- a/Application_8cpp_source.html +++ b/Application_8cpp_source.html @@ -2783,7 +2783,7 @@ $(function() {
ripple::to_string
std::string to_string(Manifest const &m)
Format the specified manifest to a string for debugging purposes.
Definition: app/misc/impl/Manifest.cpp:38
ripple::keylet::fees
Keylet const & fees() noexcept
The (fixed) index of the object containing the ledger fees.
Definition: Indexes.cpp:181
-
ripple::make_AmendmentTable
std::unique_ptr< AmendmentTable > make_AmendmentTable(Application &app, std::chrono::seconds majorityTime, std::vector< AmendmentTable::FeatureInfo > const &supported, Section const &enabled, Section const &vetoed, beast::Journal journal)
Definition: AmendmentTable.cpp:973
+
ripple::make_AmendmentTable
std::unique_ptr< AmendmentTable > make_AmendmentTable(Application &app, std::chrono::seconds majorityTime, std::vector< AmendmentTable::FeatureInfo > const &supported, Section const &enabled, Section const &vetoed, beast::Journal journal)
Definition: AmendmentTable.cpp:979
ripple::ApplicationImp::validatorManifests_
std::unique_ptr< ManifestCache > validatorManifests_
Definition: Application.cpp:210
ripple::ApplicationImp::m_pathRequests
std::unique_ptr< PathRequests > m_pathRequests
Definition: Application.cpp:200
diff --git a/Feature1_8cpp_source.html b/Feature1_8cpp_source.html index 4775da12f2..683f763f61 100644 --- a/Feature1_8cpp_source.html +++ b/Feature1_8cpp_source.html @@ -93,86 +93,97 @@ $(function() {
22 #include <ripple/app/misc/AmendmentTable.h>
23 #include <ripple/net/RPCErr.h>
24 #include <ripple/protocol/ErrorCodes.h>
-
25 #include <ripple/protocol/jss.h>
-
26 #include <ripple/rpc/Context.h>
-
27 
-
28 namespace ripple {
-
29 
-
30 // {
-
31 // feature : <feature>
-
32 // vetoed : true/false
-
33 // }
-
34 Json::Value
-
35 doFeature(RPC::JsonContext& context)
-
36 {
-
37  if (context.app.config().reporting())
-
38  return rpcError(rpcREPORTING_UNSUPPORTED);
-
39 
-
40  // Get majority amendment status
-
41  majorityAmendments_t majorities;
-
42 
-
43  if (auto const valLedger = context.ledgerMaster.getValidatedLedger())
-
44  majorities = getMajorityAmendments(*valLedger);
-
45 
-
46  auto& table = context.app.getAmendmentTable();
+
25 #include <ripple/protocol/Feature.h>
+
26 #include <ripple/protocol/jss.h>
+
27 #include <ripple/rpc/Context.h>
+
28 
+
29 namespace ripple {
+
30 
+
31 // {
+
32 // feature : <feature>
+
33 // vetoed : true/false
+
34 // }
+
35 Json::Value
+
36 doFeature(RPC::JsonContext& context)
+
37 {
+
38  if (context.app.config().reporting())
+
39  return rpcError(rpcREPORTING_UNSUPPORTED);
+
40 
+
41  bool const isAdmin = context.role == Role::ADMIN;
+
42  // Get majority amendment status
+
43  majorityAmendments_t majorities;
+
44 
+
45  if (auto const valLedger = context.ledgerMaster.getValidatedLedger())
+
46  majorities = getMajorityAmendments(*valLedger);
47 
-
48  if (!context.params.isMember(jss::feature))
-
49  {
-
50  auto features = table.getJson();
-
51 
-
52  for (auto const& [h, t] : majorities)
-
53  {
-
54  features[to_string(h)][jss::majority] =
-
55  t.time_since_epoch().count();
-
56  }
-
57 
-
58  Json::Value jvReply = Json::objectValue;
-
59  jvReply[jss::features] = features;
-
60  return jvReply;
-
61  }
-
62 
-
63  auto feature = table.find(context.params[jss::feature].asString());
+
48  auto& table = context.app.getAmendmentTable();
+
49 
+
50  if (!context.params.isMember(jss::feature))
+
51  {
+
52  auto features = table.getJson(isAdmin);
+
53 
+
54  for (auto const& [h, t] : majorities)
+
55  {
+
56  features[to_string(h)][jss::majority] =
+
57  t.time_since_epoch().count();
+
58  }
+
59 
+
60  Json::Value jvReply = Json::objectValue;
+
61  jvReply[jss::features] = features;
+
62  return jvReply;
+
63  }
64 
-
65  // If the feature is not found by name, try to parse the `feature` param as
-
66  // a feature ID. If that fails, return an error.
-
67  if (!feature && !feature.parseHex(context.params[jss::feature].asString()))
-
68  return rpcError(rpcBAD_FEATURE);
-
69 
-
70  if (context.params.isMember(jss::vetoed))
-
71  {
-
72  if (context.params[jss::vetoed].asBool())
-
73  table.veto(feature);
-
74  else
-
75  table.unVeto(feature);
-
76  }
-
77 
-
78  Json::Value jvReply = table.getJson(feature);
-
79 
-
80  auto m = majorities.find(feature);
-
81  if (m != majorities.end())
-
82  jvReply[jss::majority] = m->second.time_since_epoch().count();
-
83 
-
84  return jvReply;
-
85 }
+
65  auto feature = table.find(context.params[jss::feature].asString());
+
66 
+
67  // If the feature is not found by name, try to parse the `feature` param as
+
68  // a feature ID. If that fails, return an error.
+
69  if (!feature && !feature.parseHex(context.params[jss::feature].asString()))
+
70  return rpcError(rpcBAD_FEATURE);
+
71 
+
72  if (context.params.isMember(jss::vetoed))
+
73  {
+
74  if (!isAdmin)
+
75  return rpcError(rpcNO_PERMISSION);
+
76 
+
77  if (context.params[jss::vetoed].asBool())
+
78  table.veto(feature);
+
79  else
+
80  table.unVeto(feature);
+
81  }
+
82 
+
83  Json::Value jvReply = table.getJson(feature, isAdmin);
+
84  if (!jvReply)
+
85  return rpcError(rpcBAD_FEATURE);
86 
-
87 } // namespace ripple
+
87  auto m = majorities.find(feature);
+
88  if (m != majorities.end())
+
89  jvReply[jss::majority] = m->second.time_since_epoch().count();
+
90 
+
91  return jvReply;
+
92 }
+
93 
+
94 } // namespace ripple
-
ripple::doFeature
Json::Value doFeature(RPC::JsonContext &context)
Definition: Feature1.cpp:35
+
ripple::isAdmin
bool isAdmin(Port const &port, Json::Value const &params, beast::IP::Address const &remoteIp)
Definition: Role.cpp:84
+
ripple::doFeature
Json::Value doFeature(RPC::JsonContext &context)
Definition: Feature1.cpp:36
ripple::getMajorityAmendments
majorityAmendments_t getMajorityAmendments(ReadView const &view)
Definition: View.cpp:638
ripple::rpcError
Json::Value rpcError(int iError)
Definition: RPCErr.cpp:29
ripple::Application::getAmendmentTable
virtual AmendmentTable & getAmendmentTable()=0
std::map::find
T find(T... args)
ripple::RPC::Context::ledgerMaster
LedgerMaster & ledgerMaster
Definition: Context.h:45
+
ripple::rpcREPORTING_UNSUPPORTED
@ rpcREPORTING_UNSUPPORTED
Definition: ErrorCodes.h:141
Json::Value::asBool
bool asBool() const
Definition: json_value.cpp:619
ripple::Config::reporting
bool reporting() const
Definition: Config.h:350
+
Json::objectValue
@ objectValue
object value (collection of name/value pairs).
Definition: json_value.h:43
ripple::Application::config
virtual Config & config()=0
ripple::RPC::Context::app
Application & app
Definition: Context.h:42
Json::Value::isMember
bool isMember(const char *key) const
Return true if the object has a member named key.
Definition: json_value.cpp:932
std::map
STL class.
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
+
ripple::rpcNO_PERMISSION
@ rpcNO_PERMISSION
Definition: ErrorCodes.h:53
ripple::LedgerMaster::getValidatedLedger
std::shared_ptr< Ledger const > getValidatedLedger()
Definition: LedgerMaster.cpp:1717
ripple::to_string
std::string to_string(Manifest const &m)
Format the specified manifest to a string for debugging purposes.
Definition: app/misc/impl/Manifest.cpp:38
std::map::end
T end(T... args)
diff --git a/Feature__test_8cpp_source.html b/Feature__test_8cpp_source.html index 59209d724d..83c383a8c8 100644 --- a/Feature__test_8cpp_source.html +++ b/Feature__test_8cpp_source.html @@ -276,304 +276,388 @@ $(function() {
205  return cfg;
206  })};
207 
-
208  auto jrr = env.rpc("feature")[jss::result];
-
209  // The current HTTP/S ServerHandler returns an HTTP 403 error code here
-
210  // rather than a noPermission JSON error. The JSONRPCClient just eats
-
211  // that error and returns an null result.
-
212  BEAST_EXPECT(jrr.isNull());
-
213  }
-
214 
-
215  void
-
216  testSomeEnabled()
-
217  {
-
218  testcase("No Params, Some Enabled");
-
219 
-
220  using namespace test::jtx;
-
221  Env env{
-
222  *this, FeatureBitset(featureDepositAuth, featureDepositPreauth)};
-
223 
-
224  std::map<std::string, VoteBehavior> const& votes =
-
225  ripple::detail::supportedAmendments();
-
226 
-
227  auto jrr = env.rpc("feature")[jss::result];
-
228  if (!BEAST_EXPECT(jrr.isMember(jss::features)))
-
229  return;
-
230  for (auto it = jrr[jss::features].begin();
-
231  it != jrr[jss::features].end();
-
232  ++it)
-
233  {
-
234  uint256 id;
-
235  (void)id.parseHex(it.key().asString().c_str());
-
236  if (!BEAST_EXPECT((*it).isMember(jss::name)))
-
237  return;
-
238  bool expectEnabled = env.app().getAmendmentTable().isEnabled(id);
-
239  bool expectSupported =
-
240  env.app().getAmendmentTable().isSupported(id);
-
241  bool expectVeto =
-
242  (votes.at((*it)[jss::name].asString()) ==
-
243  VoteBehavior::DefaultNo);
-
244  bool expectObsolete =
-
245  (votes.at((*it)[jss::name].asString()) ==
-
246  VoteBehavior::Obsolete);
-
247  BEAST_EXPECTS(
-
248  (*it).isMember(jss::enabled) &&
-
249  (*it)[jss::enabled].asBool() == expectEnabled,
-
250  (*it)[jss::name].asString() + " enabled");
-
251  if (expectEnabled)
-
252  BEAST_EXPECTS(
-
253  !(*it).isMember(jss::vetoed),
-
254  (*it)[jss::name].asString() + " vetoed");
-
255  else
-
256  BEAST_EXPECTS(
-
257  (*it).isMember(jss::vetoed) &&
-
258  (*it)[jss::vetoed].isBool() == !expectObsolete &&
-
259  (!(*it)[jss::vetoed].isBool() ||
-
260  (*it)[jss::vetoed].asBool() == expectVeto) &&
-
261  ((*it)[jss::vetoed].isBool() ||
-
262  (*it)[jss::vetoed].asString() == "Obsolete"),
-
263  (*it)[jss::name].asString() + " vetoed");
-
264  BEAST_EXPECTS(
-
265  (*it).isMember(jss::supported) &&
-
266  (*it)[jss::supported].asBool() == expectSupported,
-
267  (*it)[jss::name].asString() + " supported");
-
268  }
-
269  }
-
270 
-
271  void
-
272  testWithMajorities()
-
273  {
-
274  testcase("With Majorities");
-
275 
-
276  using namespace test::jtx;
-
277  Env env{*this, envconfig(validator, "")};
-
278 
-
279  auto jrr = env.rpc("feature")[jss::result];
-
280  if (!BEAST_EXPECT(jrr.isMember(jss::features)))
-
281  return;
-
282 
-
283  // at this point, there are no majorities so no fields related to
-
284  // amendment voting
-
285  for (auto const& feature : jrr[jss::features])
-
286  {
-
287  if (!BEAST_EXPECT(feature.isMember(jss::name)))
-
288  return;
-
289  BEAST_EXPECTS(
-
290  !feature.isMember(jss::majority),
-
291  feature[jss::name].asString() + " majority");
-
292  BEAST_EXPECTS(
-
293  !feature.isMember(jss::count),
-
294  feature[jss::name].asString() + " count");
-
295  BEAST_EXPECTS(
-
296  !feature.isMember(jss::threshold),
-
297  feature[jss::name].asString() + " threshold");
-
298  BEAST_EXPECTS(
-
299  !feature.isMember(jss::validations),
-
300  feature[jss::name].asString() + " validations");
-
301  BEAST_EXPECTS(
-
302  !feature.isMember(jss::vote),
-
303  feature[jss::name].asString() + " vote");
-
304  }
-
305 
-
306  auto majorities = getMajorityAmendments(*env.closed());
-
307  if (!BEAST_EXPECT(majorities.empty()))
-
308  return;
+
208  {
+
209  auto result = env.rpc("feature")[jss::result];
+
210  BEAST_EXPECT(result.isMember(jss::features));
+
211  // There should be at least 50 amendments. Don't do exact
+
212  // comparison to avoid maintenance as more amendments are added in
+
213  // the future.
+
214  BEAST_EXPECT(result[jss::features].size() >= 50);
+
215  for (auto it = result[jss::features].begin();
+
216  it != result[jss::features].end();
+
217  ++it)
+
218  {
+
219  uint256 id;
+
220  (void)id.parseHex(it.key().asString().c_str());
+
221  if (!BEAST_EXPECT((*it).isMember(jss::name)))
+
222  return;
+
223  bool expectEnabled =
+
224  env.app().getAmendmentTable().isEnabled(id);
+
225  bool expectSupported =
+
226  env.app().getAmendmentTable().isSupported(id);
+
227  BEAST_EXPECTS(
+
228  (*it).isMember(jss::enabled) &&
+
229  (*it)[jss::enabled].asBool() == expectEnabled,
+
230  (*it)[jss::name].asString() + " enabled");
+
231  BEAST_EXPECTS(
+
232  (*it).isMember(jss::supported) &&
+
233  (*it)[jss::supported].asBool() == expectSupported,
+
234  (*it)[jss::name].asString() + " supported");
+
235  BEAST_EXPECT(!(*it).isMember(jss::vetoed));
+
236  BEAST_EXPECT(!(*it).isMember(jss::majority));
+
237  BEAST_EXPECT(!(*it).isMember(jss::count));
+
238  BEAST_EXPECT(!(*it).isMember(jss::validations));
+
239  BEAST_EXPECT(!(*it).isMember(jss::threshold));
+
240  }
+
241  }
+
242 
+
243  {
+
244  Json::Value params;
+
245  // invalid feature
+
246  params[jss::feature] =
+
247  "1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCD"
+
248  "EF";
+
249  auto const result = env.rpc(
+
250  "json",
+
251  "feature",
+
252  boost::lexical_cast<std::string>(params))[jss::result];
+
253  BEAST_EXPECTS(
+
254  result[jss::error] == "badFeature", result.toStyledString());
+
255  BEAST_EXPECT(
+
256  result[jss::error_message] == "Feature unknown or invalid.");
+
257  }
+
258 
+
259  {
+
260  Json::Value params;
+
261  params[jss::feature] =
+
262  "93E516234E35E08CA689FA33A6D38E103881F8DCB53023F728C307AA89D515"
+
263  "A7";
+
264  // invalid param
+
265  params[jss::vetoed] = true;
+
266  auto const result = env.rpc(
+
267  "json",
+
268  "feature",
+
269  boost::lexical_cast<std::string>(params))[jss::result];
+
270  BEAST_EXPECTS(
+
271  result[jss::error] == "noPermission",
+
272  result[jss::error].asString());
+
273  BEAST_EXPECT(
+
274  result[jss::error_message] ==
+
275  "You don't have permission for this command.");
+
276  }
+
277 
+
278  {
+
279  std::string const feature =
+
280  "C4483A1896170C66C098DEA5B0E024309C60DC960DE5F01CD7AF986AA3D9AD"
+
281  "37";
+
282  Json::Value params;
+
283  params[jss::feature] = feature;
+
284  auto const result = env.rpc(
+
285  "json",
+
286  "feature",
+
287  boost::lexical_cast<std::string>(params))[jss::result];
+
288  BEAST_EXPECT(result.isMember(feature));
+
289  auto const amendmentResult = result[feature];
+
290  BEAST_EXPECT(amendmentResult[jss::enabled].asBool() == false);
+
291  BEAST_EXPECT(amendmentResult[jss::supported].asBool() == true);
+
292  BEAST_EXPECT(
+
293  amendmentResult[jss::name].asString() ==
+
294  "fixMasterKeyAsRegularKey");
+
295  }
+
296  }
+
297 
+
298  void
+
299  testSomeEnabled()
+
300  {
+
301  testcase("No Params, Some Enabled");
+
302 
+
303  using namespace test::jtx;
+
304  Env env{
+
305  *this, FeatureBitset(featureDepositAuth, featureDepositPreauth)};
+
306 
+
307  std::map<std::string, VoteBehavior> const& votes =
+
308  ripple::detail::supportedAmendments();
309 
-
310  // close ledgers until the amendments show up.
-
311  for (auto i = 0; i <= 256; ++i)
-
312  {
-
313  env.close();
-
314  majorities = getMajorityAmendments(*env.closed());
-
315  if (!majorities.empty())
-
316  break;
-
317  }
-
318 
-
319  // There should be at least 5 amendments. Don't do exact comparison
-
320  // to avoid maintenance as more amendments are added in the future.
-
321  BEAST_EXPECT(majorities.size() >= 5);
-
322  std::map<std::string, VoteBehavior> const& votes =
-
323  ripple::detail::supportedAmendments();
-
324 
-
325  jrr = env.rpc("feature")[jss::result];
-
326  if (!BEAST_EXPECT(jrr.isMember(jss::features)))
-
327  return;
-
328  for (auto const& feature : jrr[jss::features])
-
329  {
-
330  if (!BEAST_EXPECT(feature.isMember(jss::name)))
-
331  return;
-
332  bool expectVeto =
-
333  (votes.at(feature[jss::name].asString()) ==
-
334  VoteBehavior::DefaultNo);
-
335  bool expectObsolete =
-
336  (votes.at(feature[jss::name].asString()) ==
-
337  VoteBehavior::Obsolete);
-
338  BEAST_EXPECTS(
-
339  (expectVeto || expectObsolete) ^
-
340  feature.isMember(jss::majority),
-
341  feature[jss::name].asString() + " majority");
-
342  BEAST_EXPECTS(
-
343  feature.isMember(jss::vetoed) &&
-
344  feature[jss::vetoed].isBool() == !expectObsolete &&
-
345  (!feature[jss::vetoed].isBool() ||
-
346  feature[jss::vetoed].asBool() == expectVeto) &&
-
347  (feature[jss::vetoed].isBool() ||
-
348  feature[jss::vetoed].asString() == "Obsolete"),
-
349  feature[jss::name].asString() + " vetoed");
-
350  BEAST_EXPECTS(
-
351  feature.isMember(jss::count),
-
352  feature[jss::name].asString() + " count");
-
353  BEAST_EXPECTS(
-
354  feature.isMember(jss::threshold),
-
355  feature[jss::name].asString() + " threshold");
-
356  BEAST_EXPECTS(
-
357  feature.isMember(jss::validations),
-
358  feature[jss::name].asString() + " validations");
-
359  BEAST_EXPECT(
-
360  feature[jss::count] ==
-
361  ((expectVeto || expectObsolete) ? 0 : 1));
-
362  BEAST_EXPECT(feature[jss::threshold] == 1);
-
363  BEAST_EXPECT(feature[jss::validations] == 1);
-
364  BEAST_EXPECTS(
-
365  expectVeto || expectObsolete || feature[jss::majority] == 2540,
-
366  "Majority: " + feature[jss::majority].asString());
-
367  }
-
368  }
-
369 
-
370  void
-
371  testVeto()
-
372  {
-
373  testcase("Veto");
-
374 
-
375  using namespace test::jtx;
-
376  Env env{*this, FeatureBitset(featureMultiSignReserve)};
-
377  constexpr const char* featureName = "MultiSignReserve";
-
378 
-
379  auto jrr = env.rpc("feature", featureName)[jss::result];
-
380  if (!BEAST_EXPECTS(jrr[jss::status] == jss::success, "status"))
-
381  return;
-
382  jrr.removeMember(jss::status);
-
383  if (!BEAST_EXPECT(jrr.size() == 1))
-
384  return;
-
385  auto feature = *(jrr.begin());
-
386  BEAST_EXPECTS(feature[jss::name] == featureName, "name");
-
387  BEAST_EXPECTS(
-
388  feature[jss::vetoed].isBool() && !feature[jss::vetoed].asBool(),
-
389  "vetoed");
-
390 
-
391  jrr = env.rpc("feature", featureName, "reject")[jss::result];
-
392  if (!BEAST_EXPECTS(jrr[jss::status] == jss::success, "status"))
-
393  return;
-
394  jrr.removeMember(jss::status);
-
395  if (!BEAST_EXPECT(jrr.size() == 1))
-
396  return;
-
397  feature = *(jrr.begin());
-
398  BEAST_EXPECTS(feature[jss::name] == featureName, "name");
-
399  BEAST_EXPECTS(
-
400  feature[jss::vetoed].isBool() && feature[jss::vetoed].asBool(),
-
401  "vetoed");
-
402 
-
403  jrr = env.rpc("feature", featureName, "accept")[jss::result];
-
404  if (!BEAST_EXPECTS(jrr[jss::status] == jss::success, "status"))
-
405  return;
-
406  jrr.removeMember(jss::status);
-
407  if (!BEAST_EXPECT(jrr.size() == 1))
-
408  return;
-
409  feature = *(jrr.begin());
-
410  BEAST_EXPECTS(feature[jss::name] == featureName, "name");
-
411  BEAST_EXPECTS(
-
412  feature[jss::vetoed].isBool() && !feature[jss::vetoed].asBool(),
-
413  "vetoed");
-
414 
-
415  // anything other than accept or reject is an error
-
416  jrr = env.rpc("feature", featureName, "maybe");
-
417  BEAST_EXPECT(jrr[jss::error] == "invalidParams");
-
418  BEAST_EXPECT(jrr[jss::error_message] == "Invalid parameters.");
-
419  }
-
420 
-
421  void
-
422  testObsolete()
-
423  {
-
424  testcase("Obsolete");
-
425 
-
426  using namespace test::jtx;
-
427  Env env{*this};
-
428  constexpr const char* featureName = "NonFungibleTokensV1";
-
429 
-
430  auto jrr = env.rpc("feature", featureName)[jss::result];
-
431  if (!BEAST_EXPECTS(jrr[jss::status] == jss::success, "status"))
-
432  return;
-
433  jrr.removeMember(jss::status);
-
434  if (!BEAST_EXPECT(jrr.size() == 1))
-
435  return;
-
436  auto feature = *(jrr.begin());
-
437  BEAST_EXPECTS(feature[jss::name] == featureName, "name");
-
438  BEAST_EXPECTS(
-
439  feature[jss::vetoed].isString() &&
-
440  feature[jss::vetoed].asString() == "Obsolete",
-
441  "vetoed");
-
442 
-
443  jrr = env.rpc("feature", featureName, "reject")[jss::result];
-
444  if (!BEAST_EXPECTS(jrr[jss::status] == jss::success, "status"))
-
445  return;
-
446  jrr.removeMember(jss::status);
-
447  if (!BEAST_EXPECT(jrr.size() == 1))
-
448  return;
-
449  feature = *(jrr.begin());
-
450  BEAST_EXPECTS(feature[jss::name] == featureName, "name");
-
451  BEAST_EXPECTS(
-
452  feature[jss::vetoed].isString() &&
-
453  feature[jss::vetoed].asString() == "Obsolete",
-
454  "vetoed");
-
455 
-
456  jrr = env.rpc("feature", featureName, "accept")[jss::result];
-
457  if (!BEAST_EXPECTS(jrr[jss::status] == jss::success, "status"))
-
458  return;
-
459  jrr.removeMember(jss::status);
-
460  if (!BEAST_EXPECT(jrr.size() == 1))
-
461  return;
-
462  feature = *(jrr.begin());
-
463  BEAST_EXPECTS(feature[jss::name] == featureName, "name");
-
464  BEAST_EXPECTS(
-
465  feature[jss::vetoed].isString() &&
-
466  feature[jss::vetoed].asString() == "Obsolete",
-
467  "vetoed");
-
468 
-
469  // anything other than accept or reject is an error
-
470  jrr = env.rpc("feature", featureName, "maybe");
-
471  BEAST_EXPECT(jrr[jss::error] == "invalidParams");
-
472  BEAST_EXPECT(jrr[jss::error_message] == "Invalid parameters.");
-
473  }
-
474 
-
475 public:
-
476  void
-
477  run() override
-
478  {
-
479  testInternals();
-
480  testFeatureLookups();
-
481  testNoParams();
-
482  testSingleFeature();
-
483  testInvalidFeature();
-
484  testNonAdmin();
-
485  testSomeEnabled();
-
486  testWithMajorities();
-
487  testVeto();
-
488  testObsolete();
-
489  }
-
490 };
-
491 
-
492 BEAST_DEFINE_TESTSUITE(Feature, rpc, ripple);
-
493 
-
494 } // namespace ripple
+
310  auto jrr = env.rpc("feature")[jss::result];
+
311  if (!BEAST_EXPECT(jrr.isMember(jss::features)))
+
312  return;
+
313  for (auto it = jrr[jss::features].begin();
+
314  it != jrr[jss::features].end();
+
315  ++it)
+
316  {
+
317  uint256 id;
+
318  (void)id.parseHex(it.key().asString().c_str());
+
319  if (!BEAST_EXPECT((*it).isMember(jss::name)))
+
320  return;
+
321  bool expectEnabled = env.app().getAmendmentTable().isEnabled(id);
+
322  bool expectSupported =
+
323  env.app().getAmendmentTable().isSupported(id);
+
324  bool expectVeto =
+
325  (votes.at((*it)[jss::name].asString()) ==
+
326  VoteBehavior::DefaultNo);
+
327  bool expectObsolete =
+
328  (votes.at((*it)[jss::name].asString()) ==
+
329  VoteBehavior::Obsolete);
+
330  BEAST_EXPECTS(
+
331  (*it).isMember(jss::enabled) &&
+
332  (*it)[jss::enabled].asBool() == expectEnabled,
+
333  (*it)[jss::name].asString() + " enabled");
+
334  if (expectEnabled)
+
335  BEAST_EXPECTS(
+
336  !(*it).isMember(jss::vetoed),
+
337  (*it)[jss::name].asString() + " vetoed");
+
338  else
+
339  BEAST_EXPECTS(
+
340  (*it).isMember(jss::vetoed) &&
+
341  (*it)[jss::vetoed].isBool() == !expectObsolete &&
+
342  (!(*it)[jss::vetoed].isBool() ||
+
343  (*it)[jss::vetoed].asBool() == expectVeto) &&
+
344  ((*it)[jss::vetoed].isBool() ||
+
345  (*it)[jss::vetoed].asString() == "Obsolete"),
+
346  (*it)[jss::name].asString() + " vetoed");
+
347  BEAST_EXPECTS(
+
348  (*it).isMember(jss::supported) &&
+
349  (*it)[jss::supported].asBool() == expectSupported,
+
350  (*it)[jss::name].asString() + " supported");
+
351  }
+
352  }
+
353 
+
354  void
+
355  testWithMajorities()
+
356  {
+
357  testcase("With Majorities");
+
358 
+
359  using namespace test::jtx;
+
360  Env env{*this, envconfig(validator, "")};
+
361 
+
362  auto jrr = env.rpc("feature")[jss::result];
+
363  if (!BEAST_EXPECT(jrr.isMember(jss::features)))
+
364  return;
+
365 
+
366  // at this point, there are no majorities so no fields related to
+
367  // amendment voting
+
368  for (auto const& feature : jrr[jss::features])
+
369  {
+
370  if (!BEAST_EXPECT(feature.isMember(jss::name)))
+
371  return;
+
372  BEAST_EXPECTS(
+
373  !feature.isMember(jss::majority),
+
374  feature[jss::name].asString() + " majority");
+
375  BEAST_EXPECTS(
+
376  !feature.isMember(jss::count),
+
377  feature[jss::name].asString() + " count");
+
378  BEAST_EXPECTS(
+
379  !feature.isMember(jss::threshold),
+
380  feature[jss::name].asString() + " threshold");
+
381  BEAST_EXPECTS(
+
382  !feature.isMember(jss::validations),
+
383  feature[jss::name].asString() + " validations");
+
384  BEAST_EXPECTS(
+
385  !feature.isMember(jss::vote),
+
386  feature[jss::name].asString() + " vote");
+
387  }
+
388 
+
389  auto majorities = getMajorityAmendments(*env.closed());
+
390  if (!BEAST_EXPECT(majorities.empty()))
+
391  return;
+
392 
+
393  // close ledgers until the amendments show up.
+
394  for (auto i = 0; i <= 256; ++i)
+
395  {
+
396  env.close();
+
397  majorities = getMajorityAmendments(*env.closed());
+
398  if (!majorities.empty())
+
399  break;
+
400  }
+
401 
+
402  // There should be at least 5 amendments. Don't do exact comparison
+
403  // to avoid maintenance as more amendments are added in the future.
+
404  BEAST_EXPECT(majorities.size() >= 5);
+
405  std::map<std::string, VoteBehavior> const& votes =
+
406  ripple::detail::supportedAmendments();
+
407 
+
408  jrr = env.rpc("feature")[jss::result];
+
409  if (!BEAST_EXPECT(jrr.isMember(jss::features)))
+
410  return;
+
411  for (auto const& feature : jrr[jss::features])
+
412  {
+
413  if (!BEAST_EXPECT(feature.isMember(jss::name)))
+
414  return;
+
415  bool expectVeto =
+
416  (votes.at(feature[jss::name].asString()) ==
+
417  VoteBehavior::DefaultNo);
+
418  bool expectObsolete =
+
419  (votes.at(feature[jss::name].asString()) ==
+
420  VoteBehavior::Obsolete);
+
421  BEAST_EXPECTS(
+
422  (expectVeto || expectObsolete) ^
+
423  feature.isMember(jss::majority),
+
424  feature[jss::name].asString() + " majority");
+
425  BEAST_EXPECTS(
+
426  feature.isMember(jss::vetoed) &&
+
427  feature[jss::vetoed].isBool() == !expectObsolete &&
+
428  (!feature[jss::vetoed].isBool() ||
+
429  feature[jss::vetoed].asBool() == expectVeto) &&
+
430  (feature[jss::vetoed].isBool() ||
+
431  feature[jss::vetoed].asString() == "Obsolete"),
+
432  feature[jss::name].asString() + " vetoed");
+
433  BEAST_EXPECTS(
+
434  feature.isMember(jss::count),
+
435  feature[jss::name].asString() + " count");
+
436  BEAST_EXPECTS(
+
437  feature.isMember(jss::threshold),
+
438  feature[jss::name].asString() + " threshold");
+
439  BEAST_EXPECTS(
+
440  feature.isMember(jss::validations),
+
441  feature[jss::name].asString() + " validations");
+
442  BEAST_EXPECT(
+
443  feature[jss::count] ==
+
444  ((expectVeto || expectObsolete) ? 0 : 1));
+
445  BEAST_EXPECT(feature[jss::threshold] == 1);
+
446  BEAST_EXPECT(feature[jss::validations] == 1);
+
447  BEAST_EXPECTS(
+
448  expectVeto || expectObsolete || feature[jss::majority] == 2540,
+
449  "Majority: " + feature[jss::majority].asString());
+
450  }
+
451  }
+
452 
+
453  void
+
454  testVeto()
+
455  {
+
456  testcase("Veto");
+
457 
+
458  using namespace test::jtx;
+
459  Env env{*this, FeatureBitset(featureMultiSignReserve)};
+
460  constexpr const char* featureName = "MultiSignReserve";
+
461 
+
462  auto jrr = env.rpc("feature", featureName)[jss::result];
+
463  if (!BEAST_EXPECTS(jrr[jss::status] == jss::success, "status"))
+
464  return;
+
465  jrr.removeMember(jss::status);
+
466  if (!BEAST_EXPECT(jrr.size() == 1))
+
467  return;
+
468  auto feature = *(jrr.begin());
+
469  BEAST_EXPECTS(feature[jss::name] == featureName, "name");
+
470  BEAST_EXPECTS(
+
471  feature[jss::vetoed].isBool() && !feature[jss::vetoed].asBool(),
+
472  "vetoed");
+
473 
+
474  jrr = env.rpc("feature", featureName, "reject")[jss::result];
+
475  if (!BEAST_EXPECTS(jrr[jss::status] == jss::success, "status"))
+
476  return;
+
477  jrr.removeMember(jss::status);
+
478  if (!BEAST_EXPECT(jrr.size() == 1))
+
479  return;
+
480  feature = *(jrr.begin());
+
481  BEAST_EXPECTS(feature[jss::name] == featureName, "name");
+
482  BEAST_EXPECTS(
+
483  feature[jss::vetoed].isBool() && feature[jss::vetoed].asBool(),
+
484  "vetoed");
+
485 
+
486  jrr = env.rpc("feature", featureName, "accept")[jss::result];
+
487  if (!BEAST_EXPECTS(jrr[jss::status] == jss::success, "status"))
+
488  return;
+
489  jrr.removeMember(jss::status);
+
490  if (!BEAST_EXPECT(jrr.size() == 1))
+
491  return;
+
492  feature = *(jrr.begin());
+
493  BEAST_EXPECTS(feature[jss::name] == featureName, "name");
+
494  BEAST_EXPECTS(
+
495  feature[jss::vetoed].isBool() && !feature[jss::vetoed].asBool(),
+
496  "vetoed");
+
497 
+
498  // anything other than accept or reject is an error
+
499  jrr = env.rpc("feature", featureName, "maybe");
+
500  BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+
501  BEAST_EXPECT(jrr[jss::error_message] == "Invalid parameters.");
+
502  }
+
503 
+
504  void
+
505  testObsolete()
+
506  {
+
507  testcase("Obsolete");
+
508 
+
509  using namespace test::jtx;
+
510  Env env{*this};
+
511  constexpr const char* featureName = "NonFungibleTokensV1";
+
512 
+
513  auto jrr = env.rpc("feature", featureName)[jss::result];
+
514  if (!BEAST_EXPECTS(jrr[jss::status] == jss::success, "status"))
+
515  return;
+
516  jrr.removeMember(jss::status);
+
517  if (!BEAST_EXPECT(jrr.size() == 1))
+
518  return;
+
519  auto feature = *(jrr.begin());
+
520  BEAST_EXPECTS(feature[jss::name] == featureName, "name");
+
521  BEAST_EXPECTS(
+
522  feature[jss::vetoed].isString() &&
+
523  feature[jss::vetoed].asString() == "Obsolete",
+
524  "vetoed");
+
525 
+
526  jrr = env.rpc("feature", featureName, "reject")[jss::result];
+
527  if (!BEAST_EXPECTS(jrr[jss::status] == jss::success, "status"))
+
528  return;
+
529  jrr.removeMember(jss::status);
+
530  if (!BEAST_EXPECT(jrr.size() == 1))
+
531  return;
+
532  feature = *(jrr.begin());
+
533  BEAST_EXPECTS(feature[jss::name] == featureName, "name");
+
534  BEAST_EXPECTS(
+
535  feature[jss::vetoed].isString() &&
+
536  feature[jss::vetoed].asString() == "Obsolete",
+
537  "vetoed");
+
538 
+
539  jrr = env.rpc("feature", featureName, "accept")[jss::result];
+
540  if (!BEAST_EXPECTS(jrr[jss::status] == jss::success, "status"))
+
541  return;
+
542  jrr.removeMember(jss::status);
+
543  if (!BEAST_EXPECT(jrr.size() == 1))
+
544  return;
+
545  feature = *(jrr.begin());
+
546  BEAST_EXPECTS(feature[jss::name] == featureName, "name");
+
547  BEAST_EXPECTS(
+
548  feature[jss::vetoed].isString() &&
+
549  feature[jss::vetoed].asString() == "Obsolete",
+
550  "vetoed");
+
551 
+
552  // anything other than accept or reject is an error
+
553  jrr = env.rpc("feature", featureName, "maybe");
+
554  BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+
555  BEAST_EXPECT(jrr[jss::error_message] == "Invalid parameters.");
+
556  }
+
557 
+
558 public:
+
559  void
+
560  run() override
+
561  {
+
562  testInternals();
+
563  testFeatureLookups();
+
564  testNoParams();
+
565  testSingleFeature();
+
566  testInvalidFeature();
+
567  testNonAdmin();
+
568  testSomeEnabled();
+
569  testWithMajorities();
+
570  testVeto();
+
571  testObsolete();
+
572  }
+
573 };
+
574 
+
575 BEAST_DEFINE_TESTSUITE(Feature, rpc, ripple);
+
576 
+
577 } // namespace ripple
ripple::getMajorityAmendments
majorityAmendments_t getMajorityAmendments(ReadView const &view)
Definition: View.cpp:638
ripple::Feature_test::testSingleFeature
void testSingleFeature()
Definition: Feature_test.cpp:154
+
std::string
STL class.
ripple::BEAST_DEFINE_TESTSUITE
BEAST_DEFINE_TESTSUITE(AccountTxPaging, app, ripple)
-
ripple::Feature_test::testVeto
void testVeto()
Definition: Feature_test.cpp:371
+
ripple::Feature_test::testVeto
void testVeto()
Definition: Feature_test.cpp:454
ripple::featureDepositPreauth
const uint256 featureDepositPreauth
-
ripple::Feature_test::run
void run() override
Definition: Feature_test.cpp:477
+
ripple::Feature_test::run
void run() override
Definition: Feature_test.cpp:560
ripple::Feature_test::testFeatureLookups
void testFeatureLookups()
Definition: Feature_test.cpp:65
ripple::featureDepositAuth
const uint256 featureDepositAuth
ripple::featureMultiSignReserve
const uint256 featureMultiSignReserve
@@ -582,7 +666,7 @@ $(function() {
ripple::base_uint< 256 >
ripple::detail::numDownVotedAmendments
std::size_t numDownVotedAmendments()
Amendments that this server won't vote for by default.
Definition: Feature.cpp:327
-
ripple::Feature_test::testSomeEnabled
void testSomeEnabled()
Definition: Feature_test.cpp:216
+
ripple::Feature_test::testSomeEnabled
void testSomeEnabled()
Definition: Feature_test.cpp:299
ripple::Feature_test
Definition: Feature_test.cpp:27
std::map::at
T at(T... args)
ripple::fixTakerDryOfferRemoval
const uint256 fixTakerDryOfferRemoval
@@ -590,7 +674,7 @@ $(function() {
std::map
STL class.
ripple::Feature_test::testInternals
void testInternals()
Definition: Feature_test.cpp:30
ripple::fix1578
const uint256 fix1578
-
ripple::Feature_test::testWithMajorities
void testWithMajorities()
Definition: Feature_test.cpp:272
+
ripple::Feature_test::testWithMajorities
void testWithMajorities()
Definition: Feature_test.cpp:355
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
ripple::featureFlow
const uint256 featureFlow
ripple::featureNegativeUNL
const uint256 featureNegativeUNL
@@ -605,7 +689,8 @@ $(function() {
ripple::Feature_test::testInvalidFeature
void testInvalidFeature()
Definition: Feature_test.cpp:184
std::unique_ptr
STL class.
ripple::detail::supportedAmendments
std::map< std::string, VoteBehavior > const & supportedAmendments()
Amendments that this server supports and the default voting behavior.
Definition: Feature.cpp:320
-
ripple::Feature_test::testObsolete
void testObsolete()
Definition: Feature_test.cpp:422
+
ripple::Feature_test::testObsolete
void testObsolete()
Definition: Feature_test.cpp:505
+
Json::Value
Represents a JSON value.
Definition: json_value.h:145
ripple::featureToName
std::string featureToName(uint256 const &f)
Definition: Feature.cpp:381
diff --git a/Handler_8cpp_source.html b/Handler_8cpp_source.html index 5320d85b0e..de3bc96c36 100644 --- a/Handler_8cpp_source.html +++ b/Handler_8cpp_source.html @@ -175,19 +175,19 @@ $(function() {
105  Role::USER,
106  NO_CONDITION},
107  {"download_shard", byRef(&doDownloadShard), Role::ADMIN, NO_CONDITION},
-
108 #ifdef RIPPLED_REPORTING
-
109  {"gateway_balances", byRef(&doGatewayBalances), Role::ADMIN, NO_CONDITION},
-
110 #else
-
111  {"gateway_balances", byRef(&doGatewayBalances), Role::USER, NO_CONDITION},
-
112 #endif
-
113  {"get_counts", byRef(&doGetCounts), Role::ADMIN, NO_CONDITION},
-
114  {"get_aggregate_price",
-
115  byRef(&doGetAggregatePrice),
-
116  Role::USER,
-
117  NO_CONDITION},
-
118  {"feature", byRef(&doFeature), Role::ADMIN, NO_CONDITION},
-
119  {"fee", byRef(&doFee), Role::USER, NEEDS_CURRENT_LEDGER},
-
120  {"fetch_info", byRef(&doFetchInfo), Role::ADMIN, NO_CONDITION},
+
108  {"feature", byRef(&doFeature), Role::USER, NO_CONDITION},
+
109  {"fee", byRef(&doFee), Role::USER, NEEDS_CURRENT_LEDGER},
+
110  {"fetch_info", byRef(&doFetchInfo), Role::ADMIN, NO_CONDITION},
+
111 #ifdef RIPPLED_REPORTING
+
112  {"gateway_balances", byRef(&doGatewayBalances), Role::ADMIN, NO_CONDITION},
+
113 #else
+
114  {"gateway_balances", byRef(&doGatewayBalances), Role::USER, NO_CONDITION},
+
115 #endif
+
116  {"get_counts", byRef(&doGetCounts), Role::ADMIN, NO_CONDITION},
+
117  {"get_aggregate_price",
+
118  byRef(&doGetAggregatePrice),
+
119  Role::USER,
+
120  NO_CONDITION},
121  {"ledger_accept",
122  byRef(&doLedgerAccept),
123  Role::ADMIN,
@@ -393,7 +393,7 @@ $(function() {
323 } // namespace ripple
ripple::doAccountNFTs
Json::Value doAccountNFTs(RPC::JsonContext &context)
General RPC command that can retrieve objects in the account root.
Definition: AccountObjects.cpp:51
-
ripple::doFeature
Json::Value doFeature(RPC::JsonContext &context)
Definition: Feature1.cpp:35
+
ripple::doFeature
Json::Value doFeature(RPC::JsonContext &context)
Definition: Feature1.cpp:36
ripple::doLedgerAccept
Json::Value doLedgerAccept(RPC::JsonContext &)
Definition: LedgerAccept.cpp:35
ripple::doUnlList
Json::Value doUnlList(RPC::JsonContext &)
Definition: UnlList.cpp:30
ripple::doGetCounts
Json::Value doGetCounts(RPC::JsonContext &context)
Definition: GetCounts.cpp:161
diff --git a/Handlers_8h_source.html b/Handlers_8h_source.html index 4d77a9adab..5a640c5be3 100644 --- a/Handlers_8h_source.html +++ b/Handlers_8h_source.html @@ -247,7 +247,7 @@ $(function() {
ripple::doResume
Json::Value doResume(RPC::JsonContext &)
ripple::doAccountNFTs
Json::Value doAccountNFTs(RPC::JsonContext &context)
General RPC command that can retrieve objects in the account root.
Definition: AccountObjects.cpp:51
-
ripple::doFeature
Json::Value doFeature(RPC::JsonContext &context)
Definition: Feature1.cpp:35
+
ripple::doFeature
Json::Value doFeature(RPC::JsonContext &context)
Definition: Feature1.cpp:36
ripple::doLedgerAccept
Json::Value doLedgerAccept(RPC::JsonContext &)
Definition: LedgerAccept.cpp:35
ripple::doUnlList
Json::Value doUnlList(RPC::JsonContext &)
Definition: UnlList.cpp:30
ripple::doGetCounts
Json::Value doGetCounts(RPC::JsonContext &context)
Definition: GetCounts.cpp:161
diff --git a/classripple_1_1AmendmentTable-members.html b/classripple_1_1AmendmentTable-members.html index 5daa02f62f..df262c18e7 100644 --- a/classripple_1_1AmendmentTable-members.html +++ b/classripple_1_1AmendmentTable-members.html @@ -81,8 +81,8 @@ $(function() { find(std::string const &name) const =0ripple::AmendmentTablepure virtual firstUnsupportedExpected() const =0ripple::AmendmentTablepure virtual getDesired() const =0ripple::AmendmentTablepure virtual - getJson() const =0ripple::AmendmentTablepure virtual - getJson(uint256 const &amendment) const =0ripple::AmendmentTablepure virtual + getJson(bool isAdmin) const =0ripple::AmendmentTablepure virtual + getJson(uint256 const &amendment, bool isAdmin) const =0ripple::AmendmentTablepure virtual hasUnsupportedEnabled() const =0ripple::AmendmentTablepure virtual isEnabled(uint256 const &amendment) const =0ripple::AmendmentTablepure virtual isSupported(uint256 const &amendment) const =0ripple::AmendmentTablepure virtual diff --git a/classripple_1_1AmendmentTable.html b/classripple_1_1AmendmentTable.html index e60425022c..94324f3c7e 100644 --- a/classripple_1_1AmendmentTable.html +++ b/classripple_1_1AmendmentTable.html @@ -112,11 +112,11 @@ Public Member Functions   virtual std::optional< NetClock::time_point > firstUnsupportedExpected () const =0   -virtual Json::Value getJson () const =0 -  -virtual Json::Value getJson (uint256 const &amendment) const =0 - Returns a Json::objectValue. More...
-  +virtual Json::Value getJson (bool isAdmin) const =0 +  +virtual Json::Value getJson (uint256 const &amendment, bool isAdmin) const =0 + Returns a Json::objectValue. More...
+  void doValidatedLedger (std::shared_ptr< ReadView const > const &lastValidatedLedger)  Called when a new fully-validated ledger is accepted. More...
  @@ -393,8 +393,8 @@ Public Member Functions - -

◆ getJson() [1/2]

+ +

◆ getJson() [1/2]

@@ -405,7 +405,8 @@ Public Member Functions virtual Json::Value ripple::AmendmentTable::getJson ( - ) + bool  + isAdmin) const @@ -416,12 +417,12 @@ Public Member Functions
-

Implemented in ripple::AmendmentTableImpl.

+

Implemented in ripple::AmendmentTableImpl.

- -

◆ getJson() [2/2]

+ +

◆ getJson() [2/2]

@@ -433,8 +434,18 @@ Public Member Functions virtual Json::Value ripple::AmendmentTable::getJson ( uint256 const &  - amendment) - const + amendment, + + + + + bool  + isAdmin  + + + + ) + const @@ -446,7 +457,7 @@ Public Member Functions

Returns a Json::objectValue.

-

Implemented in ripple::AmendmentTableImpl.

+

Implemented in ripple::AmendmentTableImpl.

diff --git a/classripple_1_1AmendmentTableImpl-members.html b/classripple_1_1AmendmentTableImpl-members.html index f226c0eac5..7a99f64e2f 100644 --- a/classripple_1_1AmendmentTableImpl-members.html +++ b/classripple_1_1AmendmentTableImpl-members.html @@ -88,10 +88,10 @@ $(function() { get(uint256 const &amendment, std::lock_guard< std::mutex > const &lock)ripple::AmendmentTableImplprivate get(uint256 const &amendment, std::lock_guard< std::mutex > const &lock) constripple::AmendmentTableImplprivate getDesired() const overrideripple::AmendmentTableImplvirtual - getJson() const overrideripple::AmendmentTableImplvirtual - getJson(uint256 const &) const overrideripple::AmendmentTableImplvirtual + getJson(bool isAdmin) const overrideripple::AmendmentTableImplvirtual + getJson(uint256 const &, bool isAdmin) const overrideripple::AmendmentTableImplvirtual hasUnsupportedEnabled() const overrideripple::AmendmentTableImplvirtual - injectJson(Json::Value &v, uint256 const &amendment, AmendmentState const &state, std::lock_guard< std::mutex > const &lock) constripple::AmendmentTableImplprivate + injectJson(Json::Value &v, uint256 const &amendment, AmendmentState const &state, bool isAdmin, std::lock_guard< std::mutex > const &lock) constripple::AmendmentTableImplprivate isEnabled(uint256 const &amendment) const overrideripple::AmendmentTableImplvirtual isSupported(uint256 const &amendment) const overrideripple::AmendmentTableImplvirtual j_ripple::AmendmentTableImplprivate diff --git a/classripple_1_1AmendmentTableImpl.html b/classripple_1_1AmendmentTableImpl.html index 47abfb224b..339f416a97 100644 --- a/classripple_1_1AmendmentTableImpl.html +++ b/classripple_1_1AmendmentTableImpl.html @@ -152,11 +152,11 @@ Public Member Functions   std::optional< NetClock::time_point > firstUnsupportedExpected () const override   -Json::Value getJson () const override -  -Json::Value getJson (uint256 const &) const override - Returns a Json::objectValue. More...
-  +Json::Value getJson (bool isAdmin) const override +  +Json::Value getJson (uint256 const &, bool isAdmin) const override + Returns a Json::objectValue. More...
+  bool needValidatedLedger (LedgerIndex seq) const override  Called to determine whether the amendment logic needs to process a new validated ledger. More...
  @@ -184,8 +184,8 @@ Private Member Functions   AmendmentState const * get (uint256 const &amendment, std::lock_guard< std::mutex > const &lock) const   -void injectJson (Json::Value &v, uint256 const &amendment, AmendmentState const &state, std::lock_guard< std::mutex > const &lock) const -  +void injectJson (Json::Value &v, uint256 const &amendment, AmendmentState const &state, bool isAdmin, std::lock_guard< std::mutex > const &lock) const +  void persistVote (uint256 const &amendment, std::string const &name, AmendmentVote vote) const   @@ -268,7 +268,7 @@ Private Attributes
-

Definition at line 464 of file AmendmentTable.cpp.

+

Definition at line 465 of file AmendmentTable.cpp.

@@ -307,7 +307,7 @@ Private Attributes
-

Definition at line 606 of file AmendmentTable.cpp.

+

Definition at line 607 of file AmendmentTable.cpp.

@@ -345,7 +345,7 @@ Private Attributes
-

Definition at line 615 of file AmendmentTable.cpp.

+

Definition at line 616 of file AmendmentTable.cpp.

@@ -383,12 +383,12 @@ Private Attributes
-

Definition at line 625 of file AmendmentTable.cpp.

+

Definition at line 626 of file AmendmentTable.cpp.

- -

◆ injectJson()

+ +

◆ injectJson()

@@ -414,6 +414,12 @@ Private Attributes AmendmentState const &  state, + + + + bool  + isAdmin, + @@ -433,7 +439,7 @@ Private Attributes
-

Definition at line 905 of file AmendmentTable.cpp.

+

Definition at line 906 of file AmendmentTable.cpp.

@@ -477,7 +483,7 @@ Private Attributes
-

Definition at line 653 of file AmendmentTable.cpp.

+

Definition at line 654 of file AmendmentTable.cpp.

@@ -507,7 +513,7 @@ Private Attributes

Implements ripple::AmendmentTable.

-

Definition at line 639 of file AmendmentTable.cpp.

+

Definition at line 640 of file AmendmentTable.cpp.

@@ -537,7 +543,7 @@ Private Attributes

Implements ripple::AmendmentTable.

-

Definition at line 664 of file AmendmentTable.cpp.

+

Definition at line 665 of file AmendmentTable.cpp.

@@ -567,7 +573,7 @@ Private Attributes

Implements ripple::AmendmentTable.

-

Definition at line 677 of file AmendmentTable.cpp.

+

Definition at line 678 of file AmendmentTable.cpp.

@@ -597,7 +603,7 @@ Private Attributes

Implements ripple::AmendmentTable.

-

Definition at line 690 of file AmendmentTable.cpp.

+

Definition at line 691 of file AmendmentTable.cpp.

@@ -627,7 +633,7 @@ Private Attributes

Implements ripple::AmendmentTable.

-

Definition at line 711 of file AmendmentTable.cpp.

+

Definition at line 712 of file AmendmentTable.cpp.

@@ -657,7 +663,7 @@ Private Attributes

Implements ripple::AmendmentTable.

-

Definition at line 719 of file AmendmentTable.cpp.

+

Definition at line 720 of file AmendmentTable.cpp.

@@ -689,7 +695,7 @@ Private Attributes

Implements ripple::AmendmentTable.

-

Definition at line 727 of file AmendmentTable.cpp.

+

Definition at line 728 of file AmendmentTable.cpp.

@@ -718,12 +724,12 @@ Private Attributes

Implements ripple::AmendmentTable.

-

Definition at line 734 of file AmendmentTable.cpp.

+

Definition at line 735 of file AmendmentTable.cpp.

- -

◆ getJson() [1/2]

+ +

◆ getJson() [1/2]

@@ -734,7 +740,8 @@ Private Attributes Json::Value ripple::AmendmentTableImpl::getJson ( - ) + bool  + isAdmin) const @@ -745,14 +752,14 @@ Private Attributes
-

Implements ripple::AmendmentTable.

+

Implements ripple::AmendmentTable.

-

Definition at line 939 of file AmendmentTable.cpp.

+

Definition at line 941 of file AmendmentTable.cpp.

- -

◆ getJson() [2/2]

+ +

◆ getJson() [2/2]

@@ -764,8 +771,18 @@ Private Attributes Json::Value ripple::AmendmentTableImpl::getJson ( uint256 const &  - amendment) - const + amendment, + + + + + bool  + isAdmin  + + + + ) + const @@ -777,9 +794,9 @@ Private Attributes

Returns a Json::objectValue.

-

Implements ripple::AmendmentTable.

+

Implements ripple::AmendmentTable.

-

Definition at line 957 of file AmendmentTable.cpp.

+

Definition at line 960 of file AmendmentTable.cpp.

@@ -812,7 +829,7 @@ Private Attributes

Implements ripple::AmendmentTable.

-

Definition at line 850 of file AmendmentTable.cpp.

+

Definition at line 851 of file AmendmentTable.cpp.

@@ -858,7 +875,7 @@ Private Attributes

Implements ripple::AmendmentTable.

-

Definition at line 861 of file AmendmentTable.cpp.

+

Definition at line 862 of file AmendmentTable.cpp.

@@ -888,7 +905,7 @@ Private Attributes

Implements ripple::AmendmentTable.

-

Definition at line 898 of file AmendmentTable.cpp.

+

Definition at line 899 of file AmendmentTable.cpp.

@@ -918,7 +935,7 @@ Private Attributes

Implements ripple::AmendmentTable.

-

Definition at line 741 of file AmendmentTable.cpp.

+

Definition at line 742 of file AmendmentTable.cpp.

@@ -947,7 +964,7 @@ Private Attributes

Implements ripple::AmendmentTable.

-

Definition at line 768 of file AmendmentTable.cpp.

+

Definition at line 769 of file AmendmentTable.cpp.

@@ -1005,7 +1022,7 @@ Private Attributes

Implements ripple::AmendmentTable.

-

Definition at line 775 of file AmendmentTable.cpp.

+

Definition at line 776 of file AmendmentTable.cpp.

diff --git a/classripple_1_1AmendmentTable__test.html b/classripple_1_1AmendmentTable__test.html index 36db6f7189..5c88d8495b 100644 --- a/classripple_1_1AmendmentTable__test.html +++ b/classripple_1_1AmendmentTable__test.html @@ -1032,7 +1032,7 @@ template<class Arg , class... Args>
-

Definition at line 674 of file AmendmentTable_test.cpp.

+

Definition at line 690 of file AmendmentTable_test.cpp.

@@ -1052,7 +1052,7 @@ template<class Arg , class... Args>
-

Definition at line 739 of file AmendmentTable_test.cpp.

+

Definition at line 755 of file AmendmentTable_test.cpp.

@@ -1072,7 +1072,7 @@ template<class Arg , class... Args>
-

Definition at line 819 of file AmendmentTable_test.cpp.

+

Definition at line 835 of file AmendmentTable_test.cpp.

@@ -1092,7 +1092,7 @@ template<class Arg , class... Args>
-

Definition at line 888 of file AmendmentTable_test.cpp.

+

Definition at line 904 of file AmendmentTable_test.cpp.

@@ -1112,7 +1112,7 @@ template<class Arg , class... Args>
-

Definition at line 965 of file AmendmentTable_test.cpp.

+

Definition at line 981 of file AmendmentTable_test.cpp.

@@ -1132,7 +1132,7 @@ template<class Arg , class... Args>
-

Definition at line 1126 of file AmendmentTable_test.cpp.

+

Definition at line 1142 of file AmendmentTable_test.cpp.

@@ -1151,7 +1151,7 @@ template<class Arg , class... Args>
-

Definition at line 1216 of file AmendmentTable_test.cpp.

+

Definition at line 1232 of file AmendmentTable_test.cpp.

@@ -1171,7 +1171,7 @@ template<class Arg , class... Args>
-

Definition at line 1259 of file AmendmentTable_test.cpp.

+

Definition at line 1275 of file AmendmentTable_test.cpp.

@@ -1198,7 +1198,7 @@ template<class Arg , class... Args>
-

Definition at line 1271 of file AmendmentTable_test.cpp.

+

Definition at line 1287 of file AmendmentTable_test.cpp.

diff --git a/classripple_1_1Feature__test.html b/classripple_1_1Feature__test.html index c6e6c1295c..b2a7b56fe6 100644 --- a/classripple_1_1Feature__test.html +++ b/classripple_1_1Feature__test.html @@ -309,7 +309,7 @@ Private Member Functions
-

Definition at line 216 of file Feature_test.cpp.

+

Definition at line 299 of file Feature_test.cpp.

@@ -336,7 +336,7 @@ Private Member Functions
-

Definition at line 272 of file Feature_test.cpp.

+

Definition at line 355 of file Feature_test.cpp.

@@ -363,7 +363,7 @@ Private Member Functions
-

Definition at line 371 of file Feature_test.cpp.

+

Definition at line 454 of file Feature_test.cpp.

@@ -390,7 +390,7 @@ Private Member Functions
-

Definition at line 422 of file Feature_test.cpp.

+

Definition at line 505 of file Feature_test.cpp.

@@ -417,7 +417,7 @@ Private Member Functions
-

Definition at line 477 of file Feature_test.cpp.

+

Definition at line 560 of file Feature_test.cpp.

diff --git a/functions_func_g.html b/functions_func_g.html index 5de67babaa..e3dbdaadfe 100644 --- a/functions_func_g.html +++ b/functions_func_g.html @@ -747,8 +747,8 @@ $(function() {
  • getJson() : ripple::AcceptedLedgerTx -, ripple::AmendmentTable -, ripple::AmendmentTableImpl +, ripple::AmendmentTable +, ripple::AmendmentTableImpl , ripple::Consensus< Adaptor > , ripple::ConsensusProposal< NodeID_t, LedgerID_t, Position_t > , ripple::DisputedTx< Tx_t, NodeID_t > diff --git a/functions_func_i.html b/functions_func_i.html index 41c1ba21a4..dc95905cbe 100644 --- a/functions_func_i.html +++ b/functions_func_i.html @@ -340,7 +340,7 @@ $(function() { : ripple::RPC::Status
  • injectJson() -: ripple::AmendmentTableImpl +: ripple::AmendmentTableImpl
  • injectTxs() : ripple::test::csf::Peer diff --git a/functions_g.html b/functions_g.html index c450b7d5df..c7459a2db0 100644 --- a/functions_g.html +++ b/functions_g.html @@ -797,8 +797,8 @@ $(function() {
  • getJson() : ripple::AcceptedLedgerTx -, ripple::AmendmentTable -, ripple::AmendmentTableImpl +, ripple::AmendmentTable +, ripple::AmendmentTableImpl , ripple::Consensus< Adaptor > , ripple::ConsensusProposal< NodeID_t, LedgerID_t, Position_t > , ripple::DisputedTx< Tx_t, NodeID_t > diff --git a/functions_i.html b/functions_i.html index 9656116abc..b0d1dc94c1 100644 --- a/functions_i.html +++ b/functions_i.html @@ -545,7 +545,7 @@ $(function() { : ripple::RPC::Status
  • injectJson() -: ripple::AmendmentTableImpl +: ripple::AmendmentTableImpl
  • injectTxs() : ripple::test::csf::Peer diff --git a/namespaceripple.html b/namespaceripple.html index 1b80e935a3..9aa9d5157c 100644 --- a/namespaceripple.html +++ b/namespaceripple.html @@ -12137,7 +12137,7 @@ template<class ApplyTxs >
    -

    Definition at line 973 of file AmendmentTable.cpp.

    +

    Definition at line 979 of file AmendmentTable.cpp.

    @@ -49726,7 +49726,7 @@ template<class TAttestation >
    -

    Definition at line 35 of file Feature1.cpp.

    +

    Definition at line 36 of file Feature1.cpp.

    diff --git a/search/all_7.js b/search/all_7.js index c9f8a30460..fcb47d7495 100644 --- a/search/all_7.js +++ b/search/all_7.js @@ -290,7 +290,7 @@ var searchData= ['getjobtypedata_3671',['getJobTypeData',['../classripple_1_1JobQueue.html#a64c1e56256e2e60a5a0b2d0c32dc3a75',1,'ripple::JobQueue']]], ['getjournal_3672',['getJournal',['../classripple_1_1ReportingETL.html#ac8a12b5c2e7dd663977c6a3e35b82f76',1,'ripple::ReportingETL']]], ['getjqtransoverflow_3673',['getJqTransOverflow',['../classripple_1_1OverlayImpl.html#ac72bf0313b420d1d1ff66e487c94f8dd',1,'ripple::OverlayImpl::getJqTransOverflow()'],['../classripple_1_1Overlay.html#aca9d3f6ef650c9c0820b182d87114e27',1,'ripple::Overlay::getJqTransOverflow()']]], - ['getjson_3674',['getJson',['../classripple_1_1RCLConsensus.html#acdab4291925cbabf861b8019c76355ea',1,'ripple::RCLConsensus::getJson()'],['../classripple_1_1RCLCxLedger.html#aad38a2e710238aef4c8c3ba64c229aee',1,'ripple::RCLCxLedger::getJson()'],['../classripple_1_1RCLCxPeerPos.html#a65a69d25d4b834b50190f671d182010d',1,'ripple::RCLCxPeerPos::getJson()'],['../classripple_1_1AcceptedLedgerTx.html#a6e8dfbec3db1a1436636838e6db327bf',1,'ripple::AcceptedLedgerTx::getJson()'],['../classripple_1_1InboundLedger.html#a069c3ef1adae2c6d17c67e71071ca962',1,'ripple::InboundLedger::getJson()'],['../classripple_1_1AmendmentTable.html#ac63a31d38346fba5d5ca78c4894af31a',1,'ripple::AmendmentTable::getJson() const =0'],['../classripple_1_1AmendmentTable.html#a679a2a34193d9788688eb8456631bc49',1,'ripple::AmendmentTable::getJson(uint256 const &amendment) const =0'],['../classripple_1_1AmendmentTableImpl.html#a9c84b0a42b131a8c6392a993bc4b4c4c',1,'ripple::AmendmentTableImpl::getJson() const override'],['../classripple_1_1AmendmentTableImpl.html#a8780f13856e21995bfa5001959d5bff4',1,'ripple::AmendmentTableImpl::getJson(uint256 const &) const override'],['../classripple_1_1Transaction.html#ac8746fa431dbfc2527f6448033caa53e',1,'ripple::Transaction::getJson()'],['../classripple_1_1ValidatorList.html#a6f943a4488f3b50dcbb5177007d43271',1,'ripple::ValidatorList::getJson()'],['../classripple_1_1ValidatorSite.html#a312f364fbd7a199243881139578c9ac7',1,'ripple::ValidatorSite::getJson()'],['../classripple_1_1TrustLineBase.html#ac9c5e0c9b869301f4991cc35a265b6fc',1,'ripple::TrustLineBase::getJson()'],['../classripple_1_1Consensus.html#a6e81235f0c5f91c23cbe1938ffe8a9e3',1,'ripple::Consensus::getJson()'],['../classripple_1_1ConsensusProposal.html#a799315c246e228ac703759505d8997d8',1,'ripple::ConsensusProposal::getJson()'],['../classripple_1_1DisputedTx.html#a17ac6060bf6ac7641f4ea9b8cc25d9c9',1,'ripple::DisputedTx::getJson()'],['../structripple_1_1ledger__trie__detail_1_1Node.html#a2619579b5ec9c819b87307ee63fe3153',1,'ripple::ledger_trie_detail::Node::getJson()'],['../classripple_1_1LedgerTrie.html#a68e57b86e3de6d1cf969b6a883742bf2',1,'ripple::LedgerTrie::getJson()'],['../classripple_1_1JobQueue.html#a8a0f5f0f114ceb9d5f03f66252d6889b',1,'ripple::JobQueue::getJson()'],['../classripple_1_1STAmount.html#a02bef3696a9cb07b72e5ec750e7ea456',1,'ripple::STAmount::getJson()'],['../classripple_1_1STArray.html#abace0153bbea0217867bde2a591ebe28',1,'ripple::STArray::getJson()'],['../classripple_1_1STBase.html#af1dfd1c754eaf5eded23242b59a0cdb5',1,'ripple::STBase::getJson()'],['../classripple_1_1STCurrency.html#a792de3f4580f1f0c69a6178a581255f3',1,'ripple::STCurrency::getJson()'],['../classripple_1_1STInteger.html#a2d690262f59133fe59e938b2097920f3',1,'ripple::STInteger::getJson()'],['../classripple_1_1STIssue.html#a70741f92ab7f71f6c227dbaed47087c3',1,'ripple::STIssue::getJson()'],['../classripple_1_1STLedgerEntry.html#a9302de6f8a80801399254527caf91fe2',1,'ripple::STLedgerEntry::getJson()'],['../classripple_1_1STObject.html#acc2ceb95cdb8fc8b2520aeceabf17553',1,'ripple::STObject::getJson()'],['../classripple_1_1STPath.html#ab8bd502211308857863a29188a680c13',1,'ripple::STPath::getJson()'],['../classripple_1_1STPathSet.html#a98d06aae5b406ad1633092c13af49408',1,'ripple::STPathSet::getJson()'],['../classripple_1_1STTx.html#a489c8110e24455a2e7dac783f4760cc2',1,'ripple::STTx::getJson(JsonOptions options) const override'],['../classripple_1_1STTx.html#a48b76dde3140dc8304e4ff4893356fdc',1,'ripple::STTx::getJson(JsonOptions options, bool binary) const'],['../classripple_1_1STVector256.html#a478b879cc607d0d1ac931f10b8cd96e8',1,'ripple::STVector256::getJson()'],['../classripple_1_1STXChainBridge.html#a73e46acf5801b27787cecc5234732077',1,'ripple::STXChainBridge::getJson()'],['../classripple_1_1TxMeta.html#a9fbad6f4d81e6952637230ee3f49a183',1,'ripple::TxMeta::getJson()'],['../classripple_1_1Resource_1_1Logic.html#a6b47a9a2f63cc950895ba67514d72723',1,'ripple::Resource::Logic::getJson()'],['../classripple_1_1Resource_1_1Logic.html#ab1ce4bc72906e2c8ac05b770b0754465',1,'ripple::Resource::Logic::getJson(int threshold)'],['../classripple_1_1Resource_1_1ManagerImp.html#a2198b717f65286957cf5abe8aa9b22e0',1,'ripple::Resource::ManagerImp::getJson() override'],['../classripple_1_1Resource_1_1ManagerImp.html#a54dac1f88cb19ee470d971036f0d7b8b',1,'ripple::Resource::ManagerImp::getJson(int threshold) override'],['../classripple_1_1Resource_1_1Manager.html#a06751117098e01ef0e0a780df25a9b2d',1,'ripple::Resource::Manager::getJson()=0'],['../classripple_1_1Resource_1_1Manager.html#ab5fe84b72cd833f4cd659b0ceca673b0',1,'ripple::Resource::Manager::getJson(int threshold)=0'],['../classripple_1_1test_1_1csf_1_1Ledger.html#a7bc8181b16188a8f129a67154afaf74d',1,'ripple::test::csf::Ledger::getJson()'],['../classripple_1_1test_1_1csf_1_1Peer_1_1Position.html#a5c3e8a7e4acd218d4f66452fe5b85805',1,'ripple::test::csf::Peer::Position::getJson()'],['../namespaceripple.html#ad30131b5a5b7cf60d9b392ab868b8c0e',1,'ripple::getJson()']]], + ['getjson_3674',['getJson',['../classripple_1_1RCLConsensus.html#acdab4291925cbabf861b8019c76355ea',1,'ripple::RCLConsensus::getJson()'],['../classripple_1_1RCLCxLedger.html#aad38a2e710238aef4c8c3ba64c229aee',1,'ripple::RCLCxLedger::getJson()'],['../classripple_1_1RCLCxPeerPos.html#a65a69d25d4b834b50190f671d182010d',1,'ripple::RCLCxPeerPos::getJson()'],['../classripple_1_1AcceptedLedgerTx.html#a6e8dfbec3db1a1436636838e6db327bf',1,'ripple::AcceptedLedgerTx::getJson()'],['../classripple_1_1InboundLedger.html#a069c3ef1adae2c6d17c67e71071ca962',1,'ripple::InboundLedger::getJson()'],['../classripple_1_1AmendmentTable.html#a6ac6934733758e569d25e1e136fb84d5',1,'ripple::AmendmentTable::getJson(bool isAdmin) const =0'],['../classripple_1_1AmendmentTable.html#a2b779a15190c7e9ba93ca99bada7093c',1,'ripple::AmendmentTable::getJson(uint256 const &amendment, bool isAdmin) const =0'],['../classripple_1_1AmendmentTableImpl.html#a8f8c9cec31fa120c43e41fa2e7d108ad',1,'ripple::AmendmentTableImpl::getJson(bool isAdmin) const override'],['../classripple_1_1AmendmentTableImpl.html#a989a955a89400c53e8d89a280b890d6b',1,'ripple::AmendmentTableImpl::getJson(uint256 const &, bool isAdmin) const override'],['../classripple_1_1Transaction.html#ac8746fa431dbfc2527f6448033caa53e',1,'ripple::Transaction::getJson()'],['../classripple_1_1ValidatorList.html#a6f943a4488f3b50dcbb5177007d43271',1,'ripple::ValidatorList::getJson()'],['../classripple_1_1ValidatorSite.html#a312f364fbd7a199243881139578c9ac7',1,'ripple::ValidatorSite::getJson()'],['../classripple_1_1TrustLineBase.html#ac9c5e0c9b869301f4991cc35a265b6fc',1,'ripple::TrustLineBase::getJson()'],['../classripple_1_1Consensus.html#a6e81235f0c5f91c23cbe1938ffe8a9e3',1,'ripple::Consensus::getJson()'],['../classripple_1_1ConsensusProposal.html#a799315c246e228ac703759505d8997d8',1,'ripple::ConsensusProposal::getJson()'],['../classripple_1_1DisputedTx.html#a17ac6060bf6ac7641f4ea9b8cc25d9c9',1,'ripple::DisputedTx::getJson()'],['../structripple_1_1ledger__trie__detail_1_1Node.html#a2619579b5ec9c819b87307ee63fe3153',1,'ripple::ledger_trie_detail::Node::getJson()'],['../classripple_1_1LedgerTrie.html#a68e57b86e3de6d1cf969b6a883742bf2',1,'ripple::LedgerTrie::getJson()'],['../classripple_1_1JobQueue.html#a8a0f5f0f114ceb9d5f03f66252d6889b',1,'ripple::JobQueue::getJson()'],['../classripple_1_1STAmount.html#a02bef3696a9cb07b72e5ec750e7ea456',1,'ripple::STAmount::getJson()'],['../classripple_1_1STArray.html#abace0153bbea0217867bde2a591ebe28',1,'ripple::STArray::getJson()'],['../classripple_1_1STBase.html#af1dfd1c754eaf5eded23242b59a0cdb5',1,'ripple::STBase::getJson()'],['../classripple_1_1STCurrency.html#a792de3f4580f1f0c69a6178a581255f3',1,'ripple::STCurrency::getJson()'],['../classripple_1_1STInteger.html#a2d690262f59133fe59e938b2097920f3',1,'ripple::STInteger::getJson()'],['../classripple_1_1STIssue.html#a70741f92ab7f71f6c227dbaed47087c3',1,'ripple::STIssue::getJson()'],['../classripple_1_1STLedgerEntry.html#a9302de6f8a80801399254527caf91fe2',1,'ripple::STLedgerEntry::getJson()'],['../classripple_1_1STObject.html#acc2ceb95cdb8fc8b2520aeceabf17553',1,'ripple::STObject::getJson()'],['../classripple_1_1STPath.html#ab8bd502211308857863a29188a680c13',1,'ripple::STPath::getJson()'],['../classripple_1_1STPathSet.html#a98d06aae5b406ad1633092c13af49408',1,'ripple::STPathSet::getJson()'],['../classripple_1_1STTx.html#a489c8110e24455a2e7dac783f4760cc2',1,'ripple::STTx::getJson(JsonOptions options) const override'],['../classripple_1_1STTx.html#a48b76dde3140dc8304e4ff4893356fdc',1,'ripple::STTx::getJson(JsonOptions options, bool binary) const'],['../classripple_1_1STVector256.html#a478b879cc607d0d1ac931f10b8cd96e8',1,'ripple::STVector256::getJson()'],['../classripple_1_1STXChainBridge.html#a73e46acf5801b27787cecc5234732077',1,'ripple::STXChainBridge::getJson()'],['../classripple_1_1TxMeta.html#a9fbad6f4d81e6952637230ee3f49a183',1,'ripple::TxMeta::getJson()'],['../classripple_1_1Resource_1_1Logic.html#a6b47a9a2f63cc950895ba67514d72723',1,'ripple::Resource::Logic::getJson()'],['../classripple_1_1Resource_1_1Logic.html#ab1ce4bc72906e2c8ac05b770b0754465',1,'ripple::Resource::Logic::getJson(int threshold)'],['../classripple_1_1Resource_1_1ManagerImp.html#a2198b717f65286957cf5abe8aa9b22e0',1,'ripple::Resource::ManagerImp::getJson() override'],['../classripple_1_1Resource_1_1ManagerImp.html#a54dac1f88cb19ee470d971036f0d7b8b',1,'ripple::Resource::ManagerImp::getJson(int threshold) override'],['../classripple_1_1Resource_1_1Manager.html#a06751117098e01ef0e0a780df25a9b2d',1,'ripple::Resource::Manager::getJson()=0'],['../classripple_1_1Resource_1_1Manager.html#ab5fe84b72cd833f4cd659b0ceca673b0',1,'ripple::Resource::Manager::getJson(int threshold)=0'],['../classripple_1_1test_1_1csf_1_1Ledger.html#a7bc8181b16188a8f129a67154afaf74d',1,'ripple::test::csf::Ledger::getJson()'],['../classripple_1_1test_1_1csf_1_1Peer_1_1Position.html#a5c3e8a7e4acd218d4f66452fe5b85805',1,'ripple::test::csf::Peer::Position::getJson()'],['../namespaceripple.html#ad30131b5a5b7cf60d9b392ab868b8c0e',1,'ripple::getJson()']]], ['getjsonname_3675',['getJsonName',['../classripple_1_1SField.html#ab18506568f3d60892a7c108eaeb3a05d',1,'ripple::SField']]], ['getjsontrie_3676',['getJsonTrie',['../classripple_1_1Validations.html#a4436616304f6309389ddd6d11f5560d2',1,'ripple::Validations']]], ['getkbusedall_3677',['getKBUsedAll',['../classripple_1_1SQLiteDatabaseImp.html#ae53c9caa41b8e7ccb388eed3cd284f51',1,'ripple::SQLiteDatabaseImp::getKBUsedAll()'],['../classripple_1_1SQLiteDatabase.html#af00c81d707db5d1f879bb52f85b28ed1',1,'ripple::SQLiteDatabase::getKBUsedAll()'],['../namespaceripple.html#a3063535903fec75ab36b634cb531c835',1,'ripple::getKBUsedAll()']]], diff --git a/search/all_9.js b/search/all_9.js index 5bd5e660f7..3ddb9ec637 100644 --- a/search/all_9.js +++ b/search/all_9.js @@ -144,7 +144,7 @@ var searchData= ['initstatedb_4405',['initStateDB',['../namespaceripple.html#a632dcd1160907dbaea1cd6caceca886c',1,'ripple']]], ['inject_4406',['inject',['../structripple_1_1RPC_1_1Status.html#a91ffe9a0175caf0cdcc5d34338de638c',1,'ripple::RPC::Status']]], ['inject_5ferror_4407',['inject_error',['../namespaceripple_1_1RPC.html#a577bde9602a28f59e445c496f92a1ccf',1,'ripple::RPC::inject_error(error_code_i code, JsonValue &json)'],['../namespaceripple_1_1RPC.html#a073aa52d66bf3061aed8861d1db747d0',1,'ripple::RPC::inject_error(int code, JsonValue &json)'],['../namespaceripple_1_1RPC.html#a2b8314da490d3e5f165dcc839bd2271e',1,'ripple::RPC::inject_error(error_code_i code, std::string const &message, JsonValue &json)']]], - ['injectjson_4408',['injectJson',['../classripple_1_1AmendmentTableImpl.html#a4f1d0bde577c66d4c238a3f6bfd8fc6a',1,'ripple::AmendmentTableImpl']]], + ['injectjson_4408',['injectJson',['../classripple_1_1AmendmentTableImpl.html#a7d021a2ba5be052ab848f7dd5ff0de25',1,'ripple::AmendmentTableImpl']]], ['injectreportingwarning_4409',['injectReportingWarning',['../namespaceripple_1_1RPC.html#a7d14d5ae6f47355a9d9d51ae58e7101a',1,'ripple::RPC']]], ['injectsle_4410',['injectSLE',['../namespaceripple_1_1RPC.html#a4ea6d08c0d50d738a6a55130a09ec238',1,'ripple::RPC']]], ['injecttxs_4411',['injectTxs',['../structripple_1_1test_1_1csf_1_1Peer.html#aeb7f2db3bebf459c49cff2afb849648a',1,'ripple::test::csf::Peer']]], diff --git a/search/functions_7.js b/search/functions_7.js index eb447e58de..3534939e4f 100644 --- a/search/functions_7.js +++ b/search/functions_7.js @@ -266,7 +266,7 @@ var searchData= ['getjobtypedata_18777',['getJobTypeData',['../classripple_1_1JobQueue.html#a64c1e56256e2e60a5a0b2d0c32dc3a75',1,'ripple::JobQueue']]], ['getjournal_18778',['getJournal',['../classripple_1_1ReportingETL.html#ac8a12b5c2e7dd663977c6a3e35b82f76',1,'ripple::ReportingETL']]], ['getjqtransoverflow_18779',['getJqTransOverflow',['../classripple_1_1OverlayImpl.html#ac72bf0313b420d1d1ff66e487c94f8dd',1,'ripple::OverlayImpl::getJqTransOverflow()'],['../classripple_1_1Overlay.html#aca9d3f6ef650c9c0820b182d87114e27',1,'ripple::Overlay::getJqTransOverflow()']]], - ['getjson_18780',['getJson',['../classripple_1_1RCLConsensus.html#acdab4291925cbabf861b8019c76355ea',1,'ripple::RCLConsensus::getJson()'],['../classripple_1_1RCLCxLedger.html#aad38a2e710238aef4c8c3ba64c229aee',1,'ripple::RCLCxLedger::getJson()'],['../classripple_1_1RCLCxPeerPos.html#a65a69d25d4b834b50190f671d182010d',1,'ripple::RCLCxPeerPos::getJson()'],['../classripple_1_1AcceptedLedgerTx.html#a6e8dfbec3db1a1436636838e6db327bf',1,'ripple::AcceptedLedgerTx::getJson()'],['../classripple_1_1InboundLedger.html#a069c3ef1adae2c6d17c67e71071ca962',1,'ripple::InboundLedger::getJson()'],['../classripple_1_1AmendmentTable.html#ac63a31d38346fba5d5ca78c4894af31a',1,'ripple::AmendmentTable::getJson() const =0'],['../classripple_1_1AmendmentTable.html#a679a2a34193d9788688eb8456631bc49',1,'ripple::AmendmentTable::getJson(uint256 const &amendment) const =0'],['../classripple_1_1AmendmentTableImpl.html#a9c84b0a42b131a8c6392a993bc4b4c4c',1,'ripple::AmendmentTableImpl::getJson() const override'],['../classripple_1_1AmendmentTableImpl.html#a8780f13856e21995bfa5001959d5bff4',1,'ripple::AmendmentTableImpl::getJson(uint256 const &) const override'],['../classripple_1_1Transaction.html#ac8746fa431dbfc2527f6448033caa53e',1,'ripple::Transaction::getJson()'],['../classripple_1_1ValidatorList.html#a6f943a4488f3b50dcbb5177007d43271',1,'ripple::ValidatorList::getJson()'],['../classripple_1_1ValidatorSite.html#a312f364fbd7a199243881139578c9ac7',1,'ripple::ValidatorSite::getJson()'],['../classripple_1_1TrustLineBase.html#ac9c5e0c9b869301f4991cc35a265b6fc',1,'ripple::TrustLineBase::getJson()'],['../classripple_1_1Consensus.html#a6e81235f0c5f91c23cbe1938ffe8a9e3',1,'ripple::Consensus::getJson()'],['../classripple_1_1ConsensusProposal.html#a799315c246e228ac703759505d8997d8',1,'ripple::ConsensusProposal::getJson()'],['../classripple_1_1DisputedTx.html#a17ac6060bf6ac7641f4ea9b8cc25d9c9',1,'ripple::DisputedTx::getJson()'],['../structripple_1_1ledger__trie__detail_1_1Node.html#a2619579b5ec9c819b87307ee63fe3153',1,'ripple::ledger_trie_detail::Node::getJson()'],['../classripple_1_1LedgerTrie.html#a68e57b86e3de6d1cf969b6a883742bf2',1,'ripple::LedgerTrie::getJson()'],['../classripple_1_1JobQueue.html#a8a0f5f0f114ceb9d5f03f66252d6889b',1,'ripple::JobQueue::getJson()'],['../classripple_1_1STAmount.html#a02bef3696a9cb07b72e5ec750e7ea456',1,'ripple::STAmount::getJson()'],['../classripple_1_1STArray.html#abace0153bbea0217867bde2a591ebe28',1,'ripple::STArray::getJson()'],['../classripple_1_1STBase.html#af1dfd1c754eaf5eded23242b59a0cdb5',1,'ripple::STBase::getJson()'],['../classripple_1_1STCurrency.html#a792de3f4580f1f0c69a6178a581255f3',1,'ripple::STCurrency::getJson()'],['../classripple_1_1STInteger.html#a2d690262f59133fe59e938b2097920f3',1,'ripple::STInteger::getJson()'],['../classripple_1_1STIssue.html#a70741f92ab7f71f6c227dbaed47087c3',1,'ripple::STIssue::getJson()'],['../classripple_1_1STLedgerEntry.html#a9302de6f8a80801399254527caf91fe2',1,'ripple::STLedgerEntry::getJson()'],['../classripple_1_1STObject.html#acc2ceb95cdb8fc8b2520aeceabf17553',1,'ripple::STObject::getJson()'],['../classripple_1_1STPath.html#ab8bd502211308857863a29188a680c13',1,'ripple::STPath::getJson()'],['../classripple_1_1STPathSet.html#a98d06aae5b406ad1633092c13af49408',1,'ripple::STPathSet::getJson()'],['../classripple_1_1STTx.html#a489c8110e24455a2e7dac783f4760cc2',1,'ripple::STTx::getJson(JsonOptions options) const override'],['../classripple_1_1STTx.html#a48b76dde3140dc8304e4ff4893356fdc',1,'ripple::STTx::getJson(JsonOptions options, bool binary) const'],['../classripple_1_1STVector256.html#a478b879cc607d0d1ac931f10b8cd96e8',1,'ripple::STVector256::getJson()'],['../classripple_1_1STXChainBridge.html#a73e46acf5801b27787cecc5234732077',1,'ripple::STXChainBridge::getJson()'],['../classripple_1_1TxMeta.html#a9fbad6f4d81e6952637230ee3f49a183',1,'ripple::TxMeta::getJson()'],['../classripple_1_1Resource_1_1Logic.html#a6b47a9a2f63cc950895ba67514d72723',1,'ripple::Resource::Logic::getJson()'],['../classripple_1_1Resource_1_1Logic.html#ab1ce4bc72906e2c8ac05b770b0754465',1,'ripple::Resource::Logic::getJson(int threshold)'],['../classripple_1_1Resource_1_1ManagerImp.html#a2198b717f65286957cf5abe8aa9b22e0',1,'ripple::Resource::ManagerImp::getJson() override'],['../classripple_1_1Resource_1_1ManagerImp.html#a54dac1f88cb19ee470d971036f0d7b8b',1,'ripple::Resource::ManagerImp::getJson(int threshold) override'],['../classripple_1_1Resource_1_1Manager.html#a06751117098e01ef0e0a780df25a9b2d',1,'ripple::Resource::Manager::getJson()=0'],['../classripple_1_1Resource_1_1Manager.html#ab5fe84b72cd833f4cd659b0ceca673b0',1,'ripple::Resource::Manager::getJson(int threshold)=0'],['../classripple_1_1test_1_1csf_1_1Ledger.html#a7bc8181b16188a8f129a67154afaf74d',1,'ripple::test::csf::Ledger::getJson()'],['../classripple_1_1test_1_1csf_1_1Peer_1_1Position.html#a5c3e8a7e4acd218d4f66452fe5b85805',1,'ripple::test::csf::Peer::Position::getJson()'],['../namespaceripple.html#ad30131b5a5b7cf60d9b392ab868b8c0e',1,'ripple::getJson()']]], + ['getjson_18780',['getJson',['../classripple_1_1RCLConsensus.html#acdab4291925cbabf861b8019c76355ea',1,'ripple::RCLConsensus::getJson()'],['../classripple_1_1RCLCxLedger.html#aad38a2e710238aef4c8c3ba64c229aee',1,'ripple::RCLCxLedger::getJson()'],['../classripple_1_1RCLCxPeerPos.html#a65a69d25d4b834b50190f671d182010d',1,'ripple::RCLCxPeerPos::getJson()'],['../classripple_1_1AcceptedLedgerTx.html#a6e8dfbec3db1a1436636838e6db327bf',1,'ripple::AcceptedLedgerTx::getJson()'],['../classripple_1_1InboundLedger.html#a069c3ef1adae2c6d17c67e71071ca962',1,'ripple::InboundLedger::getJson()'],['../classripple_1_1AmendmentTable.html#a6ac6934733758e569d25e1e136fb84d5',1,'ripple::AmendmentTable::getJson(bool isAdmin) const =0'],['../classripple_1_1AmendmentTable.html#a2b779a15190c7e9ba93ca99bada7093c',1,'ripple::AmendmentTable::getJson(uint256 const &amendment, bool isAdmin) const =0'],['../classripple_1_1AmendmentTableImpl.html#a8f8c9cec31fa120c43e41fa2e7d108ad',1,'ripple::AmendmentTableImpl::getJson(bool isAdmin) const override'],['../classripple_1_1AmendmentTableImpl.html#a989a955a89400c53e8d89a280b890d6b',1,'ripple::AmendmentTableImpl::getJson(uint256 const &, bool isAdmin) const override'],['../classripple_1_1Transaction.html#ac8746fa431dbfc2527f6448033caa53e',1,'ripple::Transaction::getJson()'],['../classripple_1_1ValidatorList.html#a6f943a4488f3b50dcbb5177007d43271',1,'ripple::ValidatorList::getJson()'],['../classripple_1_1ValidatorSite.html#a312f364fbd7a199243881139578c9ac7',1,'ripple::ValidatorSite::getJson()'],['../classripple_1_1TrustLineBase.html#ac9c5e0c9b869301f4991cc35a265b6fc',1,'ripple::TrustLineBase::getJson()'],['../classripple_1_1Consensus.html#a6e81235f0c5f91c23cbe1938ffe8a9e3',1,'ripple::Consensus::getJson()'],['../classripple_1_1ConsensusProposal.html#a799315c246e228ac703759505d8997d8',1,'ripple::ConsensusProposal::getJson()'],['../classripple_1_1DisputedTx.html#a17ac6060bf6ac7641f4ea9b8cc25d9c9',1,'ripple::DisputedTx::getJson()'],['../structripple_1_1ledger__trie__detail_1_1Node.html#a2619579b5ec9c819b87307ee63fe3153',1,'ripple::ledger_trie_detail::Node::getJson()'],['../classripple_1_1LedgerTrie.html#a68e57b86e3de6d1cf969b6a883742bf2',1,'ripple::LedgerTrie::getJson()'],['../classripple_1_1JobQueue.html#a8a0f5f0f114ceb9d5f03f66252d6889b',1,'ripple::JobQueue::getJson()'],['../classripple_1_1STAmount.html#a02bef3696a9cb07b72e5ec750e7ea456',1,'ripple::STAmount::getJson()'],['../classripple_1_1STArray.html#abace0153bbea0217867bde2a591ebe28',1,'ripple::STArray::getJson()'],['../classripple_1_1STBase.html#af1dfd1c754eaf5eded23242b59a0cdb5',1,'ripple::STBase::getJson()'],['../classripple_1_1STCurrency.html#a792de3f4580f1f0c69a6178a581255f3',1,'ripple::STCurrency::getJson()'],['../classripple_1_1STInteger.html#a2d690262f59133fe59e938b2097920f3',1,'ripple::STInteger::getJson()'],['../classripple_1_1STIssue.html#a70741f92ab7f71f6c227dbaed47087c3',1,'ripple::STIssue::getJson()'],['../classripple_1_1STLedgerEntry.html#a9302de6f8a80801399254527caf91fe2',1,'ripple::STLedgerEntry::getJson()'],['../classripple_1_1STObject.html#acc2ceb95cdb8fc8b2520aeceabf17553',1,'ripple::STObject::getJson()'],['../classripple_1_1STPath.html#ab8bd502211308857863a29188a680c13',1,'ripple::STPath::getJson()'],['../classripple_1_1STPathSet.html#a98d06aae5b406ad1633092c13af49408',1,'ripple::STPathSet::getJson()'],['../classripple_1_1STTx.html#a489c8110e24455a2e7dac783f4760cc2',1,'ripple::STTx::getJson(JsonOptions options) const override'],['../classripple_1_1STTx.html#a48b76dde3140dc8304e4ff4893356fdc',1,'ripple::STTx::getJson(JsonOptions options, bool binary) const'],['../classripple_1_1STVector256.html#a478b879cc607d0d1ac931f10b8cd96e8',1,'ripple::STVector256::getJson()'],['../classripple_1_1STXChainBridge.html#a73e46acf5801b27787cecc5234732077',1,'ripple::STXChainBridge::getJson()'],['../classripple_1_1TxMeta.html#a9fbad6f4d81e6952637230ee3f49a183',1,'ripple::TxMeta::getJson()'],['../classripple_1_1Resource_1_1Logic.html#a6b47a9a2f63cc950895ba67514d72723',1,'ripple::Resource::Logic::getJson()'],['../classripple_1_1Resource_1_1Logic.html#ab1ce4bc72906e2c8ac05b770b0754465',1,'ripple::Resource::Logic::getJson(int threshold)'],['../classripple_1_1Resource_1_1ManagerImp.html#a2198b717f65286957cf5abe8aa9b22e0',1,'ripple::Resource::ManagerImp::getJson() override'],['../classripple_1_1Resource_1_1ManagerImp.html#a54dac1f88cb19ee470d971036f0d7b8b',1,'ripple::Resource::ManagerImp::getJson(int threshold) override'],['../classripple_1_1Resource_1_1Manager.html#a06751117098e01ef0e0a780df25a9b2d',1,'ripple::Resource::Manager::getJson()=0'],['../classripple_1_1Resource_1_1Manager.html#ab5fe84b72cd833f4cd659b0ceca673b0',1,'ripple::Resource::Manager::getJson(int threshold)=0'],['../classripple_1_1test_1_1csf_1_1Ledger.html#a7bc8181b16188a8f129a67154afaf74d',1,'ripple::test::csf::Ledger::getJson()'],['../classripple_1_1test_1_1csf_1_1Peer_1_1Position.html#a5c3e8a7e4acd218d4f66452fe5b85805',1,'ripple::test::csf::Peer::Position::getJson()'],['../namespaceripple.html#ad30131b5a5b7cf60d9b392ab868b8c0e',1,'ripple::getJson()']]], ['getjsonname_18781',['getJsonName',['../classripple_1_1SField.html#ab18506568f3d60892a7c108eaeb3a05d',1,'ripple::SField']]], ['getjsontrie_18782',['getJsonTrie',['../classripple_1_1Validations.html#a4436616304f6309389ddd6d11f5560d2',1,'ripple::Validations']]], ['getkbusedall_18783',['getKBUsedAll',['../classripple_1_1SQLiteDatabaseImp.html#ae53c9caa41b8e7ccb388eed3cd284f51',1,'ripple::SQLiteDatabaseImp::getKBUsedAll()'],['../classripple_1_1SQLiteDatabase.html#af00c81d707db5d1f879bb52f85b28ed1',1,'ripple::SQLiteDatabase::getKBUsedAll()'],['../namespaceripple.html#a3063535903fec75ab36b634cb531c835',1,'ripple::getKBUsedAll()']]], diff --git a/search/functions_9.js b/search/functions_9.js index c7b1f5e83f..8eb54ff036 100644 --- a/search/functions_9.js +++ b/search/functions_9.js @@ -82,7 +82,7 @@ var searchData= ['initstatedb_19310',['initStateDB',['../namespaceripple.html#a632dcd1160907dbaea1cd6caceca886c',1,'ripple']]], ['inject_19311',['inject',['../structripple_1_1RPC_1_1Status.html#a91ffe9a0175caf0cdcc5d34338de638c',1,'ripple::RPC::Status']]], ['inject_5ferror_19312',['inject_error',['../namespaceripple_1_1RPC.html#a577bde9602a28f59e445c496f92a1ccf',1,'ripple::RPC::inject_error(error_code_i code, JsonValue &json)'],['../namespaceripple_1_1RPC.html#a073aa52d66bf3061aed8861d1db747d0',1,'ripple::RPC::inject_error(int code, JsonValue &json)'],['../namespaceripple_1_1RPC.html#a2b8314da490d3e5f165dcc839bd2271e',1,'ripple::RPC::inject_error(error_code_i code, std::string const &message, JsonValue &json)']]], - ['injectjson_19313',['injectJson',['../classripple_1_1AmendmentTableImpl.html#a4f1d0bde577c66d4c238a3f6bfd8fc6a',1,'ripple::AmendmentTableImpl']]], + ['injectjson_19313',['injectJson',['../classripple_1_1AmendmentTableImpl.html#a7d021a2ba5be052ab848f7dd5ff0de25',1,'ripple::AmendmentTableImpl']]], ['injectreportingwarning_19314',['injectReportingWarning',['../namespaceripple_1_1RPC.html#a7d14d5ae6f47355a9d9d51ae58e7101a',1,'ripple::RPC']]], ['injectsle_19315',['injectSLE',['../namespaceripple_1_1RPC.html#a4ea6d08c0d50d738a6a55130a09ec238',1,'ripple::RPC']]], ['injecttxs_19316',['injectTxs',['../structripple_1_1test_1_1csf_1_1Peer.html#aeb7f2db3bebf459c49cff2afb849648a',1,'ripple::test::csf::Peer']]],