token.h

#pragma once
 
#include <test/jtx/Account.h>
#include <test/jtx/Env.h>
#include <test/jtx/JTx.h>
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/basics/strHex.h>
#include <xrpl/json/json_value.h>
#include <xrpl/protocol/STAmount.h>
 
#include <cstdint>
#include <initializer_list>
#include <string>
#include <vector>
 
namespace xrpl::test::jtx::token {

json::Value
mint(jtx::Account const& account, std::uint32_t tokenTaxon = 0);

class XferFee
{
private:
    std::uint16_t xferFee_;
 
public:
    explicit XferFee(std::uint16_t fee) : xferFee_(fee)
    {
    }
 
    void
    operator()(Env&, JTx& jtx) const;
};

class Issuer
{
private:
    std::string issuer_;
 
public:
    explicit Issuer(jtx::Account const& issue) : issuer_(issue.human())
    {
    }
 
    void
    operator()(Env&, JTx& jtx) const;
};

class Uri
{
private:
    std::string uri_;
 
public:
    explicit Uri(std::string const& u) : uri_(strHex(u))
    {
    }
 
    void
    operator()(Env&, JTx& jtx) const;
};

class Amount
{
private:
    STAmount const amount_;
 
public:
    explicit Amount(STAmount const amount) : amount_(amount)
    {
    }
 
    void
    operator()(Env&, JTx& jtx) const;
};

uint256
getNextID(
    jtx::Env const& env,
    jtx::Account const& account,
    std::uint32_t nftokenTaxon,
    std::uint16_t flags = 0,
    std::uint16_t xferFee = 0);

uint256
getID(
    jtx::Env const& env,
    jtx::Account const& account,
    std::uint32_t tokenTaxon,
    std::uint32_t nftSeq,
    std::uint16_t flags = 0,
    std::uint16_t xferFee = 0);

json::Value
burn(jtx::Account const& account, uint256 const& nftokenID);

json::Value
createOffer(jtx::Account const& account, uint256 const& nftokenID, STAmount const& amount);

class Owner
{
private:
    std::string owner_;
 
public:
    explicit Owner(jtx::Account const& ownedBy) : owner_(ownedBy.human())
    {
    }
 
    void
    operator()(Env&, JTx& jtx) const;
};

class Expiration
{
private:
    std::uint32_t expires_;
 
public:
    explicit Expiration(std::uint32_t const& expires) : expires_(expires)
    {
    }
 
    void
    operator()(Env&, JTx& jtx) const;
};

class Destination
{
private:
    std::string dest_;
 
public:
    explicit Destination(jtx::Account const& dest) : dest_(dest.human())
    {
    }
 
    void
    operator()(Env&, JTx& jtx) const;
};

json::Value
cancelOffer(jtx::Account const& account, std::initializer_list<uint256> const& nftokenOffers = {});
 
json::Value
cancelOffer(jtx::Account const& account, std::vector<uint256> const& nftokenOffers);

class RootIndex
{
private:
    std::string rootIndex_;
 
public:
    explicit RootIndex(uint256 const& index) : rootIndex_(to_string(index))
    {
    }
 
    void
    operator()(Env&, JTx& jtx) const;
};

json::Value
acceptBuyOffer(jtx::Account const& account, uint256 const& offerIndex);

json::Value
acceptSellOffer(jtx::Account const& account, uint256 const& offerIndex);

json::Value
brokerOffers(
    jtx::Account const& account,
    uint256 const& buyOfferIndex,
    uint256 const& sellOfferIndex);

class BrokerFee
{
private:
    STAmount const brokerFee_;
 
public:
    explicit BrokerFee(STAmount const fee) : brokerFee_(fee)
    {
    }
 
    void
    operator()(Env&, JTx& jtx) const;
};

json::Value
setMinter(jtx::Account const& account, jtx::Account const& minter);

json::Value
clearMinter(jtx::Account const& account);

json::Value
modify(jtx::Account const& account, uint256 const& nftokenID);
 
}  // namespace xrpl::test::jtx::token