PublicKey.h

#pragma once
 
#include <xrpl/basics/Slice.h>
#include <xrpl/basics/StringUtilities.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/basics/contract.h>
#include <xrpl/beast/net/IPEndpoint.h>
#include <xrpl/json/json_value.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/KeyType.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STBlob.h>
#include <xrpl/protocol/STExchange.h>
#include <xrpl/protocol/UintTypes.h>
#include <xrpl/protocol/json_get_or_throw.h>
#include <xrpl/protocol/tokens.h>
 
#include <algorithm>
#include <cstdint>
#include <cstring>
#include <memory>
#include <optional>
#include <ostream>
#include <sstream>
#include <string>
 
namespace xrpl {

class PublicKey
{
protected:
    // All the constructed public keys are valid, non-empty and contain 33
    // bytes of data.
    static constexpr std::size_t kSize = 33;
    std::uint8_t buf_[kSize]{};  // should be large enough
 
public:
    using const_iterator = std::uint8_t const*;
 
public:
    PublicKey() = delete;
 
    PublicKey(PublicKey const& other);
    PublicKey&
    operator=(PublicKey const& other);

    explicit PublicKey(Slice const& slice);
 
    [[nodiscard]] std::uint8_t const*
    data() const noexcept
    {
        return buf_;
    }
 
    static std::size_t
    size() noexcept
    {
        return kSize;
    }
 
    [[nodiscard]] const_iterator
    begin() const noexcept
    {
        return buf_;
    }
 
    [[nodiscard]] const_iterator
    cbegin() const noexcept
    {
        return buf_;
    }
 
    [[nodiscard]] const_iterator
    end() const noexcept
    {
        return buf_ + kSize;
    }
 
    [[nodiscard]] const_iterator
    cend() const noexcept
    {
        return buf_ + kSize;
    }
 
    [[nodiscard]] Slice
    slice() const noexcept
    {
        return {buf_, kSize};
    }
 
    operator Slice() const noexcept
    {
        return slice();
    }
};

std::ostream&
operator<<(std::ostream& os, PublicKey const& pk);
 
inline bool
operator==(PublicKey const& lhs, PublicKey const& rhs)
{
    return std::memcmp(lhs.data(), rhs.data(), rhs.size()) == 0;
}
 
inline bool
operator<(PublicKey const& lhs, PublicKey const& rhs)
{
    return std::lexicographical_compare(
        lhs.data(), lhs.data() + lhs.size(), rhs.data(), rhs.data() + rhs.size());
}
 
template <class Hasher>
void
hash_append(Hasher& h, PublicKey const& pk)
{
    h(pk.data(), pk.size());
}
 
template <>
struct STExchange<STBlob, PublicKey>
{
    explicit STExchange() = default;
 
    using value_type = PublicKey;
 
    static void
    get(std::optional<value_type>& t, STBlob const& u)
    {
        t.emplace(Slice(u.data(), u.size()));
    }
 
    static std::unique_ptr<STBlob>
    set(SField const& f, PublicKey const& t)
    {
        return std::make_unique<STBlob>(f, t.data(), t.size());
    }
};
 
//------------------------------------------------------------------------------
 
inline std::string
toBase58(TokenType type, PublicKey const& pk)
{
    return encodeBase58Token(type, pk.data(), pk.size());
}
 
template <>
std::optional<PublicKey>
parseBase58(TokenType type, std::string const& s);
 
enum class ECDSACanonicality { Canonical, FullyCanonical };

std::optional<ECDSACanonicality>
ecdsaCanonicality(Slice const& sig);

[[nodiscard]] std::optional<KeyType>
publicKeyType(Slice const& slice);
 
[[nodiscard]] inline std::optional<KeyType>
publicKeyType(PublicKey const& publicKey)
{
    return publicKeyType(publicKey.slice());
}


[[nodiscard]] bool
verifyDigest(
    PublicKey const& publicKey,
    uint256 const& digest,
    Slice const& sig,
    bool mustBeFullyCanonical = true) noexcept;

[[nodiscard]] bool
verify(PublicKey const& publicKey, Slice const& m, Slice const& sig) noexcept;

NodeID
calcNodeID(PublicKey const&);
 
// VFALCO This belongs in AccountID.h but
//        is here because of header issues
AccountID
calcAccountID(PublicKey const& pk);
 
inline std::string
getFingerprint(
    beast::ip::Endpoint const& address,
    std::optional<PublicKey> const& publicKey = std::nullopt,
    std::optional<std::string> const& id = std::nullopt)
{
    std::stringstream ss;
    ss << "IP Address: " << address;
    if (publicKey.has_value())
    {
        ss << ", Public Key: " << toBase58(TokenType::NodePublic, *publicKey);
    }
    if (id.has_value())
    {
        ss << ", Id: " << id.value();
    }
    return ss.str();
}
}  // namespace xrpl
 
//------------------------------------------------------------------------------
 
namespace json {
template <>
inline xrpl::PublicKey
getOrThrow(json::Value const& v, xrpl::SField const& field)
{
    using namespace xrpl;
    std::string const b58 = getOrThrow<std::string>(v, field);
    if (auto pubKeyBlob = strUnHex(b58);
        pubKeyBlob.has_value() && publicKeyType(makeSlice(*pubKeyBlob)))
    {
        return PublicKey{makeSlice(*pubKeyBlob)};
    }
    for (auto const tokenType : {TokenType::NodePublic, TokenType::AccountPublic})
    {
        if (auto const pk = parseBase58<PublicKey>(tokenType, b58))
            return *pk;
    }
    Throw<JsonTypeMismatchError>(field.getJsonName(), "PublicKey");
}
}  // namespace json