AccountID.h

#ifndef XRPL_PROTOCOL_ACCOUNTID_H_INCLUDED
#define XRPL_PROTOCOL_ACCOUNTID_H_INCLUDED
 
#include <xrpl/protocol/tokens.h>
// VFALCO Uncomment when the header issues are resolved
// #include <ripple/protocol/PublicKey.h>
#include <xrpl/basics/UnorderedContainers.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/json/json_value.h>
#include <xrpl/protocol/json_get_or_throw.h>
 
#include <cstddef>
#include <optional>
#include <string>
 
namespace ripple {
 
namespace detail {
 
class AccountIDTag
{
public:
    explicit AccountIDTag() = default;
};
 
}  // namespace detail
 
using AccountID = base_uint<160, detail::AccountIDTag>;
 
std::string
toBase58(AccountID const& v);
 
template <>
std::optional<AccountID>
parseBase58(std::string const& s);
 
// VFALCO In PublicKey.h for now
// AccountID
// calcAccountID (PublicKey const& pk);
 
AccountID const&
xrpAccount();
 
AccountID const&
noAccount();
 
// DEPRECATED
bool
to_issuer(AccountID&, std::string const&);
 
// DEPRECATED Should be checking the currency or native flag
inline bool
isXRP(AccountID const& c)
{
    return c == beast::zero;
}
 
// DEPRECATED
inline std::string
to_string(AccountID const& account)
{
    return toBase58(account);
}
 
// DEPRECATED
inline std::ostream&
operator<<(std::ostream& os, AccountID const& x)
{
    os << to_string(x);
    return os;
}
 
void
initAccountIdCache(std::size_t count);
 
}  // namespace ripple
 
//------------------------------------------------------------------------------
namespace Json {
template <>
inline ripple::AccountID
getOrThrow(Json::Value const& v, ripple::SField const& field)
{
    using namespace ripple;
 
    std::string const b58 = getOrThrow<std::string>(v, field);
    if (auto const r = parseBase58<AccountID>(b58))
        return *r;
    Throw<JsonTypeMismatchError>(field.getJsonName(), "AccountID");
}
}  // namespace Json
 
//------------------------------------------------------------------------------
 
namespace std {
 
// DEPRECATED
// VFALCO Use beast::uhash or a hardened container
template <>
struct hash<ripple::AccountID> : ripple::AccountID::hasher
{
    hash() = default;
};
 
}  // namespace std
 
#endif