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  // NOLINT(readability-identifier-naming)
    {
        using beast::hash_append;
        hash_append(h, HashPrefix::Proposal);
        hash_append(h, 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