multisign.h

#pragma once
 
#include <test/jtx/Account.h>
#include <test/jtx/Env.h>
#include <test/jtx/JTx.h>
#include <test/jtx/SignerUtils.h>
#include <test/jtx/owners.h>
#include <test/jtx/tags.h>
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/json/json_value.h>
#include <xrpl/protocol/LedgerFormats.h>
#include <xrpl/protocol/SField.h>
 
#include <concepts>
#include <cstdint>
#include <optional>
#include <utility>
#include <vector>
 
namespace xrpl::test::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, NoneT);
 
//------------------------------------------------------------------------------

class Msig
{
public:
    std::vector<Reg> signers;
    SField const* const subField = nullptr;
    static constexpr SField const* kTopLevel = nullptr;
 
    Msig(SField const* subField, std::vector<Reg> signers)
        : signers(std::move(signers)), subField(subField)
    {
        sortSigners(this->signers);
    }
 
    Msig(SField const& subField, std::vector<Reg> signers) : Msig{&subField, signers}
    {
    }
 
    Msig(std::vector<Reg> signers) : Msig(kTopLevel, 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{
              kTopLevel,
              std::vector<Reg>{std::forward<AccountType>(a0), std::forward<Accounts>(aN)...}}
    {
    }
 
    void
    operator()(Env&, JTx& jt) const;
};
 
//------------------------------------------------------------------------------

using SigLists = OwnerCount<ltSIGNER_LIST>;
 
}  // namespace xrpl::test::jtx