vrf_sortition.hpp

Go to the documentation of this file.

#pragma once
#include <libdevcore/SHA3.h>
#include <libdevcrypto/Common.h>
 
#include <boost/multiprecision/mpfr.hpp>
 
#include "common/types.hpp"
#include "common/vrf_wrapper.hpp"
 
namespace taraxa {
 
// PbftVoteTypes are equal to step numbers, e.g.
// - "propose_vote" type can be created only in step 1
// - "soft_vote" type can be created only in step 2
// - "cert_vote" type can be created only in step 3
// - "next_vote" type can be created only in step 4 or more
enum class PbftVoteTypes : uint8_t { invalid_vote = 0, propose_vote, soft_vote, cert_vote, next_vote };
 
class VrfPbftMsg {
 public:
  VrfPbftMsg() = default;
  VrfPbftMsg(PbftVoteTypes type, PbftPeriod period, PbftRound round, PbftStep step);
 
  PbftVoteTypes getType() const;
 
  std::string toString() const;
 
  bytes getRlpBytes() const;
 
  bool operator==(VrfPbftMsg const& other) const;
  friend std::ostream& operator<<(std::ostream& strm, VrfPbftMsg const& pbft_msg) {
    strm << "  [Vrf Pbft Msg] " << std::endl;
    strm << "    period: " << pbft_msg.period_ << std::endl;
    strm << "    round: " << pbft_msg.round_ << std::endl;
    strm << "    step: " << pbft_msg.step_ << std::endl;
    return strm;
  }
 
  PbftPeriod period_;
  PbftRound round_;
  PbftStep step_;
};
 
dev::h256 getVoterIndexHash(const vrf_wrapper::vrf_output_t& vrf, const public_t& address, uint64_t index = 0);
 
class VrfPbftSortition : public vrf_wrapper::VrfSortitionBase {
  using vrf_sk_t = vrf_wrapper::vrf_sk_t;
  using vrf_pk_t = vrf_wrapper::vrf_pk_t;
  using vrf_proof_t = vrf_wrapper::vrf_proof_t;
  using vrf_output_t = vrf_wrapper::vrf_output_t;
 
 public:
  VrfPbftSortition() = default;
 
  VrfPbftSortition(vrf_sk_t const& sk, const VrfPbftMsg& pbft_msg)
      : VrfSortitionBase(sk, pbft_msg.getRlpBytes()), pbft_msg_(pbft_msg) {}
 
  explicit VrfPbftSortition(dev::bytes const& rlp);
 
  dev::bytes getRlpBytes() const;
 
  bool verify(const vrf_pk_t& pk, bool strict = true) const {
    return VrfSortitionBase::verify(pk, pbft_msg_.getRlpBytes(), 1, strict);
  }
 
  bool operator==(VrfPbftSortition const& other) const {
    return pbft_msg_ == other.pbft_msg_ && vrf_wrapper::VrfSortitionBase::operator==(other);
  }
 
  static inline uint256_t max256bits = std::numeric_limits<uint256_t>::max();
  static inline auto kMax256bFP = max256bits.convert_to<boost::multiprecision::mpfr_float>();
 
  static uint64_t getBinominalDistribution(uint64_t stake, double dpos_total_votes_count, double threshold,
                                           const uint256_t& hash);
 
  uint64_t calculateWeight(uint64_t stake, uint64_t dpos_total_votes_count, uint64_t threshold,
                           const public_t& address) const;
 
  friend std::ostream& operator<<(std::ostream& strm, const VrfPbftSortition& vrf_sortition) {
    strm << "[VRF sortition] " << std::endl;
    strm << "  proof: " << vrf_sortition.proof_ << std::endl;
    strm << "  output: " << vrf_sortition.output_ << std::endl;
    strm << vrf_sortition.pbft_msg_ << std::endl;
    return strm;
  }
 
  VrfPbftMsg pbft_msg_;
};
 
}  // namespace taraxa