RCLCxPeerPos.h

#pragma once
 
#include <xrpld/consensus/ConsensusProposal.h>
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/hash/hash_append.h>
#include <xrpl/json/json_value.h>
#include <xrpl/protocol/HashPrefix.h>
#include <xrpl/protocol/PublicKey.h>
 
#include <boost/container/static_vector.hpp>
 
#include <cstdint>
#include <string>
 
namespace xrpl {
 
class RCLCxPeerPos
{
public:
    //< The type of the proposed position
    using Proposal = ConsensusProposal<NodeID, uint256, uint256>;
 
    RCLCxPeerPos(
        PublicKey const& publicKey,
        Slice const& signature,
        uint256 const& suppress,
        Proposal const& proposal);  // trivially copyable
 
    bool
    checkSign() const;
 
    Slice
    signature() const
    {
        return {signature_.data(), signature_.size()};
    }
 
    PublicKey const&
    publicKey() const
    {
        return publicKey_;
    }
 
    uint256 const&
    suppressionID() const
    {
        return suppression_;
    }
 
    Proposal const&
    proposal() const
    {
        return proposal_;
    }
 
    Json::Value
    getJson() const;
 
    std::string
    render() const
    {
        return proposal_.render();
    }
 
private:
    PublicKey publicKey_;
    uint256 suppression_;
    Proposal proposal_;
    boost::container::static_vector<std::uint8_t, 72> signature_;
 
    template <class Hasher>
    void
    hash_append(Hasher& h) const
    {
        using beast::hash_append;
        hash_append(h, HashPrefix::proposal);
        hash_append(h, std::uint32_t(proposal().proposeSeq()));
        hash_append(h, proposal().closeTime());
        hash_append(h, proposal().prevLedger());
        hash_append(h, proposal().position());
    }
};
 
uint256
proposalUniqueId(
    uint256 const& proposeHash,
    uint256 const& previousLedger,
    std::uint32_t proposeSeq,
    NetClock::time_point closeTime,
    Slice const& publicKey,
    Slice const& signature);
 
}  // namespace xrpl