batch.h

#pragma once
 
#include <test/jtx/Account.h>
#include <test/jtx/Env.h>
#include <test/jtx/JTx.h>
#include <test/jtx/SignerUtils.h>
 
#include <xrpl/json/json_value.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STAmount.h>
#include <xrpl/protocol/TxFlags.h>
#include <xrpl/protocol/XRPAmount.h>
#include <xrpl/protocol/jss.h>
 
#include <concepts>
#include <cstdint>
#include <optional>
#include <source_location>
#include <string>
#include <utility>
#include <vector>

namespace xrpl::test::jtx::batch {

XRPAmount
calcBatchFee(jtx::Env const& env, uint32_t const& numSigners, uint32_t const& txns = 0);

XRPAmount
calcConfidentialBatchFee(jtx::Env const& env, uint32_t const& numSigners, uint32_t const& txns = 0);

json::Value
outer(jtx::Account const& account, uint32_t seq, STAmount const& fee, std::uint32_t flags);

void
validateInnerTxn(
    Env& env,
    std::string const& batchID,
    std::string const& txHash,
    std::string const& txType,
    std::string const& result,
    std::source_location const& loc = std::source_location::current());

class Inner
{
private:
    json::Value txn_;
    std::optional<std::uint32_t> ticket_;
 
public:
    Inner(
        json::Value txn,
        std::uint32_t const& sequence,
        std::optional<std::uint32_t> const& ticket = std::nullopt)
        : txn_(std::move(txn)), ticket_(ticket)
    {
        txn_[jss::SigningPubKey] = "";
        txn_[jss::Sequence] = sequence;
        txn_[jss::Fee] = "0";
        txn_[jss::Flags] = txn_[jss::Flags].asUInt() | tfInnerBatchTxn;
 
        // Optionally set ticket sequence
        if (ticket_.has_value())
        {
            txn_[jss::Sequence] = 0;
            txn_[sfTicketSequence.jsonName] = *ticket_;
        }
    }
 
    void
    operator()(Env&, JTx& jtx) const;
 
    json::Value&
    operator[](json::StaticString const& key)
    {
        return txn_[key];
    }
 
    void
    removeMember(json::StaticString const& key)
    {
        txn_.removeMember(key);
    }
 
    [[nodiscard]] json::Value const&
    getTxn() const
    {
        return txn_;
    }
};

class Sig
{
public:
    std::vector<Reg> signers;
 
    Sig(std::vector<Reg> s) : signers(std::move(s))
    {
        sortSigners(signers);
    }
 
    template <class AccountType, class... Accounts>
        requires std::convertible_to<AccountType, Reg>
    explicit Sig(AccountType&& a0, Accounts&&... aN)
        : signers{std::forward<AccountType>(a0), std::forward<Accounts>(aN)...}
    {
        sortSigners(signers);
    }
 
    void
    operator()(Env&, JTx& jt) const;
};

class Msig
{
public:
    Account master;
    std::vector<Reg> signers;
 
    Msig(Account masterAccount, std::vector<Reg> s)
        : master(std::move(masterAccount)), signers(std::move(s))
    {
        sortSigners(signers);
    }
 
    template <class AccountType, class... Accounts>
        requires std::convertible_to<AccountType, Reg>
    explicit Msig(Account masterAccount, AccountType&& a0, Accounts&&... aN)
        : master(std::move(masterAccount))
        , signers{std::forward<AccountType>(a0), std::forward<Accounts>(aN)...}
    {
        sortSigners(signers);
    }
 
    void
    operator()(Env&, JTx& jt) const;
};
 
}  // namespace xrpl::test::jtx::batch