Seed.h

#pragma once
 
#include <xrpl/basics/Slice.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/protocol/tokens.h>
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <optional>
#include <string>
 
namespace xrpl {

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);
 
    [[nodiscard]] std::uint8_t const*
    data() const
    {
        return buf_.data();
    }
 
    [[nodiscard]] std::size_t
    size() const
    {
        return buf_.size();
    }
 
    [[nodiscard]] const_iterator
    begin() const noexcept
    {
        return buf_.begin();
    }
 
    [[nodiscard]] const_iterator
    cbegin() const noexcept
    {
        return buf_.cbegin();
    }
 
    [[nodiscard]] const_iterator
    end() const noexcept
    {
        return buf_.end();
    }
 
    [[nodiscard]] 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 xrpl