jtx/Account.h

#pragma once
 
#include <xrpl/beast/hash/uhash.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/KeyType.h>
#include <xrpl/protocol/PublicKey.h>
#include <xrpl/protocol/SecretKey.h>
 
#include <string>
#include <unordered_map>
#include <utility>
 
namespace xrpl::test::jtx {
 
class IOU;

class Account
{
private:
    // Tag for access to private contr
    struct PrivateCtorTag
    {
    };
 
public:
    static Account const kMaster;
 
    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 class AcctStringType { Base58Seed, Other };
    Account(AcctStringType stringType, std::string base58SeedStr);

    [[nodiscard]] std::string const&
    name() const
    {
        return name_;
    }

    [[nodiscard]] PublicKey const&
    pk() const
    {
        return pk_;
    }

    [[nodiscard]] SecretKey const&
    sk() const
    {
        return sk_;
    }

    [[nodiscard]] AccountID
    id() const
    {
        return id_;
    }

    [[nodiscard]] 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  // NOLINT(readability-identifier-naming)
{
    hash_append(h, v.id());
}
 
inline auto
operator<=>(Account const& lhs, Account const& rhs) noexcept
{
    return lhs.id() <=> rhs.id();
}
 
}  // namespace xrpl::test::jtx