multisign.h

#pragma once
 
#include <test/jtx/Account.h>
#include <test/jtx/SignerUtils.h>
#include <test/jtx/amount.h>
#include <test/jtx/owners.h>
#include <test/jtx/tags.h>
 
#include <concepts>
#include <cstdint>
#include <optional>
 
namespace xrpl {
namespace test {
namespace jtx {
 
struct signer
{
    std::uint32_t weight;
    Account account;
    std::optional<uint256> tag;
 
    signer(Account account_, std::uint32_t weight_ = 1, std::optional<uint256> tag_ = std::nullopt)
        : weight(weight_), account(std::move(account_)), tag(tag_)
    {
    }
};
 
Json::Value
signers(Account const& account, std::uint32_t quorum, std::vector<signer> const& v);
 
Json::Value
signers(Account const& account, none_t);
 
//------------------------------------------------------------------------------
 
class msig
{
public:
    std::vector<Reg> signers;
    SField const* const subField = nullptr;
    static constexpr SField* const topLevel = nullptr;
 
    msig(SField const* subField_, std::vector<Reg> signers_)
        : signers(std::move(signers_)), subField(subField_)
    {
        sortSigners(signers);
    }
 
    msig(SField const& subField_, std::vector<Reg> signers_) : msig{&subField_, signers_}
    {
    }
 
    msig(std::vector<Reg> signers_) : msig(topLevel, signers_)
    {
    }
 
    template <class AccountType, class... Accounts>
        requires std::convertible_to<AccountType, Reg>
    explicit msig(SField const* subField_, AccountType&& a0, Accounts&&... aN)
        : msig{
              subField_,
              std::vector<Reg>{std::forward<AccountType>(a0), std::forward<Accounts>(aN)...}}
    {
    }
 
    template <class AccountType, class... Accounts>
        requires std::convertible_to<AccountType, Reg>
    explicit msig(SField const& subField_, AccountType&& a0, Accounts&&... aN)
        : msig{
              &subField_,
              std::vector<Reg>{std::forward<AccountType>(a0), std::forward<Accounts>(aN)...}}
    {
    }
 
    template <class AccountType, class... Accounts>
        requires(std::convertible_to<AccountType, Reg> && !std::is_same_v<AccountType, SField*>)
    explicit msig(AccountType&& a0, Accounts&&... aN)
        : msig{
              topLevel,
              std::vector<Reg>{std::forward<AccountType>(a0), std::forward<Accounts>(aN)...}}
    {
    }
 
    void
    operator()(Env&, JTx& jt) const;
};
 
//------------------------------------------------------------------------------
 
using siglists = owner_count<ltSIGNER_LIST>;
 
}  // namespace jtx
}  // namespace test
}  // namespace xrpl