SecretKey.h

#ifndef XRPL_PROTOCOL_SECRETKEY_H_INCLUDED
#define XRPL_PROTOCOL_SECRETKEY_H_INCLUDED
 
#include <xrpl/basics/Buffer.h>
#include <xrpl/basics/Slice.h>
#include <xrpl/protocol/KeyType.h>
#include <xrpl/protocol/PublicKey.h>
#include <xrpl/protocol/Seed.h>
#include <xrpl/protocol/tokens.h>
 
#include <array>
#include <cstring>
#include <string>
 
namespace ripple {
 
class SecretKey
{
private:
    std::uint8_t buf_[32];
 
public:
    using const_iterator = std::uint8_t const*;
 
    SecretKey() = delete;
    SecretKey(SecretKey const&) = default;
    SecretKey&
    operator=(SecretKey const&) = default;
 
    ~SecretKey();
 
    SecretKey(std::array<std::uint8_t, 32> const& data);
    SecretKey(Slice const& slice);
 
    std::uint8_t const*
    data() const
    {
        return buf_;
    }
 
    std::size_t
    size() const
    {
        return sizeof(buf_);
    }
 
    std::string
    to_string() const;
 
    const_iterator
    begin() const noexcept
    {
        return buf_;
    }
 
    const_iterator
    cbegin() const noexcept
    {
        return buf_;
    }
 
    const_iterator
    end() const noexcept
    {
        return buf_ + sizeof(buf_);
    }
 
    const_iterator
    cend() const noexcept
    {
        return buf_ + sizeof(buf_);
    }
};
 
inline bool
operator==(SecretKey const& lhs, SecretKey const& rhs)
{
    return lhs.size() == rhs.size() &&
        std::memcmp(lhs.data(), rhs.data(), rhs.size()) == 0;
}
 
inline bool
operator!=(SecretKey const& lhs, SecretKey const& rhs)
{
    return !(lhs == rhs);
}
 
//------------------------------------------------------------------------------
 
template <>
std::optional<SecretKey>
parseBase58(TokenType type, std::string const& s);
 
inline std::string
toBase58(TokenType type, SecretKey const& sk)
{
    return encodeBase58Token(type, sk.data(), sk.size());
}
 
SecretKey
randomSecretKey();
 
SecretKey
generateSecretKey(KeyType type, Seed const& seed);
 
PublicKey
derivePublicKey(KeyType type, SecretKey const& sk);
 
std::pair<PublicKey, SecretKey>
generateKeyPair(KeyType type, Seed const& seed);
 
std::pair<PublicKey, SecretKey>
randomKeyPair(KeyType type);
 
Buffer
signDigest(PublicKey const& pk, SecretKey const& sk, uint256 const& digest);
 
inline Buffer
signDigest(KeyType type, SecretKey const& sk, uint256 const& digest)
{
    return signDigest(derivePublicKey(type, sk), sk, digest);
}
Buffer
sign(PublicKey const& pk, SecretKey const& sk, Slice const& message);
 
inline Buffer
sign(KeyType type, SecretKey const& sk, Slice const& message)
{
    return sign(derivePublicKey(type, sk), sk, message);
}
}  // namespace ripple
 
#endif