Account.h

#ifndef XRPL_TEST_JTX_ACCOUNT_H_INCLUDED
#define XRPL_TEST_JTX_ACCOUNT_H_INCLUDED
 
#include <xrpl/beast/hash/uhash.h>
#include <xrpl/protocol/KeyType.h>
#include <xrpl/protocol/SecretKey.h>
#include <xrpl/protocol/UintTypes.h>
 
#include <string>
#include <unordered_map>
 
namespace ripple {
namespace test {
namespace jtx {
 
class IOU;
 
class Account
{
private:
    // Tag for access to private contr
    struct privateCtorTag
    {
    };
 
public:
    static Account const master;
 
    Account() = delete;
    Account(Account&&) = default;
    Account(Account const&) = default;
    Account&
    operator=(Account const&) = default;
    Account&
    operator=(Account&&) = default;
 
    Account(std::string name, KeyType type = KeyType::secp256k1);
 
    Account(char const* name, KeyType type = KeyType::secp256k1)
        : Account(std::string(name), type)
    {
    }
 
    // This constructor needs to be public so `std::pair` can use it when
    // emplacing into the cache. However, it is logically `private`. This is
    // enforced with the `privateTag` parameter.
    Account(
        std::string name,
        std::pair<PublicKey, SecretKey> const& keys,
        Account::privateCtorTag);
 
    explicit Account(std::string name, AccountID const& id);
 
    enum AcctStringType { base58Seed, other };
    Account(AcctStringType stringType, std::string base58SeedStr);
 
    std::string const&
    name() const
    {
        return name_;
    }
 
    PublicKey const&
    pk() const
    {
        return pk_;
    }
 
    SecretKey const&
    sk() const
    {
        return sk_;
    }
 
    AccountID
    id() const
    {
        return id_;
    }
 
    std::string const&
    human() const
    {
        return human_;
    }
 
    operator AccountID() const
    {
        return id_;
    }
 
    IOU
    operator[](std::string const& s) const;
 
private:
    static std::
        unordered_map<std::pair<std::string, KeyType>, Account, beast::uhash<>>
            cache_;
 
    // Return the account from the cache & add it to the cache if needed
    static Account
    fromCache(AcctStringType stringType, std::string name, KeyType type);
 
    std::string name_;
    PublicKey pk_;
    SecretKey sk_;
    AccountID id_;
    std::string human_;  // base58 public key string
};
 
inline bool
operator==(Account const& lhs, Account const& rhs) noexcept
{
    return lhs.id() == rhs.id();
}
 
template <class Hasher>
void
hash_append(Hasher& h, Account const& v) noexcept
{
    hash_append(h, v.id());
}
 
inline auto
operator<=>(Account const& lhs, Account const& rhs) noexcept
{
    return lhs.id() <=> rhs.id();
}
 
}  // namespace jtx
}  // namespace test
}  // namespace ripple
 
#endif