Seed.h

#ifndef XRPL_PROTOCOL_SEED_H_INCLUDED
#define XRPL_PROTOCOL_SEED_H_INCLUDED
 
#include <xrpl/basics/Slice.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/protocol/tokens.h>
 
#include <array>
#include <optional>
 
namespace ripple {
 
class Seed
{
private:
    std::array<uint8_t, 16> buf_;
 
public:
    using const_iterator = std::array<uint8_t, 16>::const_iterator;
 
    Seed() = delete;
 
    Seed(Seed const&) = default;
    Seed&
    operator=(Seed const&) = default;
 
    ~Seed();
 
    explicit Seed(Slice const& slice);
    explicit Seed(uint128 const& seed);
    std::uint8_t const*
    data() const
    {
        return buf_.data();
    }
 
    std::size_t
    size() const
    {
        return buf_.size();
    }
 
    const_iterator
    begin() const noexcept
    {
        return buf_.begin();
    }
 
    const_iterator
    cbegin() const noexcept
    {
        return buf_.cbegin();
    }
 
    const_iterator
    end() const noexcept
    {
        return buf_.end();
    }
 
    const_iterator
    cend() const noexcept
    {
        return buf_.cend();
    }
};
 
//------------------------------------------------------------------------------
 
Seed
randomSeed();
 
Seed
generateSeed(std::string const& passPhrase);
 
template <>
std::optional<Seed>
parseBase58(std::string const& s);
 
std::optional<Seed>
parseGenericSeed(std::string const& str, bool rfc1751 = true);
 
std::string
seedAs1751(Seed const& seed);
 
inline std::string
toBase58(Seed const& seed)
{
    return encodeBase58Token(TokenType::FamilySeed, seed.data(), seed.size());
}
 
}  // namespace ripple
 
#endif