token.h

#ifndef XRPL_TEST_JTX_NFT_H_INCLUDED
#define XRPL_TEST_JTX_NFT_H_INCLUDED
 
#include <test/jtx/Account.h>
#include <test/jtx/Env.h>
#include <test/jtx/owners.h>
 
#include <xrpl/basics/strHex.h>
 
#include <initializer_list>
 
namespace ripple {
namespace test {
namespace jtx {
 
namespace 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 token
 
}  // namespace jtx
 
}  // namespace test
}  // namespace ripple
 
#endif  // XRPL_TEST_JTX_NFT_H_INCLUDED