ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2026-04-29 15:37:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/tapanito/lending-fix-amendment' into a1q123456/support-lending-in-batch

Browse Source 
Signed-off-by: JCW <a1q123456@users.noreply.github.com>

# Conflicts:
#	src/test/app/Loan/Loan_test.cpp
This commit is contained in:
JCW
2026-03-24 16:11:06 +00:00
parent 945cfa3e51 d94232007f
commit cecf02be13
909 changed files with 77376 additions and 12955 deletions
Download Patch File Download Diff File Expand all files Collapse all files

155
include/xrpl/basics/Mutex.hpp Normal file
View File

@@ -0,0 +1,155 @@
/*
This file is part of clio: https://github.com/XRPLF/clio
Copyright (c) 2024, the clio developers.
Permission to use, copy, modify, and distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
*/
#pragma once
#include <mutex>
#include <type_traits>
namespace xrpl {
template <typename ProtectedDataType, typename MutexType>
class Mutex;
/**
* @brief A lock on a mutex that provides access to the protected data.
*
* @tparam ProtectedDataType data type to hold
* @tparam LockType type of lock
* @tparam MutexType type of mutex
*/
template <typename ProtectedDataType, template <typename...> typename LockType, typename MutexType>
class Lock
{
LockType<MutexType> lock_;
ProtectedDataType& data_;
public:
/** @cond */
ProtectedDataType const&
operator*() const
{
return data_;
}
ProtectedDataType&
operator*()
{
return data_;
}
ProtectedDataType const&
get() const
{
return data_;
}
ProtectedDataType&
get()
{
return data_;
}
ProtectedDataType const*
operator->() const
{
return &data_;
}
ProtectedDataType*
operator->()
{
return &data_;
}
operator LockType<MutexType>&() &
{
return lock_;
}
operator LockType<MutexType> const&() const&
{
return lock_;
}
/** @endcond */
private:
friend class Mutex<std::remove_const_t<ProtectedDataType>, MutexType>;
Lock(MutexType& mutex, ProtectedDataType& data) : lock_(mutex), data_(data)
{
}
};
/**
* @brief A container for data that is protected by a mutex. Inspired by Mutex in Rust.
*
* @tparam ProtectedDataType data type to hold
* @tparam MutexType type of mutex
*/
template <typename ProtectedDataType, typename MutexType = std::mutex>
class Mutex
{
mutable MutexType mutex_;
ProtectedDataType data_{};
public:
Mutex() = default;
/**
* @brief Construct a new Mutex object with the given data
*
* @param data The data to protect
*/
explicit Mutex(ProtectedDataType data) : data_(std::move(data))
{
}
/**
* @brief Make a new Mutex object with the given data
*
* @tparam Args The types of the arguments to forward to the constructor of the protected data
* @param args The arguments to forward to the constructor of the protected data
* @return The Mutex object that protects the given data
*/
template <typename... Args>
static Mutex
make(Args&&... args)
{
return Mutex{ProtectedDataType{std::forward<Args>(args)...}};
}
/**
* @brief Lock the mutex and get a lock object allowing access to the protected data
*
* @tparam LockType The type of lock to use
* @return A lock on the mutex and a reference to the protected data
*/
template <template <typename...> typename LockType = std::lock_guard>
Lock<ProtectedDataType const, LockType, MutexType>
lock() const
{
return {mutex_, data_};
}
/**
* @brief Lock the mutex and get a lock object allowing access to the protected data
*
* @tparam LockType The type of lock to use
* @return A lock on the mutex and a reference to the protected data
*/
template <template <typename...> typename LockType = std::lock_guard>
Lock<ProtectedDataType, LockType, MutexType>
lock()
{
return {mutex_, data_};
}
};
} // namespace xrpl

17
include/xrpl/basics/contract.h
View File

@@ -1,5 +1,6 @@
#pragma once
#include <xrpl/basics/sanitizers.h>
#include <xrpl/beast/type_name.h>
#include <exception>
@@ -23,16 +24,28 @@ LogThrow(std::string const& title);
When called from within a catch block, it will pass
control to the next matching exception handler, if any.
Otherwise, std::terminate will be called.
ASAN can't handle sudden jumps in control flow very well. This
function is marked as XRPL_NO_SANITIZE_ADDRESS to prevent it from
triggering false positives, since it throws.
*/
[[noreturn]] inline void
[[noreturn]] XRPL_NO_SANITIZE_ADDRESS inline void
Rethrow()
{
LogThrow("Re-throwing exception");
throw;
}
/*
Logs and throws an exception of type E.
ASAN can't handle sudden jumps in control flow very well. This
function is marked as XRPL_NO_SANITIZE_ADDRESS to prevent it from
triggering false positives, since it throws.
*/
template <class E, class... Args>
[[noreturn]] inline void
[[noreturn]] XRPL_NO_SANITIZE_ADDRESS inline void
Throw(Args&&... args)
{
static_assert(

29
include/xrpl/basics/safe_cast.h
View File

@@ -1,5 +1,7 @@
#pragma once
#include <xrpl/beast/utility/instrumentation.h>
#include <type_traits>
namespace xrpl {
@@ -70,4 +72,31 @@ unsafe_cast(Src s) noexcept
return unsafe_cast<Dest>(static_cast<std::underlying_type_t<Src>>(s));
}
template <class Dest, class Src>
requires std::is_pointer_v<Dest>
inline Dest
safe_downcast(Src* s) noexcept
{
#ifdef NDEBUG
return static_cast<Dest>(s); // NOLINT(cppcoreguidelines-pro-type-static-cast-downcast)
#else
auto* result = dynamic_cast<Dest>(s);
XRPL_ASSERT(result != nullptr, "xrpl::safe_downcast : pointer downcast is valid");
return result;
#endif
}
template <class Dest, class Src>
requires std::is_lvalue_reference_v<Dest>
inline Dest
safe_downcast(Src& s) noexcept
{
#ifndef NDEBUG
XRPL_ASSERT(
dynamic_cast<std::add_pointer_t<std::remove_reference_t<Dest>>>(&s) != nullptr,
"xrpl::safe_downcast : reference downcast is valid");
#endif
return static_cast<Dest>(s); // NOLINT(cppcoreguidelines-pro-type-static-cast-downcast)
}
} // namespace xrpl

13
include/xrpl/basics/sanitizers.h Normal file
View File

@@ -0,0 +1,13 @@
#pragma once
// Helper to disable ASan/HwASan for specific functions
/*
ASAN flags some false positives with sudden jumps in control flow, like
exceptions, or when encountering coroutine stack switches. This macro can be used to disable ASAN
intrumentation for specific functions.
*/
#if defined(__GNUC__) || defined(__clang__)
#define XRPL_NO_SANITIZE_ADDRESS __attribute__((no_sanitize("address", "hwaddress")))
#else
#define XRPL_NO_SANITIZE_ADDRESS
#endif

6
include/xrpl/beast/core/List.h
View File

@@ -43,8 +43,8 @@ private:
template <typename>
friend class ListIterator;
ListNode* m_next;
ListNode* m_prev;
ListNode* m_next = nullptr;
ListNode* m_prev = nullptr;
};
//------------------------------------------------------------------------------
@@ -567,7 +567,7 @@ private:
}
private:
size_type m_size;
size_type m_size = 0u;
Node m_head;
Node m_tail;
};

5
include/xrpl/beast/core/SemanticVersion.h
View File

@@ -1,6 +1,7 @@
#pragma once
#include <string>
#include <string_view>
#include <vector>
namespace beast {
@@ -26,14 +27,14 @@ public:
SemanticVersion();
SemanticVersion(std::string const& version);
SemanticVersion(std::string_view version);
/** Parse a semantic version string.
The parsing is as strict as possible.
@return `true` if the string was parsed.
*/
bool
parse(std::string const& input);
parse(std::string_view input);
/** Produce a string from semantic version components. */
std::string

10
include/xrpl/core/Coro.ipp
View File

@@ -1,7 +1,5 @@
#pragma once
#include <xrpl/basics/ByteUtilities.h>
namespace xrpl {
template <class F>
@@ -11,16 +9,18 @@ JobQueue::Coro::Coro(Coro_create_t, JobQueue& jq, JobType type, std::string cons
, name_(name)
, running_(false)
, coro_(
// Stack size of 1MB wasn't sufficient for deep calls. ASAN tests flagged the issue. Hence
// increasing the size to 1.5MB.
boost::context::protected_fixedsize_stack(1536 * 1024),
[this, fn = std::forward<F>(f)](
boost::coroutines::asymmetric_coroutine<void>::push_type& do_yield) {
boost::coroutines2::asymmetric_coroutine<void>::push_type& do_yield) {
yield_ = &do_yield;
yield();
fn(shared_from_this());
#ifndef NDEBUG
finished_ = true;
#endif
},
boost::coroutines::attributes(megabytes(1)))
})
{
}

7
include/xrpl/core/JobQueue.h
View File

@@ -7,7 +7,8 @@
#include <xrpl/core/detail/Workers.h>
#include <xrpl/json/json_value.h>
#include <boost/coroutine/all.hpp>
#include <boost/context/protected_fixedsize_stack.hpp>
#include <boost/coroutine2/all.hpp>
#include <set>
@@ -48,8 +49,8 @@ public:
std::mutex mutex_;
std::mutex mutex_run_;
std::condition_variable cv_;
boost::coroutines::asymmetric_coroutine<void>::pull_type coro_;
boost::coroutines::asymmetric_coroutine<void>::push_type* yield_;
boost::coroutines2::coroutine<void>::pull_type coro_;
boost::coroutines2::coroutine<void>::push_type* yield_;
#ifndef NDEBUG
bool finished_ = false;
#endif

13
include/xrpl/git/Git.h Normal file
View File

@@ -0,0 +1,13 @@
#pragma once
#include <string>
namespace xrpl::git {
std::string const&
getCommitHash();
std::string const&
getBuildBranch();
} // namespace xrpl::git

2
include/xrpl/json/json_value.h
View File

@@ -421,7 +421,7 @@ private:
ObjectValues* map_{nullptr};
} value_;
ValueType type_ : 8;
int allocated_ : 1; // Notes: if declared as bool, bitfield is useless.
int allocated_ : 1 {}; // Notes: if declared as bool, bitfield is useless.
};
inline Value

4
include/xrpl/json/json_writer.h
View File

@@ -108,7 +108,7 @@ private:
std::string indentString_;
int rightMargin_;
int indentSize_;
bool addChildValues_;
bool addChildValues_{};
};
/** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a
@@ -175,7 +175,7 @@ private:
std::string indentString_;
int rightMargin_;
std::string indentation_;
bool addChildValues_;
bool addChildValues_{};
};
std::string

43
include/xrpl/ledger/Credit.h
View File

@@ -1,43 +0,0 @@
#pragma once
#include <xrpl/ledger/View.h>
#include <xrpl/protocol/IOUAmount.h>
#include <xrpl/protocol/STAmount.h>
namespace xrpl {
/** Calculate the maximum amount of IOUs that an account can hold
@param ledger the ledger to check against.
@param account the account of interest.
@param issuer the issuer of the IOU.
@param currency the IOU to check.
@return The maximum amount that can be held.
*/
/** @{ */
STAmount
creditLimit(
ReadView const& view,
AccountID const& account,
AccountID const& issuer,
Currency const& currency);
IOUAmount
creditLimit2(ReadView const& v, AccountID const& acc, AccountID const& iss, Currency const& cur);
/** @} */
/** Returns the amount of IOUs issued by issuer that are held by an account
@param ledger the ledger to check against.
@param account the account of interest.
@param issuer the issuer of the IOU.
@param currency the IOU to check.
*/
/** @{ */
STAmount
creditBalance(
ReadView const& view,
AccountID const& account,
AccountID const& issuer,
Currency const& currency);
/** @} */
} // namespace xrpl

881
include/xrpl/ledger/View.h
View File

@@ -2,26 +2,23 @@
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/ledger/ApplyView.h>
#include <xrpl/ledger/OpenView.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/protocol/Asset.h>
#include <xrpl/protocol/Indexes.h>
#include <xrpl/protocol/MPTIssue.h>
#include <xrpl/protocol/Protocol.h>
#include <xrpl/protocol/Rate.h>
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STObject.h>
#include <xrpl/protocol/Serializer.h>
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/TER.h>
#include <cstdint>
#include <functional>
#include <initializer_list>
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <utility>
namespace xrpl {
enum class WaiveTransferFee : bool { No = false, Yes };
enum class SkipEntry : bool { No = false, Yes };
//------------------------------------------------------------------------------
@@ -54,24 +51,6 @@ enum class SkipEntry : bool { No = false, Yes };
[[nodiscard]] bool
hasExpired(ReadView const& view, std::optional<std::uint32_t> const& exp);
/** Controls the treatment of frozen account balances */
enum FreezeHandling { fhIGNORE_FREEZE, fhZERO_IF_FROZEN };
/** Controls the treatment of unauthorized MPT balances */
enum AuthHandling { ahIGNORE_AUTH, ahZERO_IF_UNAUTHORIZED };
/** Controls whether to include the account's full spendable balance */
enum SpendableHandling { shSIMPLE_BALANCE, shFULL_BALANCE };
[[nodiscard]] bool
isGlobalFrozen(ReadView const& view, AccountID const& issuer);
[[nodiscard]] bool
isGlobalFrozen(ReadView const& view, MPTIssue const& mptIssue);
[[nodiscard]] bool
isGlobalFrozen(ReadView const& view, Asset const& asset);
// Note, depth parameter is used to limit the recursion depth
[[nodiscard]] bool
isVaultPseudoAccountFrozen(
@@ -80,175 +59,6 @@ isVaultPseudoAccountFrozen(
MPTIssue const& mptShare,
int depth);
[[nodiscard]] bool
isIndividualFrozen(
ReadView const& view,
AccountID const& account,
Currency const& currency,
AccountID const& issuer);
[[nodiscard]] inline bool
isIndividualFrozen(ReadView const& view, AccountID const& account, Issue const& issue)
{
return isIndividualFrozen(view, account, issue.currency, issue.account);
}
[[nodiscard]] bool
isIndividualFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptIssue);
[[nodiscard]] inline bool
isIndividualFrozen(ReadView const& view, AccountID const& account, Asset const& asset)
{
return std::visit(
[&](auto const& issue) { return isIndividualFrozen(view, account, issue); }, asset.value());
}
[[nodiscard]] bool
isFrozen(
ReadView const& view,
AccountID const& account,
Currency const& currency,
AccountID const& issuer);
[[nodiscard]] inline bool
isFrozen(ReadView const& view, AccountID const& account, Issue const& issue, int = 0 /*ignored*/)
{
return isFrozen(view, account, issue.currency, issue.account);
}
[[nodiscard]] bool
isFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptIssue, int depth = 0);
/**
* isFrozen check is recursive for MPT shares in a vault, descending to
* assets in the vault, up to maxAssetCheckDepth recursion depth. This is
* purely defensive, as we currently do not allow such vaults to be created.
*/
[[nodiscard]] inline bool
isFrozen(ReadView const& view, AccountID const& account, Asset const& asset, int depth = 0)
{
return std::visit(
[&](auto const& issue) { return isFrozen(view, account, issue, depth); }, asset.value());
}
[[nodiscard]] inline TER
checkFrozen(ReadView const& view, AccountID const& account, Issue const& issue)
{
return isFrozen(view, account, issue) ? (TER)tecFROZEN : (TER)tesSUCCESS;
}
[[nodiscard]] inline TER
checkFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptIssue)
{
return isFrozen(view, account, mptIssue) ? (TER)tecLOCKED : (TER)tesSUCCESS;
}
[[nodiscard]] inline TER
checkFrozen(ReadView const& view, AccountID const& account, Asset const& asset)
{
return std::visit(
[&](auto const& issue) { return checkFrozen(view, account, issue); }, asset.value());
}
[[nodiscard]] bool
isAnyFrozen(
ReadView const& view,
std::initializer_list<AccountID> const& accounts,
MPTIssue const& mptIssue,
int depth = 0);
[[nodiscard]] inline bool
isAnyFrozen(
ReadView const& view,
std::initializer_list<AccountID> const& accounts,
Issue const& issue)
{
for (auto const& account : accounts)
{
if (isFrozen(view, account, issue.currency, issue.account))
return true;
}
return false;
}
[[nodiscard]] inline bool
isAnyFrozen(
ReadView const& view,
std::initializer_list<AccountID> const& accounts,
Asset const& asset,
int depth = 0)
{
return std::visit(
[&]<ValidIssueType TIss>(TIss const& issue) {
if constexpr (std::is_same_v<TIss, Issue>)
return isAnyFrozen(view, accounts, issue);
else
return isAnyFrozen(view, accounts, issue, depth);
},
asset.value());
}
[[nodiscard]] bool
isDeepFrozen(
ReadView const& view,
AccountID const& account,
Currency const& currency,
AccountID const& issuer);
[[nodiscard]] inline bool
isDeepFrozen(
ReadView const& view,
AccountID const& account,
Issue const& issue,
int = 0 /*ignored*/)
{
return isDeepFrozen(view, account, issue.currency, issue.account);
}
[[nodiscard]] inline bool
isDeepFrozen(
ReadView const& view,
AccountID const& account,
MPTIssue const& mptIssue,
int depth = 0)
{
// Unlike IOUs, frozen / locked MPTs are not allowed to send or receive
// funds, so checking "deep frozen" is the same as checking "frozen".
return isFrozen(view, account, mptIssue, depth);
}
/**
* isFrozen check is recursive for MPT shares in a vault, descending to
* assets in the vault, up to maxAssetCheckDepth recursion depth. This is
* purely defensive, as we currently do not allow such vaults to be created.
*/
[[nodiscard]] inline bool
isDeepFrozen(ReadView const& view, AccountID const& account, Asset const& asset, int depth = 0)
{
return std::visit(
[&](auto const& issue) { return isDeepFrozen(view, account, issue, depth); },
asset.value());
}
[[nodiscard]] inline TER
checkDeepFrozen(ReadView const& view, AccountID const& account, Issue const& issue)
{
return isDeepFrozen(view, account, issue) ? (TER)tecFROZEN : (TER)tesSUCCESS;
}
[[nodiscard]] inline TER
checkDeepFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptIssue)
{
return isDeepFrozen(view, account, mptIssue) ? (TER)tecLOCKED : (TER)tesSUCCESS;
}
[[nodiscard]] inline TER
checkDeepFrozen(ReadView const& view, AccountID const& account, Asset const& asset)
{
return std::visit(
[&](auto const& issue) { return checkDeepFrozen(view, account, issue); }, asset.value());
}
[[nodiscard]] bool
isLPTokenFrozen(
ReadView const& view,
@@ -256,159 +66,6 @@ isLPTokenFrozen(
Issue const& asset,
Issue const& asset2);
// Returns the amount an account can spend.
//
// If shSIMPLE_BALANCE is specified, this is the amount the account can spend
// without going into debt.
//
// If shFULL_BALANCE is specified, this is the amount the account can spend
// total. Specifically:
// * The account can go into debt if using a trust line, and the other side has
// a non-zero limit.
// * If the account is the asset issuer the limit is defined by the asset /
// issuance.
//
// <-- saAmount: amount of currency held by account. May be negative.
[[nodiscard]] STAmount
accountHolds(
ReadView const& view,
AccountID const& account,
Currency const& currency,
AccountID const& issuer,
FreezeHandling zeroIfFrozen,
beast::Journal j,
SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
[[nodiscard]] STAmount
accountHolds(
ReadView const& view,
AccountID const& account,
Issue const& issue,
FreezeHandling zeroIfFrozen,
beast::Journal j,
SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
[[nodiscard]] STAmount
accountHolds(
ReadView const& view,
AccountID const& account,
MPTIssue const& mptIssue,
FreezeHandling zeroIfFrozen,
AuthHandling zeroIfUnauthorized,
beast::Journal j,
SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
[[nodiscard]] STAmount
accountHolds(
ReadView const& view,
AccountID const& account,
Asset const& asset,
FreezeHandling zeroIfFrozen,
AuthHandling zeroIfUnauthorized,
beast::Journal j,
SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
// Returns the amount an account can spend of the currency type saDefault, or
// returns saDefault if this account is the issuer of the currency in
// question. Should be used in favor of accountHolds when questioning how much
// an account can spend while also allowing currency issuers to spend
// unlimited amounts of their own currency (since they can always issue more).
[[nodiscard]] STAmount
accountFunds(
ReadView const& view,
AccountID const& id,
STAmount const& saDefault,
FreezeHandling freezeHandling,
beast::Journal j);
// Return the account's liquid (not reserved) XRP. Generally prefer
// calling accountHolds() over this interface. However, this interface
// allows the caller to temporarily adjust the owner count should that be
// necessary.
//
// @param ownerCountAdj positive to add to count, negative to reduce count.
[[nodiscard]] XRPAmount
xrpLiquid(ReadView const& view, AccountID const& id, std::int32_t ownerCountAdj, beast::Journal j);
/** Iterate all items in the given directory. */
void
forEachItem(
ReadView const& view,
Keylet const& root,
std::function<void(std::shared_ptr<SLE const> const&)> const& f);
/** Iterate all items after an item in the given directory.
@param after The key of the item to start after
@param hint The directory page containing `after`
@param limit The maximum number of items to return
@return `false` if the iteration failed
*/
bool
forEachItemAfter(
ReadView const& view,
Keylet const& root,
uint256 const& after,
std::uint64_t const hint,
unsigned int limit,
std::function<bool(std::shared_ptr<SLE const> const&)> const& f);
/** Iterate all items in an account's owner directory. */
inline void
forEachItem(
ReadView const& view,
AccountID const& id,
std::function<void(std::shared_ptr<SLE const> const&)> const& f)
{
return forEachItem(view, keylet::ownerDir(id), f);
}
/** Iterate all items after an item in an owner directory.
@param after The key of the item to start after
@param hint The directory page containing `after`
@param limit The maximum number of items to return
@return `false` if the iteration failed
*/
inline bool
forEachItemAfter(
ReadView const& view,
AccountID const& id,
uint256 const& after,
std::uint64_t const hint,
unsigned int limit,
std::function<bool(std::shared_ptr<SLE const> const&)> const& f)
{
return forEachItemAfter(view, keylet::ownerDir(id), after, hint, limit, f);
}
/** Returns IOU issuer transfer fee as Rate. Rate specifies
* the fee as fractions of 1 billion. For example, 1% transfer rate
* is represented as 1,010,000,000.
* @param issuer The IOU issuer
*/
[[nodiscard]] Rate
transferRate(ReadView const& view, AccountID const& issuer);
/** Returns MPT transfer fee as Rate. Rate specifies
* the fee as fractions of 1 billion. For example, 1% transfer rate
* is represented as 1,010,000,000.
* @param issuanceID MPTokenIssuanceID of MPTTokenIssuance object
*/
[[nodiscard]] Rate
transferRate(ReadView const& view, MPTID const& issuanceID);
/** Returns the transfer fee as Rate based on the type of token
* @param view The ledger view
* @param amount The amount to transfer
*/
[[nodiscard]] Rate
transferRate(ReadView const& view, STAmount const& amount);
/** Returns `true` if the directory is empty
@param key The key of the directory
*/
[[nodiscard]] bool
dirIsEmpty(ReadView const& view, Keylet const& k);
// Return the list of enabled amendments
[[nodiscard]] std::set<uint256>
getEnabledAmendments(ReadView const& view);
@@ -474,81 +131,6 @@ areCompatible(
//
//------------------------------------------------------------------------------
/** Adjust the owner count up or down. */
void
adjustOwnerCount(
ApplyView& view,
std::shared_ptr<SLE> const& sle,
std::int32_t amount,
beast::Journal j);
/** @{ */
/** Returns the first entry in the directory, advancing the index
@deprecated These are legacy function that are considered deprecated
and will soon be replaced with an iterator-based model
that is easier to use. You should not use them in new code.
@param view The view against which to operate
@param root The root (i.e. first page) of the directory to iterate
@param page The current page
@param index The index inside the current page
@param entry The entry at the current index
@return true if the directory isn't empty; false otherwise
*/
bool
cdirFirst(
ReadView const& view,
uint256 const& root,
std::shared_ptr<SLE const>& page,
unsigned int& index,
uint256& entry);
bool
dirFirst(
ApplyView& view,
uint256 const& root,
std::shared_ptr<SLE>& page,
unsigned int& index,
uint256& entry);
/** @} */
/** @{ */
/** Returns the next entry in the directory, advancing the index
@deprecated These are legacy function that are considered deprecated
and will soon be replaced with an iterator-based model
that is easier to use. You should not use them in new code.
@param view The view against which to operate
@param root The root (i.e. first page) of the directory to iterate
@param page The current page
@param index The index inside the current page
@param entry The entry at the current index
@return true if the directory isn't empty; false otherwise
*/
bool
cdirNext(
ReadView const& view,
uint256 const& root,
std::shared_ptr<SLE const>& page,
unsigned int& index,
uint256& entry);
bool
dirNext(
ApplyView& view,
uint256 const& root,
std::shared_ptr<SLE>& page,
unsigned int& index,
uint256& entry);
/** @} */
[[nodiscard]] std::function<void(SLE::ref)>
describeOwnerDir(AccountID const& account);
[[nodiscard]] TER
dirLink(
ApplyView& view,
@@ -556,63 +138,6 @@ dirLink(
std::shared_ptr<SLE>& object,
SF_UINT64 const& node = sfOwnerNode);
AccountID
pseudoAccountAddress(ReadView const& view, uint256 const& pseudoOwnerKey);
/**
*
* Create pseudo-account, storing pseudoOwnerKey into ownerField.
*
* The list of valid ownerField is maintained in View.cpp and the caller to
* this function must perform necessary amendment check(s) before using a
* field. The amendment check is **not** performed in createPseudoAccount.
*/
[[nodiscard]] Expected<std::shared_ptr<SLE>, TER>
createPseudoAccount(ApplyView& view, uint256 const& pseudoOwnerKey, SField const& ownerField);
// Returns true if and only if sleAcct is a pseudo-account or specific
// pseudo-accounts in pseudoFieldFilter.
//
// Returns false if sleAcct is
// * NOT a pseudo-account OR
// * NOT a ltACCOUNT_ROOT OR
// * null pointer
[[nodiscard]] bool
isPseudoAccount(
std::shared_ptr<SLE const> sleAcct,
std::set<SField const*> const& pseudoFieldFilter = {});
// Returns the list of fields that define an ACCOUNT_ROOT as a pseudo-account if
// set
// Pseudo-account designator fields MUST be maintained by including the
// SField::sMD_PseudoAccount flag in the SField definition. (Don't forget to
// "| SField::sMD_Default"!) The fields do NOT need to be amendment-gated,
// since a non-active amendment will not set any field, by definition.
// Specific properties of a pseudo-account are NOT checked here, that's what
// InvariantCheck is for.
[[nodiscard]] std::vector<SField const*> const&
getPseudoAccountFields();
[[nodiscard]] inline bool
isPseudoAccount(
ReadView const& view,
AccountID const& accountId,
std::set<SField const*> const& pseudoFieldFilter = {})
{
return isPseudoAccount(view.read(keylet::account(accountId)), pseudoFieldFilter);
}
[[nodiscard]] TER
canAddHolding(ReadView const& view, Asset const& asset);
/** Validates that the destination SLE and tag are valid
- Checks that the SLE is not null.
- If the SLE requires a destination tag, checks that there is a tag.
*/
[[nodiscard]] TER
checkDestinationAndTag(SLE::const_ref toSle, bool hasDestinationTag);
/** Checks that can withdraw funds from an object to itself or a destination.
*
* The receiver may be either the submitting account (sfAccount) or a different
@@ -686,351 +211,6 @@ doWithdraw(
STAmount const& amount,
beast::Journal j);
/// Any transactors that call addEmptyHolding() in doApply must call
/// canAddHolding() in preflight with the same View and Asset
[[nodiscard]] TER
addEmptyHolding(
ApplyView& view,
AccountID const& accountID,
XRPAmount priorBalance,
Issue const& issue,
beast::Journal journal);
[[nodiscard]] TER
addEmptyHolding(
ApplyView& view,
AccountID const& accountID,
XRPAmount priorBalance,
MPTIssue const& mptIssue,
beast::Journal journal);
[[nodiscard]] inline TER
addEmptyHolding(
ApplyView& view,
AccountID const& accountID,
XRPAmount priorBalance,
Asset const& asset,
beast::Journal journal)
{
return std::visit(
[&]<ValidIssueType TIss>(TIss const& issue) -> TER {
return addEmptyHolding(view, accountID, priorBalance, issue, journal);
},
asset.value());
}
[[nodiscard]] TER
authorizeMPToken(
ApplyView& view,
XRPAmount const& priorBalance,
MPTID const& mptIssuanceID,
AccountID const& account,
beast::Journal journal,
std::uint32_t flags = 0,
std::optional<AccountID> holderID = std::nullopt);
// VFALCO NOTE Both STAmount parameters should just
// be "Amount", a unit-less number.
//
/** Create a trust line
This can set an initial balance.
*/
[[nodiscard]] TER
trustCreate(
ApplyView& view,
bool const bSrcHigh,
AccountID const& uSrcAccountID,
AccountID const& uDstAccountID,
uint256 const& uIndex, // --> ripple state entry
SLE::ref sleAccount, // --> the account being set.
bool const bAuth, // --> authorize account.
bool const bNoRipple, // --> others cannot ripple through
bool const bFreeze, // --> funds cannot leave
bool bDeepFreeze, // --> can neither receive nor send funds
STAmount const& saBalance, // --> balance of account being set.
// Issuer should be noAccount()
STAmount const& saLimit, // --> limit for account being set.
// Issuer should be the account being set.
std::uint32_t uSrcQualityIn,
std::uint32_t uSrcQualityOut,
beast::Journal j);
[[nodiscard]] TER
removeEmptyHolding(
ApplyView& view,
AccountID const& accountID,
Issue const& issue,
beast::Journal journal);
[[nodiscard]] TER
removeEmptyHolding(
ApplyView& view,
AccountID const& accountID,
MPTIssue const& mptIssue,
beast::Journal journal);
[[nodiscard]] inline TER
removeEmptyHolding(
ApplyView& view,
AccountID const& accountID,
Asset const& asset,
beast::Journal journal)
{
return std::visit(
[&]<ValidIssueType TIss>(TIss const& issue) -> TER {
return removeEmptyHolding(view, accountID, issue, journal);
},
asset.value());
}
[[nodiscard]] TER
trustDelete(
ApplyView& view,
std::shared_ptr<SLE> const& sleRippleState,
AccountID const& uLowAccountID,
AccountID const& uHighAccountID,
beast::Journal j);
/** Delete an offer.
Requirements:
The passed `sle` be obtained from a prior
call to view.peek()
*/
// [[nodiscard]] // nodiscard commented out so Flow, BookTip and others compile.
TER
offerDelete(ApplyView& view, std::shared_ptr<SLE> const& sle, beast::Journal j);
//------------------------------------------------------------------------------
//
// Money Transfers
//
// Direct send w/o fees:
// - Redeeming IOUs and/or sending sender's own IOUs.
// - Create trust line of needed.
// --> bCheckIssuer : normally require issuer to be involved.
// [[nodiscard]] // nodiscard commented out so DirectStep.cpp compiles.
/** Calls static rippleCreditIOU if saAmount represents Issue.
* Calls static rippleCreditMPT if saAmount represents MPTIssue.
*/
TER
rippleCredit(
ApplyView& view,
AccountID const& uSenderID,
AccountID const& uReceiverID,
STAmount const& saAmount,
bool bCheckIssuer,
beast::Journal j);
TER
rippleLockEscrowMPT(
ApplyView& view,
AccountID const& uGrantorID,
STAmount const& saAmount,
beast::Journal j);
TER
rippleUnlockEscrowMPT(
ApplyView& view,
AccountID const& uGrantorID,
AccountID const& uGranteeID,
STAmount const& netAmount,
STAmount const& grossAmount,
beast::Journal j);
/** Calls static accountSendIOU if saAmount represents Issue.
* Calls static accountSendMPT if saAmount represents MPTIssue.
*/
[[nodiscard]] TER
accountSend(
ApplyView& view,
AccountID const& from,
AccountID const& to,
STAmount const& saAmount,
beast::Journal j,
WaiveTransferFee waiveFee = WaiveTransferFee::No);
using MultiplePaymentDestinations = std::vector<std::pair<AccountID, Number>>;
/** Like accountSend, except one account is sending multiple payments (with the
* same asset!) simultaneously
*
* Calls static accountSendMultiIOU if saAmount represents Issue.
* Calls static accountSendMultiMPT if saAmount represents MPTIssue.
*/
[[nodiscard]] TER
accountSendMulti(
ApplyView& view,
AccountID const& senderID,
Asset const& asset,
MultiplePaymentDestinations const& receivers,
beast::Journal j,
WaiveTransferFee waiveFee = WaiveTransferFee::No);
[[nodiscard]] TER
issueIOU(
ApplyView& view,
AccountID const& account,
STAmount const& amount,
Issue const& issue,
beast::Journal j);
[[nodiscard]] TER
redeemIOU(
ApplyView& view,
AccountID const& account,
STAmount const& amount,
Issue const& issue,
beast::Journal j);
[[nodiscard]] TER
transferXRP(
ApplyView& view,
AccountID const& from,
AccountID const& to,
STAmount const& amount,
beast::Journal j);
/* Check if MPToken (for MPT) or trust line (for IOU) exists:
* - StrongAuth - before checking if authorization is required
* - WeakAuth
* for MPT - after checking lsfMPTRequireAuth flag
* for IOU - do not check if trust line exists
* - Legacy
* for MPT - before checking lsfMPTRequireAuth flag i.e. same as StrongAuth
* for IOU - do not check if trust line exists i.e. same as WeakAuth
*/
enum class AuthType { StrongAuth, WeakAuth, Legacy };
/** Check if the account lacks required authorization.
*
* Return tecNO_AUTH or tecNO_LINE if it does
* and tesSUCCESS otherwise.
*
* If StrongAuth then return tecNO_LINE if the RippleState doesn't exist. Return
* tecNO_AUTH if lsfRequireAuth is set on the issuer's AccountRoot, and the
* RippleState does exist, and the RippleState is not authorized.
*
* If WeakAuth then return tecNO_AUTH if lsfRequireAuth is set, and the
* RippleState exists, and is not authorized. Return tecNO_LINE if
* lsfRequireAuth is set and the RippleState doesn't exist. Consequently, if
* WeakAuth and lsfRequireAuth is *not* set, this function will return
* tesSUCCESS even if RippleState does *not* exist.
*
* The default "Legacy" auth type is equivalent to WeakAuth.
*/
[[nodiscard]] TER
requireAuth(
ReadView const& view,
Issue const& issue,
AccountID const& account,
AuthType authType = AuthType::Legacy);
/** Check if the account lacks required authorization.
*
* This will also check for expired credentials. If it is called directly
* from preclaim, the user should convert result tecEXPIRED to tesSUCCESS and
* proceed to also check permissions with enforceMPTokenAuthorization inside
* doApply. This will ensure that any expired credentials are deleted.
*
* requireAuth check is recursive for MPT shares in a vault, descending to
* assets in the vault, up to maxAssetCheckDepth recursion depth. This is
* purely defensive, as we currently do not allow such vaults to be created.
*
* If StrongAuth then return tecNO_AUTH if MPToken doesn't exist or
* lsfMPTRequireAuth is set and MPToken is not authorized. Vault and LoanBroker
* pseudo-accounts are implicitly authorized.
*
* If WeakAuth then return tecNO_AUTH if lsfMPTRequireAuth is set and MPToken
* doesn't exist or is not authorized (explicitly or via credentials, if
* DomainID is set in MPTokenIssuance). Consequently, if WeakAuth and
* lsfMPTRequireAuth is *not* set, this function will return true even if
* MPToken does *not* exist.
*
* The default "Legacy" auth type is equivalent to StrongAuth.
*/
[[nodiscard]] TER
requireAuth(
ReadView const& view,
MPTIssue const& mptIssue,
AccountID const& account,
AuthType authType = AuthType::Legacy,
int depth = 0);
[[nodiscard]] TER inline requireAuth(
ReadView const& view,
Asset const& asset,
AccountID const& account,
AuthType authType = AuthType::Legacy)
{
return std::visit(
[&]<ValidIssueType TIss>(TIss const& issue_) {
return requireAuth(view, issue_, account, authType);
},
asset.value());
}
/** Enforce account has MPToken to match its authorization.
*
* Called from doApply - it will check for expired (and delete if found any)
* credentials matching DomainID set in MPTokenIssuance. Must be called if
* requireAuth(...MPTIssue...) returned tesSUCCESS or tecEXPIRED in preclaim,
* which implies that preclaim should replace `tecEXPIRED` with `tesSUCCESS`
* in order for the transactor to proceed to doApply.
*
* This function will create MPToken (if needed) on the basis of any
* non-expired credentials and will delete any expired credentials, indirectly
* via verifyValidDomain, as per DomainID (if set in MPTokenIssuance).
*
* The caller does NOT need to ensure that DomainID is actually set - this
* function handles gracefully both cases when DomainID is set and when not.
*
* The caller does NOT need to look for existing MPToken to match
* mptIssue/account - this function checks lsfMPTAuthorized of an existing
* MPToken iff DomainID is not set.
*
* Do not use for accounts which hold implied permission e.g. object owners or
* if MPTokenIssuance does not require authorization. In both cases use
* MPTokenAuthorize::authorize if MPToken does not yet exist.
*/
[[nodiscard]] TER
enforceMPTokenAuthorization(
ApplyView& view,
MPTID const& mptIssuanceID,
AccountID const& account,
XRPAmount const& priorBalance,
beast::Journal j);
/** Check if the destination account is allowed
* to receive MPT. Return tecNO_AUTH if it doesn't
* and tesSUCCESS otherwise.
*/
[[nodiscard]] TER
canTransfer(
ReadView const& view,
MPTIssue const& mptIssue,
AccountID const& from,
AccountID const& to);
[[nodiscard]] TER
canTransfer(ReadView const& view, Issue const& issue, AccountID const& from, AccountID const& to);
[[nodiscard]] TER inline canTransfer(
ReadView const& view,
Asset const& asset,
AccountID const& from,
AccountID const& to)
{
return std::visit(
[&]<ValidIssueType TIss>(TIss const& issue) -> TER {
return canTransfer(view, issue, from, to);
},
asset.value());
}
/** Deleter function prototype. Returns the status of the entry deletion
* (if should not be skipped) and if the entry should be skipped. The status
* is always tesSUCCESS if the entry should be skipped.
@@ -1052,57 +232,6 @@ cleanupOnAccountDelete(
beast::Journal j,
std::optional<std::uint16_t> maxNodesToDelete = std::nullopt);
/** Delete trustline to AMM. The passed `sle` must be obtained from a prior
* call to view.peek(). Fail if neither side of the trustline is AMM or
* if ammAccountID is seated and is not one of the trustline's side.
*/
[[nodiscard]] TER
deleteAMMTrustLine(
ApplyView& view,
std::shared_ptr<SLE> sleState,
std::optional<AccountID> const& ammAccountID,
beast::Journal j);
// From the perspective of a vault, return the number of shares to give the
// depositor when they deposit a fixed amount of assets. Since shares are MPT
// this number is integral and always truncated in this calculation.
[[nodiscard]] std::optional<STAmount>
assetsToSharesDeposit(
std::shared_ptr<SLE const> const& vault,
std::shared_ptr<SLE const> const& issuance,
STAmount const& assets);
// From the perspective of a vault, return the number of assets to take from
// depositor when they receive a fixed amount of shares. Note, since shares are
// MPT, they are always an integral number.
[[nodiscard]] std::optional<STAmount>
sharesToAssetsDeposit(
std::shared_ptr<SLE const> const& vault,
std::shared_ptr<SLE const> const& issuance,
STAmount const& shares);
enum class TruncateShares : bool { no = false, yes = true };
// From the perspective of a vault, return the number of shares to demand from
// the depositor when they ask to withdraw a fixed amount of assets. Since
// shares are MPT this number is integral, and it will be rounded to nearest
// unless explicitly requested to be truncated instead.
[[nodiscard]] std::optional<STAmount>
assetsToSharesWithdraw(
std::shared_ptr<SLE const> const& vault,
std::shared_ptr<SLE const> const& issuance,
STAmount const& assets,
TruncateShares truncate = TruncateShares::no);
// From the perspective of a vault, return the number of assets to give the
// depositor when they redeem a fixed amount of shares. Note, since shares are
// MPT, they are always an integral number.
[[nodiscard]] std::optional<STAmount>
sharesToAssetsWithdraw(
std::shared_ptr<SLE const> const& vault,
std::shared_ptr<SLE const> const& issuance,
STAmount const& shares);
/** Has the specified time passed?
@param now the current time

112
include/xrpl/ledger/helpers/AccountRootHelpers.h Normal file
View File

@@ -0,0 +1,112 @@
#pragma once
#include <xrpl/basics/Expected.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/ledger/ApplyView.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/protocol/Indexes.h>
#include <xrpl/protocol/Rate.h>
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/TER.h>
#include <memory>
#include <set>
#include <vector>
namespace xrpl {
/** Check if the issuer has the global freeze flag set.
@param issuer The account to check
@return true if the account has global freeze set
*/
[[nodiscard]] bool
isGlobalFrozen(ReadView const& view, AccountID const& issuer);
// Calculate liquid XRP balance for an account.
// This function may be used to calculate the amount of XRP that
// the holder is able to freely spend. It subtracts reserve requirements.
//
// ownerCountAdj adjusts the owner count in case the caller calculates
// before ledger entries are added or removed. Positive to add, negative
// to subtract.
//
// @param ownerCountAdj positive to add to count, negative to reduce count.
[[nodiscard]] XRPAmount
xrpLiquid(ReadView const& view, AccountID const& id, std::int32_t ownerCountAdj, beast::Journal j);
/** Adjust the owner count up or down. */
void
adjustOwnerCount(
ApplyView& view,
std::shared_ptr<SLE> const& sle,
std::int32_t amount,
beast::Journal j);
/** Returns IOU issuer transfer fee as Rate. Rate specifies
* the fee as fractions of 1 billion. For example, 1% transfer rate
* is represented as 1,010,000,000.
* @param issuer The IOU issuer
*/
[[nodiscard]] Rate
transferRate(ReadView const& view, AccountID const& issuer);
/** Generate a pseudo-account address from a pseudo owner key.
@param pseudoOwnerKey The key to generate the address from
@return The generated account ID
*/
AccountID
pseudoAccountAddress(ReadView const& view, uint256 const& pseudoOwnerKey);
/** Returns the list of fields that define an ACCOUNT_ROOT as a pseudo-account
if set.
The list is constructed during initialization and is const after that.
Pseudo-account designator fields MUST be maintained by including the
SField::sMD_PseudoAccount flag in the SField definition.
*/
[[nodiscard]] std::vector<SField const*> const&
getPseudoAccountFields();
/** Returns true if and only if sleAcct is a pseudo-account or specific
pseudo-accounts in pseudoFieldFilter.
Returns false if sleAcct is:
- NOT a pseudo-account OR
- NOT a ltACCOUNT_ROOT OR
- null pointer
*/
[[nodiscard]] bool
isPseudoAccount(
std::shared_ptr<SLE const> sleAcct,
std::set<SField const*> const& pseudoFieldFilter = {});
/** Convenience overload that reads the account from the view. */
[[nodiscard]] inline bool
isPseudoAccount(
ReadView const& view,
AccountID const& accountId,
std::set<SField const*> const& pseudoFieldFilter = {})
{
return isPseudoAccount(view.read(keylet::account(accountId)), pseudoFieldFilter);
}
/**
* Create pseudo-account, storing pseudoOwnerKey into ownerField.
*
* The list of valid ownerField is maintained in AccountRootHelpers.cpp and
* the caller to this function must perform necessary amendment check(s)
* before using a field. The amendment check is **not** performed in
* createPseudoAccount.
*/
[[nodiscard]] Expected<std::shared_ptr<SLE>, TER>
createPseudoAccount(ApplyView& view, uint256 const& pseudoOwnerKey, SField const& ownerField);
/** Checks the destination and tag.
- Checks that the SLE is not null.
- If the SLE requires a destination tag, checks that there is a tag.
*/
[[nodiscard]] TER
checkDestinationAndTag(SLE::const_ref toSle, bool hasDestinationTag);
} // namespace xrpl

4
include/xrpl/ledger/CredentialHelpers.h → include/xrpl/ledger/helpers/CredentialHelpers.h
View File

@@ -49,7 +49,7 @@ validDomain(ReadView const& view, uint256 domainID, AccountID const& subject);
// This function is only called when we about to return tecNO_PERMISSION
// because all the checks for the DepositPreauth authorization failed.
TER
authorizedDepositPreauth(ApplyView const& view, STVector256 const& ctx, AccountID const& dst);
authorizedDepositPreauth(ReadView const& view, STVector256 const& ctx, AccountID const& dst);
// Sort credentials array, return empty set if there are duplicates
std::set<std::pair<AccountID, Slice>>
@@ -74,7 +74,7 @@ verifyDepositPreauth(
ApplyView& view,
AccountID const& src,
AccountID const& dst,
std::shared_ptr<SLE> const& sleDst,
std::shared_ptr<SLE const> const& sleDst,
beast::Journal j);
} // namespace xrpl

223
include/xrpl/ledger/helpers/DirectoryHelpers.h Normal file
View File

@@ -0,0 +1,223 @@
#pragma once
#include <xrpl/beast/utility/instrumentation.h>
#include <xrpl/ledger/ApplyView.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/protocol/Indexes.h>
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/TER.h>
#include <functional>
#include <memory>
#include <type_traits>
namespace xrpl {
namespace detail {
template <
class V,
class N,
class = std::enable_if_t<
std::is_same_v<std::remove_cv_t<N>, SLE> && std::is_base_of_v<ReadView, V>>>
bool
internalDirNext(
V& view,
uint256 const& root,
std::shared_ptr<N>& page,
unsigned int& index,
uint256& entry)
{
auto const& svIndexes = page->getFieldV256(sfIndexes);
XRPL_ASSERT(index <= svIndexes.size(), "xrpl::detail::internalDirNext : index inside range");
if (index >= svIndexes.size())
{
auto const next = page->getFieldU64(sfIndexNext);
if (!next)
{
entry.zero();
return false;
}
if constexpr (std::is_const_v<N>)
{
page = view.read(keylet::page(root, next));
}
else
{
page = view.peek(keylet::page(root, next));
}
XRPL_ASSERT(page, "xrpl::detail::internalDirNext : non-null root");
if (!page)
return false;
index = 0;
return internalDirNext(view, root, page, index, entry);
}
entry = svIndexes[index++];
return true;
}
template <
class V,
class N,
class = std::enable_if_t<
std::is_same_v<std::remove_cv_t<N>, SLE> && std::is_base_of_v<ReadView, V>>>
bool
internalDirFirst(
V& view,
uint256 const& root,
std::shared_ptr<N>& page,
unsigned int& index,
uint256& entry)
{
if constexpr (std::is_const_v<N>)
{
page = view.read(keylet::page(root));
}
else
{
page = view.peek(keylet::page(root));
}
if (!page)
return false;
index = 0;
return internalDirNext(view, root, page, index, entry);
}
} // namespace detail
/** @{ */
/** Returns the first entry in the directory, advancing the index
@deprecated These are legacy function that are considered deprecated
and will soon be replaced with an iterator-based model
that is easier to use. You should not use them in new code.
@param view The view against which to operate
@param root The root (i.e. first page) of the directory to iterate
@param page The current page
@param index The index inside the current page
@param entry The entry at the current index
@return true if the directory isn't empty; false otherwise
*/
bool
cdirFirst(
ReadView const& view,
uint256 const& root,
std::shared_ptr<SLE const>& page,
unsigned int& index,
uint256& entry);
bool
dirFirst(
ApplyView& view,
uint256 const& root,
std::shared_ptr<SLE>& page,
unsigned int& index,
uint256& entry);
/** @} */
/** @{ */
/** Returns the next entry in the directory, advancing the index
@deprecated These are legacy function that are considered deprecated
and will soon be replaced with an iterator-based model
that is easier to use. You should not use them in new code.
@param view The view against which to operate
@param root The root (i.e. first page) of the directory to iterate
@param page The current page
@param index The index inside the current page
@param entry The entry at the current index
@return true if the directory isn't empty; false otherwise
*/
bool
cdirNext(
ReadView const& view,
uint256 const& root,
std::shared_ptr<SLE const>& page,
unsigned int& index,
uint256& entry);
bool
dirNext(
ApplyView& view,
uint256 const& root,
std::shared_ptr<SLE>& page,
unsigned int& index,
uint256& entry);
/** @} */
/** Iterate all items in the given directory. */
void
forEachItem(
ReadView const& view,
Keylet const& root,
std::function<void(std::shared_ptr<SLE const> const&)> const& f);
/** Iterate all items after an item in the given directory.
@param after The key of the item to start after
@param hint The directory page containing `after`
@param limit The maximum number of items to return
@return `false` if the iteration failed
*/
bool
forEachItemAfter(
ReadView const& view,
Keylet const& root,
uint256 const& after,
std::uint64_t const hint,
unsigned int limit,
std::function<bool(std::shared_ptr<SLE const> const&)> const& f);
/** Iterate all items in an account's owner directory. */
inline void
forEachItem(
ReadView const& view,
AccountID const& id,
std::function<void(std::shared_ptr<SLE const> const&)> const& f)
{
return forEachItem(view, keylet::ownerDir(id), f);
}
/** Iterate all items after an item in an owner directory.
@param after The key of the item to start after
@param hint The directory page containing `after`
@param limit The maximum number of items to return
@return `false` if the iteration failed
*/
inline bool
forEachItemAfter(
ReadView const& view,
AccountID const& id,
uint256 const& after,
std::uint64_t const hint,
unsigned int limit,
std::function<bool(std::shared_ptr<SLE const> const&)> const& f)
{
return forEachItemAfter(view, keylet::ownerDir(id), after, hint, limit, f);
}
/** Returns `true` if the directory is empty
@param key The key of the directory
*/
[[nodiscard]] bool
dirIsEmpty(ReadView const& view, Keylet const& k);
/** Returns a function that sets the owner on a directory SLE */
[[nodiscard]] std::function<void(SLE::ref)>
describeOwnerDir(AccountID const& account);
} // namespace xrpl

160
include/xrpl/ledger/helpers/MPTokenHelpers.h Normal file
View File

@@ -0,0 +1,160 @@
#pragma once
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/ledger/ApplyView.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/ledger/helpers/TokenHelpers.h>
#include <xrpl/protocol/MPTIssue.h>
#include <xrpl/protocol/Rate.h>
#include <xrpl/protocol/STAmount.h>
#include <xrpl/protocol/TER.h>
#include <initializer_list>
#include <optional>
namespace xrpl {
//------------------------------------------------------------------------------
//
// Freeze checking (MPT-specific)
//
//------------------------------------------------------------------------------
[[nodiscard]] bool
isGlobalFrozen(ReadView const& view, MPTIssue const& mptIssue);
[[nodiscard]] bool
isIndividualFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptIssue);
[[nodiscard]] bool
isFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptIssue, int depth = 0);
[[nodiscard]] bool
isAnyFrozen(
ReadView const& view,
std::initializer_list<AccountID> const& accounts,
MPTIssue const& mptIssue,
int depth = 0);
//------------------------------------------------------------------------------
//
// Transfer rate (MPT-specific)
//
//------------------------------------------------------------------------------
/** Returns MPT transfer fee as Rate. Rate specifies
* the fee as fractions of 1 billion. For example, 1% transfer rate
* is represented as 1,010,000,000.
* @param issuanceID MPTokenIssuanceID of MPTTokenIssuance object
*/
[[nodiscard]] Rate
transferRate(ReadView const& view, MPTID const& issuanceID);
//------------------------------------------------------------------------------
//
// Holding checks (MPT-specific)
//
//------------------------------------------------------------------------------
[[nodiscard]] TER
canAddHolding(ReadView const& view, MPTIssue const& mptIssue);
//------------------------------------------------------------------------------
//
// Authorization (MPT-specific)
//
//------------------------------------------------------------------------------
[[nodiscard]] TER
authorizeMPToken(
ApplyView& view,
XRPAmount const& priorBalance,
MPTID const& mptIssuanceID,
AccountID const& account,
beast::Journal journal,
std::uint32_t flags = 0,
std::optional<AccountID> holderID = std::nullopt);
/** Check if the account lacks required authorization for MPT.
*
* requireAuth check is recursive for MPT shares in a vault, descending to
* assets in the vault, up to maxAssetCheckDepth recursion depth. This is
* purely defensive, as we currently do not allow such vaults to be created.
*/
[[nodiscard]] TER
requireAuth(
ReadView const& view,
MPTIssue const& mptIssue,
AccountID const& account,
AuthType authType = AuthType::Legacy,
int depth = 0);
/** Enforce account has MPToken to match its authorization.
*
* Called from doApply - it will check for expired (and delete if found any)
* credentials matching DomainID set in MPTokenIssuance. Must be called if
* requireAuth(...MPTIssue...) returned tesSUCCESS or tecEXPIRED in preclaim.
*/
[[nodiscard]] TER
enforceMPTokenAuthorization(
ApplyView& view,
MPTID const& mptIssuanceID,
AccountID const& account,
XRPAmount const& priorBalance,
beast::Journal j);
/** Check if the destination account is allowed
* to receive MPT. Return tecNO_AUTH if it doesn't
* and tesSUCCESS otherwise.
*/
[[nodiscard]] TER
canTransfer(
ReadView const& view,
MPTIssue const& mptIssue,
AccountID const& from,
AccountID const& to);
//------------------------------------------------------------------------------
//
// Empty holding operations (MPT-specific)
//
//------------------------------------------------------------------------------
[[nodiscard]] TER
addEmptyHolding(
ApplyView& view,
AccountID const& accountID,
XRPAmount priorBalance,
MPTIssue const& mptIssue,
beast::Journal journal);
[[nodiscard]] TER
removeEmptyHolding(
ApplyView& view,
AccountID const& accountID,
MPTIssue const& mptIssue,
beast::Journal journal);
//------------------------------------------------------------------------------
//
// Escrow operations (MPT-specific)
//
//------------------------------------------------------------------------------
TER
rippleLockEscrowMPT(
ApplyView& view,
AccountID const& uGrantorID,
STAmount const& saAmount,
beast::Journal j);
TER
rippleUnlockEscrowMPT(
ApplyView& view,
AccountID const& uGrantorID,
AccountID const& uGranteeID,
STAmount const& netAmount,
STAmount const& grossAmount,
beast::Journal j);
} // namespace xrpl

28
include/xrpl/ledger/helpers/OfferHelpers.h Normal file
View File

@@ -0,0 +1,28 @@
#pragma once
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/ledger/ApplyView.h>
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/TER.h>
#include <memory>
namespace xrpl {
/** Delete an offer.
Requirements:
The offer must exist.
The caller must have already checked permissions.
@param view The ApplyView to modify.
@param sle The offer to delete.
@param j Journal for logging.
@return tesSUCCESS on success, otherwise an error code.
*/
// [[nodiscard]] // nodiscard commented out so Flow, BookTip and others compile.
TER
offerDelete(ApplyView& view, std::shared_ptr<SLE> const& sle, beast::Journal j);
} // namespace xrpl

255
include/xrpl/ledger/helpers/RippleStateHelpers.h Normal file
View File

@@ -0,0 +1,255 @@
#pragma once
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/ledger/ApplyView.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/ledger/helpers/TokenHelpers.h>
#include <xrpl/protocol/IOUAmount.h>
#include <xrpl/protocol/Issue.h>
#include <xrpl/protocol/STAmount.h>
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/TER.h>
//------------------------------------------------------------------------------
//
// RippleState (Trustline) helpers
//
//------------------------------------------------------------------------------
namespace xrpl {
//------------------------------------------------------------------------------
//
// Credit functions (from Credit.h)
//
//------------------------------------------------------------------------------
/** Calculate the maximum amount of IOUs that an account can hold
@param view the ledger to check against.
@param account the account of interest.
@param issuer the issuer of the IOU.
@param currency the IOU to check.
@return The maximum amount that can be held.
*/
/** @{ */
STAmount
creditLimit(
ReadView const& view,
AccountID const& account,
AccountID const& issuer,
Currency const& currency);
IOUAmount
creditLimit2(ReadView const& v, AccountID const& acc, AccountID const& iss, Currency const& cur);
/** @} */
/** Returns the amount of IOUs issued by issuer that are held by an account
@param view the ledger to check against.
@param account the account of interest.
@param issuer the issuer of the IOU.
@param currency the IOU to check.
*/
/** @{ */
STAmount
creditBalance(
ReadView const& view,
AccountID const& account,
AccountID const& issuer,
Currency const& currency);
/** @} */
//------------------------------------------------------------------------------
//
// Freeze checking (IOU-specific)
//
//------------------------------------------------------------------------------
[[nodiscard]] bool
isIndividualFrozen(
ReadView const& view,
AccountID const& account,
Currency const& currency,
AccountID const& issuer);
[[nodiscard]] inline bool
isIndividualFrozen(ReadView const& view, AccountID const& account, Issue const& issue)
{
return isIndividualFrozen(view, account, issue.currency, issue.account);
}
[[nodiscard]] bool
isFrozen(
ReadView const& view,
AccountID const& account,
Currency const& currency,
AccountID const& issuer);
[[nodiscard]] inline bool
isFrozen(ReadView const& view, AccountID const& account, Issue const& issue)
{
return isFrozen(view, account, issue.currency, issue.account);
}
// Overload with depth parameter for uniformity with MPTIssue version.
// The depth parameter is ignored for IOUs since they don't have vault recursion.
[[nodiscard]] inline bool
isFrozen(ReadView const& view, AccountID const& account, Issue const& issue, int /*depth*/)
{
return isFrozen(view, account, issue);
}
[[nodiscard]] bool
isDeepFrozen(
ReadView const& view,
AccountID const& account,
Currency const& currency,
AccountID const& issuer);
[[nodiscard]] inline bool
isDeepFrozen(
ReadView const& view,
AccountID const& account,
Issue const& issue,
int = 0 /*ignored*/)
{
return isDeepFrozen(view, account, issue.currency, issue.account);
}
[[nodiscard]] inline TER
checkDeepFrozen(ReadView const& view, AccountID const& account, Issue const& issue)
{
return isDeepFrozen(view, account, issue) ? (TER)tecFROZEN : (TER)tesSUCCESS;
}
//------------------------------------------------------------------------------
//
// Trust line operations
//
//------------------------------------------------------------------------------
/** Create a trust line
This can set an initial balance.
*/
[[nodiscard]] TER
trustCreate(
ApplyView& view,
bool const bSrcHigh,
AccountID const& uSrcAccountID,
AccountID const& uDstAccountID,
uint256 const& uIndex, // --> ripple state entry
SLE::ref sleAccount, // --> the account being set.
bool const bAuth, // --> authorize account.
bool const bNoRipple, // --> others cannot ripple through
bool const bFreeze, // --> funds cannot leave
bool bDeepFreeze, // --> can neither receive nor send funds
STAmount const& saBalance, // --> balance of account being set.
// Issuer should be noAccount()
STAmount const& saLimit, // --> limit for account being set.
// Issuer should be the account being set.
std::uint32_t uQualityIn,
std::uint32_t uQualityOut,
beast::Journal j);
[[nodiscard]] TER
trustDelete(
ApplyView& view,
std::shared_ptr<SLE> const& sleRippleState,
AccountID const& uLowAccountID,
AccountID const& uHighAccountID,
beast::Journal j);
//------------------------------------------------------------------------------
//
// IOU issuance/redemption
//
//------------------------------------------------------------------------------
[[nodiscard]] TER
issueIOU(
ApplyView& view,
AccountID const& account,
STAmount const& amount,
Issue const& issue,
beast::Journal j);
[[nodiscard]] TER
redeemIOU(
ApplyView& view,
AccountID const& account,
STAmount const& amount,
Issue const& issue,
beast::Journal j);
//------------------------------------------------------------------------------
//
// Authorization and transfer checks (IOU-specific)
//
//------------------------------------------------------------------------------
/** Check if the account lacks required authorization.
*
* Return tecNO_AUTH or tecNO_LINE if it does
* and tesSUCCESS otherwise.
*
* If StrongAuth then return tecNO_LINE if the RippleState doesn't exist. Return
* tecNO_AUTH if lsfRequireAuth is set on the issuer's AccountRoot, and the
* RippleState does exist, and the RippleState is not authorized.
*
* If WeakAuth then return tecNO_AUTH if lsfRequireAuth is set, and the
* RippleState exists, and is not authorized. Return tecNO_LINE if
* lsfRequireAuth is set and the RippleState doesn't exist. Consequently, if
* WeakAuth and lsfRequireAuth is *not* set, this function will return
* tesSUCCESS even if RippleState does *not* exist.
*
* The default "Legacy" auth type is equivalent to WeakAuth.
*/
[[nodiscard]] TER
requireAuth(
ReadView const& view,
Issue const& issue,
AccountID const& account,
AuthType authType = AuthType::Legacy);
/** Check if the destination account is allowed
* to receive IOU. Return terNO_RIPPLE if rippling is
* disabled on both sides and tesSUCCESS otherwise.
*/
[[nodiscard]] TER
canTransfer(ReadView const& view, Issue const& issue, AccountID const& from, AccountID const& to);
//------------------------------------------------------------------------------
//
// Empty holding operations (IOU-specific)
//
//------------------------------------------------------------------------------
/// Any transactors that call addEmptyHolding() in doApply must call
/// canAddHolding() in preflight with the same View and Asset
[[nodiscard]] TER
addEmptyHolding(
ApplyView& view,
AccountID const& accountID,
XRPAmount priorBalance,
Issue const& issue,
beast::Journal journal);
[[nodiscard]] TER
removeEmptyHolding(
ApplyView& view,
AccountID const& accountID,
Issue const& issue,
beast::Journal journal);
/** Delete trustline to AMM. The passed `sle` must be obtained from a prior
* call to view.peek(). Fail if neither side of the trustline is AMM or
* if ammAccountID is seated and is not one of the trustline's side.
*/
[[nodiscard]] TER
deleteAMMTrustLine(
ApplyView& view,
std::shared_ptr<SLE> sleState,
std::optional<AccountID> const& ammAccountID,
beast::Journal j);
} // namespace xrpl

286
include/xrpl/ledger/helpers/TokenHelpers.h Normal file
View File

@@ -0,0 +1,286 @@
#pragma once
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/ledger/ApplyView.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/protocol/Asset.h>
#include <xrpl/protocol/MPTIssue.h>
#include <xrpl/protocol/Rate.h>
#include <xrpl/protocol/STAmount.h>
#include <xrpl/protocol/TER.h>
#include <initializer_list>
#include <vector>
namespace xrpl {
//------------------------------------------------------------------------------
//
// Enums for token handling
//
//------------------------------------------------------------------------------
/** Controls the treatment of frozen account balances */
enum FreezeHandling { fhIGNORE_FREEZE, fhZERO_IF_FROZEN };
/** Controls the treatment of unauthorized MPT balances */
enum AuthHandling { ahIGNORE_AUTH, ahZERO_IF_UNAUTHORIZED };
/** Controls whether to include the account's full spendable balance */
enum SpendableHandling { shSIMPLE_BALANCE, shFULL_BALANCE };
enum class WaiveTransferFee : bool { No = false, Yes };
/* Check if MPToken (for MPT) or trust line (for IOU) exists:
* - StrongAuth - before checking if authorization is required
* - WeakAuth
* for MPT - after checking lsfMPTRequireAuth flag
* for IOU - do not check if trust line exists
* - Legacy
* for MPT - before checking lsfMPTRequireAuth flag i.e. same as StrongAuth
* for IOU - do not check if trust line exists i.e. same as WeakAuth
*/
enum class AuthType { StrongAuth, WeakAuth, Legacy };
//------------------------------------------------------------------------------
//
// Freeze checking (Asset-based dispatchers)
//
//------------------------------------------------------------------------------
[[nodiscard]] bool
isGlobalFrozen(ReadView const& view, Asset const& asset);
[[nodiscard]] bool
isIndividualFrozen(ReadView const& view, AccountID const& account, Asset const& asset);
/**
* isFrozen check is recursive for MPT shares in a vault, descending to
* assets in the vault, up to maxAssetCheckDepth recursion depth. This is
* purely defensive, as we currently do not allow such vaults to be created.
*/
[[nodiscard]] bool
isFrozen(ReadView const& view, AccountID const& account, Asset const& asset, int depth = 0);
[[nodiscard]] TER
checkFrozen(ReadView const& view, AccountID const& account, Issue const& issue);
[[nodiscard]] TER
checkFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptIssue);
[[nodiscard]] TER
checkFrozen(ReadView const& view, AccountID const& account, Asset const& asset);
[[nodiscard]] bool
isAnyFrozen(
ReadView const& view,
std::initializer_list<AccountID> const& accounts,
Issue const& issue);
[[nodiscard]] bool
isAnyFrozen(
ReadView const& view,
std::initializer_list<AccountID> const& accounts,
Asset const& asset,
int depth = 0);
[[nodiscard]] bool
isDeepFrozen(
ReadView const& view,
AccountID const& account,
MPTIssue const& mptIssue,
int depth = 0);
/**
* isFrozen check is recursive for MPT shares in a vault, descending to
* assets in the vault, up to maxAssetCheckDepth recursion depth. This is
* purely defensive, as we currently do not allow such vaults to be created.
*/
[[nodiscard]] bool
isDeepFrozen(ReadView const& view, AccountID const& account, Asset const& asset, int depth = 0);
[[nodiscard]] TER
checkDeepFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptIssue);
[[nodiscard]] TER
checkDeepFrozen(ReadView const& view, AccountID const& account, Asset const& asset);
//------------------------------------------------------------------------------
//
// Account balance functions (Asset-based dispatchers)
//
//------------------------------------------------------------------------------
// Returns the amount an account can spend.
//
// If shSIMPLE_BALANCE is specified, this is the amount the account can spend
// without going into debt.
//
// If shFULL_BALANCE is specified, this is the amount the account can spend
// total. Specifically:
// * The account can go into debt if using a trust line, and the other side has
// a non-zero limit.
// * If the account is the asset issuer the limit is defined by the asset /
// issuance.
//
// <-- saAmount: amount of currency held by account. May be negative.
[[nodiscard]] STAmount
accountHolds(
ReadView const& view,
AccountID const& account,
Currency const& currency,
AccountID const& issuer,
FreezeHandling zeroIfFrozen,
beast::Journal j,
SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
[[nodiscard]] STAmount
accountHolds(
ReadView const& view,
AccountID const& account,
Issue const& issue,
FreezeHandling zeroIfFrozen,
beast::Journal j,
SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
[[nodiscard]] STAmount
accountHolds(
ReadView const& view,
AccountID const& account,
MPTIssue const& mptIssue,
FreezeHandling zeroIfFrozen,
AuthHandling zeroIfUnauthorized,
beast::Journal j,
SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
[[nodiscard]] STAmount
accountHolds(
ReadView const& view,
AccountID const& account,
Asset const& asset,
FreezeHandling zeroIfFrozen,
AuthHandling zeroIfUnauthorized,
beast::Journal j,
SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
// Returns the amount an account can spend of the currency type saDefault, or
// returns saDefault if this account is the issuer of the currency in
// question. Should be used in favor of accountHolds when questioning how much
// an account can spend while also allowing currency issuers to spend
// unlimited amounts of their own currency (since they can always issue more).
[[nodiscard]] STAmount
accountFunds(
ReadView const& view,
AccountID const& id,
STAmount const& saDefault,
FreezeHandling freezeHandling,
beast::Journal j);
/** Returns the transfer fee as Rate based on the type of token
* @param view The ledger view
* @param amount The amount to transfer
*/
[[nodiscard]] Rate
transferRate(ReadView const& view, STAmount const& amount);
//------------------------------------------------------------------------------
//
// Holding operations (Asset-based dispatchers)
//
//------------------------------------------------------------------------------
[[nodiscard]] TER
canAddHolding(ReadView const& view, Asset const& asset);
[[nodiscard]] TER
addEmptyHolding(
ApplyView& view,
AccountID const& accountID,
XRPAmount priorBalance,
Asset const& asset,
beast::Journal journal);
[[nodiscard]] TER
removeEmptyHolding(
ApplyView& view,
AccountID const& accountID,
Asset const& asset,
beast::Journal journal);
//------------------------------------------------------------------------------
//
// Authorization and transfer checks (Asset-based dispatchers)
//
//------------------------------------------------------------------------------
[[nodiscard]] TER
requireAuth(
ReadView const& view,
Asset const& asset,
AccountID const& account,
AuthType authType = AuthType::Legacy);
[[nodiscard]] TER
canTransfer(ReadView const& view, Asset const& asset, AccountID const& from, AccountID const& to);
//------------------------------------------------------------------------------
//
// Money Transfers (Asset-based dispatchers)
//
//------------------------------------------------------------------------------
// Direct send w/o fees:
// - Redeeming IOUs and/or sending sender's own IOUs.
// - Create trust line of needed.
// --> bCheckIssuer : normally require issuer to be involved.
// [[nodiscard]] // nodiscard commented out so DirectStep.cpp compiles.
/** Calls static rippleCreditIOU if saAmount represents Issue.
* Calls static rippleCreditMPT if saAmount represents MPTIssue.
*/
TER
rippleCredit(
ApplyView& view,
AccountID const& uSenderID,
AccountID const& uReceiverID,
STAmount const& saAmount,
bool bCheckIssuer,
beast::Journal j);
/** Calls static accountSendIOU if saAmount represents Issue.
* Calls static accountSendMPT if saAmount represents MPTIssue.
*/
[[nodiscard]] TER
accountSend(
ApplyView& view,
AccountID const& from,
AccountID const& to,
STAmount const& saAmount,
beast::Journal j,
WaiveTransferFee waiveFee = WaiveTransferFee::No);
using MultiplePaymentDestinations = std::vector<std::pair<AccountID, Number>>;
/** Like accountSend, except one account is sending multiple payments (with the
* same asset!) simultaneously
*
* Calls static accountSendMultiIOU if saAmount represents Issue.
* Calls static accountSendMultiMPT if saAmount represents MPTIssue.
*/
[[nodiscard]] TER
accountSendMulti(
ApplyView& view,
AccountID const& senderID,
Asset const& asset,
MultiplePaymentDestinations const& receivers,
beast::Journal j,
WaiveTransferFee waiveFee = WaiveTransferFee::No);
[[nodiscard]] TER
transferXRP(
ApplyView& view,
AccountID const& from,
AccountID const& to,
STAmount const& amount,
beast::Journal j);
} // namespace xrpl

81
include/xrpl/ledger/helpers/VaultHelpers.h Normal file
View File

@@ -0,0 +1,81 @@
#pragma once
#include <xrpl/protocol/STAmount.h>
#include <xrpl/protocol/STLedgerEntry.h>
#include <memory>
#include <optional>
namespace xrpl {
/** From the perspective of a vault, return the number of shares to give
depositor when they offer a fixed amount of assets. Note, since shares are
MPT, this number is integral and always truncated in this calculation.
@param vault The vault SLE.
@param issuance The MPTokenIssuance SLE for the vault's shares.
@param assets The amount of assets to convert.
@return The number of shares, or nullopt on error.
*/
[[nodiscard]] std::optional<STAmount>
assetsToSharesDeposit(
std::shared_ptr<SLE const> const& vault,
std::shared_ptr<SLE const> const& issuance,
STAmount const& assets);
/** From the perspective of a vault, return the number of assets to take from
depositor when they receive a fixed amount of shares. Note, since shares are
MPT, they are always an integral number.
@param vault The vault SLE.
@param issuance The MPTokenIssuance SLE for the vault's shares.
@param shares The amount of shares to convert.
@return The number of assets, or nullopt on error.
*/
[[nodiscard]] std::optional<STAmount>
sharesToAssetsDeposit(
std::shared_ptr<SLE const> const& vault,
std::shared_ptr<SLE const> const& issuance,
STAmount const& shares);
/** Controls whether to truncate shares instead of rounding. */
enum class TruncateShares : bool { no = false, yes = true };
/** From the perspective of a vault, return the number of shares to demand from
the depositor when they ask to withdraw a fixed amount of assets. Since
shares are MPT this number is integral, and it will be rounded to nearest
unless explicitly requested to be truncated instead.
@param vault The vault SLE.
@param issuance The MPTokenIssuance SLE for the vault's shares.
@param assets The amount of assets to convert.
@param truncate Whether to truncate instead of rounding.
@return The number of shares, or nullopt on error.
*/
[[nodiscard]] std::optional<STAmount>
assetsToSharesWithdraw(
std::shared_ptr<SLE const> const& vault,
std::shared_ptr<SLE const> const& issuance,
STAmount const& assets,
TruncateShares truncate = TruncateShares::no);
/** From the perspective of a vault, return the number of assets to give the
depositor when they redeem a fixed amount of shares. Note, since shares are
MPT, they are always an integral number.
@param vault The vault SLE.
@param issuance The MPTokenIssuance SLE for the vault's shares.
@param shares The amount of shares to convert.
@return The number of assets, or nullopt on error.
*/
[[nodiscard]] std::optional<STAmount>
sharesToAssetsWithdraw(
std::shared_ptr<SLE const> const& vault,
std::shared_ptr<SLE const> const& issuance,
STAmount const& shares);
} // namespace xrpl

12
include/xrpl/net/HTTPClient.h
View File

@@ -29,6 +29,18 @@ public:
bool sslVerify,
beast::Journal j);
/** Destroys the global SSL context created by initializeSSLContext().
*
* This releases the underlying boost::asio::ssl::context and any
* associated OpenSSL resources. Must not be called while any
* HTTPClient requests are in flight.
*
* @note Currently only called from tests during teardown. In production,
* the SSL context lives for the lifetime of the process.
*/
static void
cleanupSSLContext();
static void
get(bool bSSL,
boost::asio::io_context& io_context,

2
include/xrpl/protocol/BuildInfo.h
View File

@@ -49,7 +49,7 @@ getFullVersionString();
@return the encoded version in a 64-bit integer
*/
std::uint64_t
encodeSoftwareVersion(char const* const versionStr);
encodeSoftwareVersion(std::string_view versionStr);
/** Returns this server's version packed in a 64-bit integer. */
std::uint64_t

43
include/xrpl/protocol/Feature.h
View File

@@ -64,6 +64,49 @@
namespace xrpl {
// Feature names must not exceed this length (in characters, excluding the null terminator).
static constexpr std::size_t maxFeatureNameSize = 63;
// Reserve this exact feature-name length (in characters/bytes, excluding the null terminator)
// so that a 32-byte uint256 (for example, in WASM or other interop contexts) can be used
// as a compact, fixed-size feature selector without conflicting with human-readable names.
static constexpr std::size_t reservedFeatureNameSize = 32;
// Both validFeatureNameSize and validFeatureName are consteval functions that can be used in
// static_asserts to validate feature names at compile time. They are only used inside
// enforceValidFeatureName in Feature.cpp, but are exposed here for testing. The expected
// parameter `auto fn` is a constexpr lambda which returns a const char*, making it available
// for compile-time evaluation. Read more in https://accu.org/journals/overload/30/172/wu/
consteval auto
validFeatureNameSize(auto fn) -> bool
{
constexpr char const* n = fn();
// Note, std::strlen is not constexpr, we need to implement our own here.
constexpr std::size_t N = [](auto n) {
std::size_t ret = 0;
for (auto ptr = n; *ptr != '\0'; ret++, ++ptr)
;
return ret;
}(n);
return N != reservedFeatureNameSize && //
N <= maxFeatureNameSize;
}
consteval auto
validFeatureName(auto fn) -> bool
{
constexpr char const* n = fn();
// Prevent the use of visually confusable characters and enforce that feature names
// are always valid ASCII. This is needed because C++ allows Unicode identifiers.
// Characters below 0x20 are nonprintable control characters, and characters with the 0x80 bit
// set are non-ASCII (e.g. UTF-8 encoding of Unicode), so both are disallowed.
for (auto ptr = n; *ptr != '\0'; ++ptr)
{
if (*ptr & 0x80 || *ptr < 0x20)
return false;
}
return true;
}
enum class VoteBehavior : int { Obsolete = -1, DefaultNo = 0, DefaultYes };
enum class AmendmentSupport : int { Retired = -1, Supported = 0, Unsupported };

18
include/xrpl/protocol/KnownFormats.h
View File

@@ -30,9 +30,11 @@ public:
Item(
char const* name,
KeyType type,
std::initializer_list<SOElement> uniqueFields,
std::initializer_list<SOElement> commonFields)
: soTemplate_(uniqueFields, commonFields), name_(name), type_(type)
std::vector<SOElement> uniqueFields,
std::vector<SOElement> commonFields)
: soTemplate_(std::move(uniqueFields), std::move(commonFields))
, name_(name)
, type_(type)
{
// Verify that KeyType is appropriate.
static_assert(
@@ -142,16 +144,16 @@ protected:
@param name The name of this format.
@param type The type of this format.
@param uniqueFields An std::initializer_list of unique fields
@param commonFields An std::initializer_list of common fields
@param uniqueFields A std::vector of unique fields
@param commonFields A std::vector of common fields
@return The created format.
*/
Item const&
add(char const* name,
KeyType type,
std::initializer_list<SOElement> uniqueFields,
std::initializer_list<SOElement> commonFields = {})
std::vector<SOElement> uniqueFields,
std::vector<SOElement> commonFields = {})
{
if (auto const item = findByType(type))
{
@@ -160,7 +162,7 @@ protected:
item->getName());
}
formats_.emplace_front(name, type, uniqueFields, commonFields);
formats_.emplace_front(name, type, std::move(uniqueFields), std::move(commonFields));
Item const& item{formats_.front()};
names_[name] = &item;

309
include/xrpl/protocol/LedgerFormats.h
View File

@@ -2,36 +2,34 @@
#include <xrpl/protocol/KnownFormats.h>
namespace xrpl {
#include <map>
#include <string>
#include <vector>
namespace xrpl {
/** Identifiers for on-ledger objects.
Each ledger object requires a unique type identifier, which is stored
within the object itself; this makes it possible to iterate the entire
ledger and determine each object's type and verify that the object you
retrieved from a given hash matches the expected type.
Each ledger object requires a unique type identifier, which is stored within the object itself;
this makes it possible to iterate the entire ledger and determine each object's type and verify
that the object you retrieved from a given hash matches the expected type.
@warning Since these values are stored inside objects stored on the ledger
they are part of the protocol. **Changing them should be avoided
because without special handling, this will result in a hard
@warning Since these values are stored inside objects stored on the ledger they are part of the
protocol.
**Changing them should be avoided because without special handling, this will result in a hard
fork.**
@note Values outside this range may be used internally by the code for
various purposes, but attempting to use such values to identify
on-ledger objects will results in an invariant failure.
@note Values outside this range may be used internally by the code for various purposes, but
attempting to use such values to identify on-ledger objects will result in an invariant failure.
@note When retiring types, the specific values should not be removed but
should be marked as [[deprecated]]. This is to avoid accidental
reuse of identifiers.
@note When retiring types, the specific values should not be removed but should be marked as
[[deprecated]]. This is to avoid accidental reuse of identifiers.
@todo The C++ language does not enable checking for duplicate values
here. If it becomes possible then we should do this.
@todo The C++ language does not enable checking for duplicate values here.
If it becomes possible then we should do this.
@ingroup protocol
*/
// clang-format off
enum LedgerEntryType : std::uint16_t
{
enum LedgerEntryType : std::uint16_t {
#pragma push_macro("LEDGER_ENTRY")
#undef LEDGER_ENTRY
@@ -46,12 +44,10 @@ enum LedgerEntryType : std::uint16_t
//---------------------------------------------------------------------------
/** A special type, matching any ledger entry type.
The value does not represent a concrete type, but rather is used in
contexts where the specific type of a ledger object is unimportant,
unknown or unavailable.
The value does not represent a concrete type, but rather is used in contexts where the
specific type of a ledger object is unimportant, unknown or unavailable.
Objects with this special type cannot be created or stored on the
ledger.
Objects with this special type cannot be created or stored on the ledger.
\sa keylet::unchecked
*/
@@ -59,12 +55,11 @@ enum LedgerEntryType : std::uint16_t
/** A special type, matching any ledger type except directory nodes.
The value does not represent a concrete type, but rather is used in
contexts where the ledger object must not be a directory node but
its specific type is otherwise unimportant, unknown or unavailable.
The value does not represent a concrete type, but rather is used in contexts where the
ledger object must not be a directory node but its specific type is otherwise unimportant,
unknown or unavailable.
Objects with this special type cannot be created or stored on the
ledger.
Objects with this special type cannot be created or stored on the ledger.
\sa keylet::child
*/
@@ -93,104 +88,188 @@ enum LedgerEntryType : std::uint16_t
Support for this type of object was never implemented.
No objects of this type were ever created.
*/
ltGENERATOR_MAP [[deprecated("This object type is not supported and should not be used.")]] = 0x0067,
ltGENERATOR_MAP [[deprecated("This object type is not supported and should not be used.")]] =
0x0067,
};
// clang-format off
/**
/** Ledger object flags.
These flags are specified in ledger objects and modify their behavior.
@warning Ledger object flags form part of the protocol.
**Changing them should be avoided because without special handling, this will result in a hard
fork.**
@ingroup protocol
*/
enum LedgerSpecificFlags {
// ltACCOUNT_ROOT
lsfPasswordSpent = 0x00010000, // True, if password set fee is spent.
lsfRequireDestTag =
0x00020000, // True, to require a DestinationTag for payments.
lsfRequireAuth =
0x00040000, // True, to require a authorization to hold IOUs.
lsfDisallowXRP = 0x00080000, // True, to disallow sending XRP.
lsfDisableMaster = 0x00100000, // True, force regular key
lsfNoFreeze = 0x00200000, // True, cannot freeze ripple states
lsfGlobalFreeze = 0x00400000, // True, all assets frozen
lsfDefaultRipple =
0x00800000, // True, incoming trust lines allow rippling by default
lsfDepositAuth = 0x01000000, // True, all deposits require authorization
/* // reserved for Hooks amendment
lsfTshCollect = 0x02000000, // True, allow TSH collect-calls to acc hooks
*/
lsfDisallowIncomingNFTokenOffer =
0x04000000, // True, reject new incoming NFT offers
lsfDisallowIncomingCheck =
0x08000000, // True, reject new checks
lsfDisallowIncomingPayChan =
0x10000000, // True, reject new paychans
lsfDisallowIncomingTrustline =
0x20000000, // True, reject new trustlines (only if no issued assets)
lsfAllowTrustLineLocking =
0x40000000, // True, enable trustline locking
lsfAllowTrustLineClawback =
0x80000000, // True, enable clawback
#pragma push_macro("XMACRO")
#pragma push_macro("TO_VALUE")
#pragma push_macro("VALUE_TO_MAP")
#pragma push_macro("NULL_NAME")
#pragma push_macro("TO_MAP")
#pragma push_macro("ALL_LEDGER_FLAGS")
// ltOFFER
lsfPassive = 0x00010000,
lsfSell = 0x00020000, // True, offer was placed as a sell.
lsfHybrid = 0x00040000, // True, offer is hybrid.
#undef XMACRO
#undef TO_VALUE
#undef VALUE_TO_MAP
#undef NULL_NAME
#undef TO_MAP
// ltRIPPLE_STATE
lsfLowReserve = 0x00010000, // True, if entry counts toward reserve.
lsfHighReserve = 0x00020000,
lsfLowAuth = 0x00040000,
lsfHighAuth = 0x00080000,
lsfLowNoRipple = 0x00100000,
lsfHighNoRipple = 0x00200000,
lsfLowFreeze = 0x00400000, // True, low side has set freeze flag
lsfHighFreeze = 0x00800000, // True, high side has set freeze flag
lsfLowDeepFreeze = 0x02000000, // True, low side has set deep freeze flag
lsfHighDeepFreeze = 0x04000000, // True, high side has set deep freeze flag
lsfAMMNode = 0x01000000, // True, trust line to AMM. Used by client
// apps to identify payments via AMM.
#undef ALL_LEDGER_FLAGS
// ltSIGNER_LIST
lsfOneOwnerCount = 0x00010000, // True, uses only one OwnerCount
// clang-format off
// ltDIR_NODE
lsfNFTokenBuyOffers = 0x00000001,
lsfNFTokenSellOffers = 0x00000002,
#define XMACRO(LEDGER_OBJECT, LSF_FLAG, LSF_FLAG2) \
LEDGER_OBJECT(AccountRoot, \
LSF_FLAG(lsfPasswordSpent, 0x00010000) /* True, if password set fee is spent. */ \
LSF_FLAG(lsfRequireDestTag, 0x00020000) /* True, to require a DestinationTag for payments. */ \
LSF_FLAG(lsfRequireAuth, 0x00040000) /* True, to require a authorization to hold IOUs. */ \
LSF_FLAG(lsfDisallowXRP, 0x00080000) /* True, to disallow sending XRP. */ \
LSF_FLAG(lsfDisableMaster, 0x00100000) /* True, force regular key */ \
LSF_FLAG(lsfNoFreeze, 0x00200000) /* True, cannot freeze ripple states */ \
LSF_FLAG(lsfGlobalFreeze, 0x00400000) /* True, all assets frozen */ \
LSF_FLAG(lsfDefaultRipple, 0x00800000) /* True, incoming trust lines allow rippling by default */ \
LSF_FLAG(lsfDepositAuth, 0x01000000) /* True, all deposits require authorization */ \
LSF_FLAG(lsfDisallowIncomingNFTokenOffer, 0x04000000) /* True, reject new incoming NFT offers */ \
LSF_FLAG(lsfDisallowIncomingCheck, 0x08000000) /* True, reject new checks */ \
LSF_FLAG(lsfDisallowIncomingPayChan, 0x10000000) /* True, reject new paychans */ \
LSF_FLAG(lsfDisallowIncomingTrustline, 0x20000000) /* True, reject new trustlines (only if no issued assets) */ \
LSF_FLAG(lsfAllowTrustLineLocking, 0x40000000) /* True, enable trustline locking */ \
LSF_FLAG(lsfAllowTrustLineClawback, 0x80000000)) /* True, enable clawback */ \
\
LEDGER_OBJECT(Offer, \
LSF_FLAG(lsfPassive, 0x00010000) \
LSF_FLAG(lsfSell, 0x00020000) /* True, offer was placed as a sell. */ \
LSF_FLAG(lsfHybrid, 0x00040000)) /* True, offer is hybrid. */ \
\
LEDGER_OBJECT(RippleState, \
LSF_FLAG(lsfLowReserve, 0x00010000) /* True, if entry counts toward reserve. */ \
LSF_FLAG(lsfHighReserve, 0x00020000) \
LSF_FLAG(lsfLowAuth, 0x00040000) \
LSF_FLAG(lsfHighAuth, 0x00080000) \
LSF_FLAG(lsfLowNoRipple, 0x00100000) \
LSF_FLAG(lsfHighNoRipple, 0x00200000) \
LSF_FLAG(lsfLowFreeze, 0x00400000) /* True, low side has set freeze flag */ \
LSF_FLAG(lsfHighFreeze, 0x00800000) /* True, high side has set freeze flag */ \
LSF_FLAG(lsfAMMNode, 0x01000000) /* True, trust line to AMM. */ \
/* Used by client apps to identify payments via AMM. */ \
LSF_FLAG(lsfLowDeepFreeze, 0x02000000) /* True, low side has set deep freeze flag */ \
LSF_FLAG(lsfHighDeepFreeze, 0x04000000)) /* True, high side has set deep freeze flag */ \
\
LEDGER_OBJECT(SignerList, \
LSF_FLAG(lsfOneOwnerCount, 0x00010000)) /* True, uses only one OwnerCount */ \
\
LEDGER_OBJECT(DirNode, \
LSF_FLAG(lsfNFTokenBuyOffers, 0x00000001) \
LSF_FLAG(lsfNFTokenSellOffers, 0x00000002)) \
\
LEDGER_OBJECT(NFTokenOffer, \
LSF_FLAG(lsfSellNFToken, 0x00000001)) \
\
LEDGER_OBJECT(MPTokenIssuance, \
LSF_FLAG(lsfMPTLocked, 0x00000001) /* Also used in ltMPTOKEN */ \
LSF_FLAG(lsfMPTCanLock, 0x00000002) \
LSF_FLAG(lsfMPTRequireAuth, 0x00000004) \
LSF_FLAG(lsfMPTCanEscrow, 0x00000008) \
LSF_FLAG(lsfMPTCanTrade, 0x00000010) \
LSF_FLAG(lsfMPTCanTransfer, 0x00000020) \
LSF_FLAG(lsfMPTCanClawback, 0x00000040)) \
\
LEDGER_OBJECT(MPTokenIssuanceMutable, \
LSF_FLAG(lsmfMPTCanMutateCanLock, 0x00000002) \
LSF_FLAG(lsmfMPTCanMutateRequireAuth, 0x00000004) \
LSF_FLAG(lsmfMPTCanMutateCanEscrow, 0x00000008) \
LSF_FLAG(lsmfMPTCanMutateCanTrade, 0x00000010) \
LSF_FLAG(lsmfMPTCanMutateCanTransfer, 0x00000020) \
LSF_FLAG(lsmfMPTCanMutateCanClawback, 0x00000040) \
LSF_FLAG(lsmfMPTCanMutateMetadata, 0x00010000) \
LSF_FLAG(lsmfMPTCanMutateTransferFee, 0x00020000)) \
\
LEDGER_OBJECT(MPToken, \
LSF_FLAG2(lsfMPTLocked, 0x00000001) \
LSF_FLAG(lsfMPTAuthorized, 0x00000002)) \
\
LEDGER_OBJECT(Credential, \
LSF_FLAG(lsfAccepted, 0x00010000)) \
\
LEDGER_OBJECT(Vault, \
LSF_FLAG(lsfVaultPrivate, 0x00010000)) \
\
LEDGER_OBJECT(Loan, \
LSF_FLAG(lsfLoanDefault, 0x00010000) \
LSF_FLAG(lsfLoanImpaired, 0x00020000) \
LSF_FLAG(lsfLoanOverpayment, 0x00040000)) /* True, loan allows overpayments */
// ltNFTOKEN_OFFER
lsfSellNFToken = 0x00000001,
// clang-format on
// ltMPTOKEN_ISSUANCE
lsfMPTLocked = 0x00000001, // Also used in ltMPTOKEN
lsfMPTCanLock = 0x00000002,
lsfMPTRequireAuth = 0x00000004,
lsfMPTCanEscrow = 0x00000008,
lsfMPTCanTrade = 0x00000010,
lsfMPTCanTransfer = 0x00000020,
lsfMPTCanClawback = 0x00000040,
// Create all the flag values as an enum.
//
// example:
// enum LedgerSpecificFlags {
// lsfPasswordSpent = 0x00010000,
// lsfRequireDestTag = 0x00020000,
// ...
// };
#define TO_VALUE(name, value) name = value,
#define NULL_NAME(name, values) values
#define NULL_OUTPUT(name, value)
enum LedgerSpecificFlags : std::uint32_t { XMACRO(NULL_NAME, TO_VALUE, NULL_OUTPUT) };
lsmfMPTCanMutateCanLock = 0x00000002,
lsmfMPTCanMutateRequireAuth = 0x00000004,
lsmfMPTCanMutateCanEscrow = 0x00000008,
lsmfMPTCanMutateCanTrade = 0x00000010,
lsmfMPTCanMutateCanTransfer = 0x00000020,
lsmfMPTCanMutateCanClawback = 0x00000040,
lsmfMPTCanMutateMetadata = 0x00010000,
lsmfMPTCanMutateTransferFee = 0x00020000,
// Create getter functions for each set of flags using Meyer's singleton pattern.
// This avoids static initialization order fiasco while still providing efficient access.
// This is used below in `getAllLedgerFlags()` to generate the server_definitions RPC output.
//
// example:
// inline LedgerFlagMap const& getAccountRootFlags() {
// static LedgerFlagMap const flags = {
// {"lsfPasswordSpent", 0x00010000},
// {"lsfRequireDestTag", 0x00020000},
// ...};
// return flags;
// }
using LedgerFlagMap = std::map<std::string, std::uint32_t>;
#define VALUE_TO_MAP(name, value) {#name, value},
#define TO_MAP(name, values) \
inline LedgerFlagMap const& get##name##Flags() \
{ \
static LedgerFlagMap const flags = {values}; \
return flags; \
}
XMACRO(TO_MAP, VALUE_TO_MAP, VALUE_TO_MAP)
// ltMPTOKEN
lsfMPTAuthorized = 0x00000002,
// Create a getter function for all ledger flag maps using Meyer's singleton pattern.
// This is used to generate the server_definitions RPC output.
//
// example:
// inline std::vector<std::pair<std::string, LedgerFlagMap>> const& getAllLedgerFlags() {
// static std::vector<std::pair<std::string, LedgerFlagMap>> const flags = {
// {"AccountRoot", getAccountRootFlags()},
// ...};
// return flags;
// }
#define ALL_LEDGER_FLAGS(name, values) {#name, get##name##Flags()},
inline std::vector<std::pair<std::string, LedgerFlagMap>> const&
getAllLedgerFlags()
{
static std::vector<std::pair<std::string, LedgerFlagMap>> const flags = {
XMACRO(ALL_LEDGER_FLAGS, NULL_OUTPUT, NULL_OUTPUT)};
return flags;
}
// ltCREDENTIAL
lsfAccepted = 0x00010000,
#undef XMACRO
#undef TO_VALUE
#undef VALUE_TO_MAP
#undef NULL_NAME
#undef NULL_OUTPUT
#undef TO_MAP
#undef ALL_LEDGER_FLAGS
// ltVAULT
lsfVaultPrivate = 0x00010000,
// ltLOAN
lsfLoanDefault = 0x00010000,
lsfLoanImpaired = 0x00020000,
lsfLoanOverpayment = 0x00040000, // True, loan allows overpayments
};
#pragma pop_macro("XMACRO")
#pragma pop_macro("TO_VALUE")
#pragma pop_macro("VALUE_TO_MAP")
#pragma pop_macro("NULL_NAME")
#pragma pop_macro("TO_MAP")
#pragma pop_macro("ALL_LEDGER_FLAGS")
//------------------------------------------------------------------------------
@@ -207,6 +286,10 @@ private:
public:
static LedgerFormats const&
getInstance();
// Fields shared by all ledger entry formats:
static std::vector<SOElement> const&
getCommonFields();
};
} // namespace xrpl

2
include/xrpl/protocol/Permissions.h
View File

@@ -65,7 +65,7 @@ public:
std::optional<TxType>
getGranularTxType(GranularPermissionType const& gpType) const;
std::optional<std::reference_wrapper<uint256 const>> const
std::optional<std::reference_wrapper<uint256 const>>
getTxFeature(TxType txType) const;
bool

2
include/xrpl/protocol/Protocol.h
View File

@@ -209,7 +209,7 @@ std::size_t constexpr maxDIDDocumentLength = 256;
std::size_t constexpr maxDIDURILength = 256;
/** The maximum length of an Attestation inside a DID */
std::size_t constexpr maxDIDAttestationLength = 256;
std::size_t constexpr maxDIDDataLength = 256;
/** The maximum length of a domain */
std::size_t constexpr maxDomainLength = 256;

2
include/xrpl/protocol/PublicKey.h
View File

@@ -44,7 +44,7 @@ protected:
// All the constructed public keys are valid, non-empty and contain 33
// bytes of data.
static constexpr std::size_t size_ = 33;
std::uint8_t buf_[size_]; // should be large enough
std::uint8_t buf_[size_]{}; // should be large enough
public:
using const_iterator = std::uint8_t const*;

9
include/xrpl/protocol/SOTemplate.h
View File

@@ -6,6 +6,7 @@
#include <functional>
#include <initializer_list>
#include <stdexcept>
#include <vector>
namespace xrpl {
@@ -97,8 +98,12 @@ public:
operator=(SOTemplate&& other) = default;
/** Create a template populated with all fields.
After creating the template fields cannot be
added, modified, or removed.
After creating the template fields cannot be added, modified, or removed.
*/
SOTemplate(std::vector<SOElement> uniqueFields, std::vector<SOElement> commonFields = {});
/** Create a template populated with all fields.
Note: Defers to the vector constructor above.
*/
SOTemplate(
std::initializer_list<SOElement> uniqueFields,

2
include/xrpl/protocol/STAccount.h
View File

@@ -24,7 +24,7 @@ public:
STAccount();
STAccount(SField const& n);
STAccount(SField const& n, Buffer&& v);
STAccount(SField const& n, Buffer const& v);
STAccount(SerialIter& sit, SField const& name);
STAccount(SField const& n, AccountID const& v);

4
include/xrpl/protocol/STObject.h
View File

@@ -57,7 +57,7 @@ class STObject : public STBase, public CountedObject<STObject>
using list_type = std::vector<detail::STVar>;
list_type v_;
SOTemplate const* mType;
SOTemplate const* mType{};
public:
using iterator = boost::transform_iterator<Transform, STObject::list_type::const_iterator>;
@@ -401,7 +401,7 @@ public:
getStyle(SField const& field) const;
bool
hasMatchingEntry(STBase const&);
hasMatchingEntry(STBase const&) const;
bool
operator==(STObject const& o) const;

7
include/xrpl/protocol/STTx.h
View File

@@ -15,7 +15,7 @@
namespace xrpl {
enum TxnSql : char {
enum class TxnSql : char {
txnSqlNew = 'N',
txnSqlConflict = 'C',
txnSqlHeld = 'H',
@@ -83,6 +83,9 @@ public:
std::uint32_t
getSeqValue() const;
AccountID
getFeePayer() const;
boost::container::flat_set<AccountID>
getMentionedAccounts() const;
@@ -122,7 +125,7 @@ public:
getMetaSQL(
Serializer rawTxn,
std::uint32_t inLedger,
char status,
TxnSql status,
std::string const& escapedMetaData) const;
std::vector<uint256> const&

22
include/xrpl/protocol/SecretKey.h
View File

@@ -16,8 +16,11 @@ namespace xrpl {
/** A secret key. */
class SecretKey
{
public:
static constexpr std::size_t size_ = 32;
private:
std::uint8_t buf_[32];
std::uint8_t buf_[size_]{};
public:
using const_iterator = std::uint8_t const*;
@@ -27,9 +30,14 @@ public:
SecretKey&
operator=(SecretKey const&) = default;
bool
operator==(SecretKey const&) = delete;
bool
operator!=(SecretKey const&) = delete;
~SecretKey();
SecretKey(std::array<std::uint8_t, 32> const& data);
SecretKey(std::array<std::uint8_t, size_> const& data);
SecretKey(Slice const& slice);
std::uint8_t const*
@@ -78,16 +86,10 @@ public:
};
inline bool
operator==(SecretKey const& lhs, SecretKey const& rhs)
{
return lhs.size() == rhs.size() && std::memcmp(lhs.data(), rhs.data(), rhs.size()) == 0;
}
operator==(SecretKey const& lhs, SecretKey const& rhs) = delete;
inline bool
operator!=(SecretKey const& lhs, SecretKey const& rhs)
{
return !(lhs == rhs);
}
operator!=(SecretKey const& lhs, SecretKey const& rhs) = delete;
//------------------------------------------------------------------------------

2
include/xrpl/protocol/Seed.h
View File

@@ -13,7 +13,7 @@ namespace xrpl {
class Seed
{
private:
std::array<uint8_t, 16> buf_;
std::array<uint8_t, 16> buf_{};
public:
using const_iterator = std::array<uint8_t, 16>::const_iterator;

2
include/xrpl/protocol/SystemParameters.h
View File

@@ -14,7 +14,7 @@ namespace xrpl {
static inline std::string const&
systemName()
{
static std::string const name = "ripple";
static std::string const name = "xrpld";
return name;
}

680
include/xrpl/protocol/TxFlags.h
View File

@@ -3,294 +3,444 @@
#include <xrpl/protocol/LedgerFormats.h>
#include <cstdint>
#include <map>
#include <string>
#include <utility>
#include <vector>
namespace xrpl {
/** Transaction flags.
These flags are specified in a transaction's 'Flags' field and modify the
behavior of that transaction.
These flags are specified in a transaction's 'Flags' field and modify
the behavior of that transaction.
There are two types of flags:
(1) Universal flags: these are flags which apply to, and are interpreted
the same way by, all transactions, except, perhaps,
to special pseudo-transactions.
(1) Universal flags: these are flags which apply to, and are interpreted the same way by,
all transactions, except, perhaps, to special pseudo-transactions.
(2) Tx-Specific flags: these are flags which are interpreted according
to the type of the transaction being executed.
That is, the same numerical flag value may have
different effects, depending on the transaction
being executed.
(2) Tx-Specific flags: these are flags which are interpreted according to the type of the
transaction being executed. That is, the same numerical flag value may have different
effects, depending on the transaction being executed.
@note The universal transaction flags occupy the high-order 8 bits. The
tx-specific flags occupy the remaining 24 bits.
@note The universal transaction flags occupy the high-order 8 bits.
The tx-specific flags occupy the remaining 24 bits.
@warning Transaction flags form part of the protocol. **Changing them
should be avoided because without special handling, this will
result in a hard fork.**
@warning Transaction flags form part of the protocol.
**Changing them should be avoided because without special handling, this will result in
a hard fork.**
@ingroup protocol
*/
// Formatting equals sign aligned 4 spaces after longest prefix, except for
// wrapped lines
// clang-format off
using FlagValue = std::uint32_t;
// Universal Transaction flags:
constexpr std::uint32_t tfFullyCanonicalSig = 0x80000000;
constexpr std::uint32_t tfInnerBatchTxn = 0x40000000;
constexpr std::uint32_t tfUniversal = tfFullyCanonicalSig | tfInnerBatchTxn;
constexpr std::uint32_t tfUniversalMask = ~tfUniversal;
inline constexpr FlagValue tfFullyCanonicalSig = 0x80000000;
inline constexpr FlagValue tfInnerBatchTxn = 0x40000000;
inline constexpr FlagValue tfUniversal = tfFullyCanonicalSig | tfInnerBatchTxn;
inline constexpr FlagValue tfUniversalMask = ~tfUniversal;
// AccountSet flags:
constexpr std::uint32_t tfRequireDestTag = 0x00010000;
constexpr std::uint32_t tfOptionalDestTag = 0x00020000;
constexpr std::uint32_t tfRequireAuth = 0x00040000;
constexpr std::uint32_t tfOptionalAuth = 0x00080000;
constexpr std::uint32_t tfDisallowXRP = 0x00100000;
constexpr std::uint32_t tfAllowXRP = 0x00200000;
constexpr std::uint32_t tfAccountSetMask =
~(tfUniversal | tfRequireDestTag | tfOptionalDestTag | tfRequireAuth |
tfOptionalAuth | tfDisallowXRP | tfAllowXRP);
#pragma push_macro("XMACRO")
#pragma push_macro("TO_VALUE")
#pragma push_macro("VALUE_TO_MAP")
#pragma push_macro("NULL_NAME")
#pragma push_macro("NULL_OUTPUT")
#pragma push_macro("TO_MAP")
#pragma push_macro("TO_MASK")
#pragma push_macro("VALUE_TO_MASK")
#pragma push_macro("ALL_TX_FLAGS")
#pragma push_macro("NULL_MASK_ADJ")
#pragma push_macro("MASK_ADJ_TO_MASK")
// AccountSet SetFlag/ClearFlag values
constexpr std::uint32_t asfRequireDest = 1;
constexpr std::uint32_t asfRequireAuth = 2;
constexpr std::uint32_t asfDisallowXRP = 3;
constexpr std::uint32_t asfDisableMaster = 4;
constexpr std::uint32_t asfAccountTxnID = 5;
constexpr std::uint32_t asfNoFreeze = 6;
constexpr std::uint32_t asfGlobalFreeze = 7;
constexpr std::uint32_t asfDefaultRipple = 8;
constexpr std::uint32_t asfDepositAuth = 9;
constexpr std::uint32_t asfAuthorizedNFTokenMinter = 10;
/* // reserved for Hooks amendment
constexpr std::uint32_t asfTshCollect = 11;
*/
constexpr std::uint32_t asfDisallowIncomingNFTokenOffer = 12;
constexpr std::uint32_t asfDisallowIncomingCheck = 13;
constexpr std::uint32_t asfDisallowIncomingPayChan = 14;
constexpr std::uint32_t asfDisallowIncomingTrustline = 15;
constexpr std::uint32_t asfAllowTrustLineClawback = 16;
constexpr std::uint32_t asfAllowTrustLineLocking = 17;
#undef XMACRO
#undef TO_VALUE
#undef VALUE_TO_MAP
#undef NULL_NAME
#undef NULL_OUTPUT
#undef TO_MAP
#undef TO_MASK
#undef VALUE_TO_MASK
#undef NULL_MASK_ADJ
#undef MASK_ADJ_TO_MASK
// OfferCreate flags:
constexpr std::uint32_t tfPassive = 0x00010000;
constexpr std::uint32_t tfImmediateOrCancel = 0x00020000;
constexpr std::uint32_t tfFillOrKill = 0x00040000;
constexpr std::uint32_t tfSell = 0x00080000;
constexpr std::uint32_t tfHybrid = 0x00100000;
constexpr std::uint32_t tfOfferCreateMask =
~(tfUniversal | tfPassive | tfImmediateOrCancel | tfFillOrKill | tfSell | tfHybrid);
// clang-format off
#undef ALL_TX_FLAGS
// Payment flags:
constexpr std::uint32_t tfNoRippleDirect = 0x00010000;
constexpr std::uint32_t tfPartialPayment = 0x00020000;
constexpr std::uint32_t tfLimitQuality = 0x00040000;
constexpr std::uint32_t tfPaymentMask =
~(tfUniversal | tfPartialPayment | tfLimitQuality | tfNoRippleDirect);
constexpr std::uint32_t tfMPTPaymentMask = ~(tfUniversal | tfPartialPayment);
// TrustSet flags:
constexpr std::uint32_t tfSetfAuth = 0x00010000;
constexpr std::uint32_t tfSetNoRipple = 0x00020000;
constexpr std::uint32_t tfClearNoRipple = 0x00040000;
constexpr std::uint32_t tfSetFreeze = 0x00100000;
constexpr std::uint32_t tfClearFreeze = 0x00200000;
constexpr std::uint32_t tfSetDeepFreeze = 0x00400000;
constexpr std::uint32_t tfClearDeepFreeze = 0x00800000;
constexpr std::uint32_t tfTrustSetMask =
~(tfUniversal | tfSetfAuth | tfSetNoRipple | tfClearNoRipple | tfSetFreeze |
tfClearFreeze | tfSetDeepFreeze | tfClearDeepFreeze);
constexpr std::uint32_t tfTrustSetPermissionMask = ~(tfUniversal | tfSetfAuth | tfSetFreeze | tfClearFreeze);
// EnableAmendment flags:
constexpr std::uint32_t tfGotMajority = 0x00010000;
constexpr std::uint32_t tfLostMajority = 0x00020000;
constexpr std::uint32_t tfChangeMask =
~( tfUniversal | tfGotMajority | tfLostMajority);
// PaymentChannelClaim flags:
constexpr std::uint32_t tfRenew = 0x00010000;
constexpr std::uint32_t tfClose = 0x00020000;
constexpr std::uint32_t tfPayChanClaimMask = ~(tfUniversal | tfRenew | tfClose);
// NFTokenMint flags:
constexpr std::uint32_t const tfBurnable = 0x00000001;
constexpr std::uint32_t const tfOnlyXRP = 0x00000002;
constexpr std::uint32_t const tfTrustLine = 0x00000004;
constexpr std::uint32_t const tfTransferable = 0x00000008;
constexpr std::uint32_t const tfMutable = 0x00000010;
// MPTokenIssuanceCreate flags:
// Note: tf/lsfMPTLocked is intentionally omitted, since this transaction
// is not allowed to modify it.
constexpr std::uint32_t const tfMPTCanLock = lsfMPTCanLock;
constexpr std::uint32_t const tfMPTRequireAuth = lsfMPTRequireAuth;
constexpr std::uint32_t const tfMPTCanEscrow = lsfMPTCanEscrow;
constexpr std::uint32_t const tfMPTCanTrade = lsfMPTCanTrade;
constexpr std::uint32_t const tfMPTCanTransfer = lsfMPTCanTransfer;
constexpr std::uint32_t const tfMPTCanClawback = lsfMPTCanClawback;
constexpr std::uint32_t const tfMPTokenIssuanceCreateMask =
~(tfUniversal | tfMPTCanLock | tfMPTRequireAuth | tfMPTCanEscrow | tfMPTCanTrade | tfMPTCanTransfer | tfMPTCanClawback);
// MPTokenIssuanceCreate MutableFlags:
// Indicating specific fields or flags may be changed after issuance.
constexpr std::uint32_t const tmfMPTCanMutateCanLock = lsmfMPTCanMutateCanLock;
constexpr std::uint32_t const tmfMPTCanMutateRequireAuth = lsmfMPTCanMutateRequireAuth;
constexpr std::uint32_t const tmfMPTCanMutateCanEscrow = lsmfMPTCanMutateCanEscrow;
constexpr std::uint32_t const tmfMPTCanMutateCanTrade = lsmfMPTCanMutateCanTrade;
constexpr std::uint32_t const tmfMPTCanMutateCanTransfer = lsmfMPTCanMutateCanTransfer;
constexpr std::uint32_t const tmfMPTCanMutateCanClawback = lsmfMPTCanMutateCanClawback;
constexpr std::uint32_t const tmfMPTCanMutateMetadata = lsmfMPTCanMutateMetadata;
constexpr std::uint32_t const tmfMPTCanMutateTransferFee = lsmfMPTCanMutateTransferFee;
constexpr std::uint32_t const tmfMPTokenIssuanceCreateMutableMask =
~(tmfMPTCanMutateCanLock | tmfMPTCanMutateRequireAuth | tmfMPTCanMutateCanEscrow | tmfMPTCanMutateCanTrade
| tmfMPTCanMutateCanTransfer | tmfMPTCanMutateCanClawback | tmfMPTCanMutateMetadata | tmfMPTCanMutateTransferFee);
// MPTokenAuthorize flags:
constexpr std::uint32_t const tfMPTUnauthorize = 0x00000001;
constexpr std::uint32_t const tfMPTokenAuthorizeMask = ~(tfUniversal | tfMPTUnauthorize);
// MPTokenIssuanceSet flags:
constexpr std::uint32_t const tfMPTLock = 0x00000001;
constexpr std::uint32_t const tfMPTUnlock = 0x00000002;
constexpr std::uint32_t const tfMPTokenIssuanceSetMask = ~(tfUniversal | tfMPTLock | tfMPTUnlock);
constexpr std::uint32_t const tfMPTokenIssuanceSetPermissionMask = ~(tfUniversal | tfMPTLock | tfMPTUnlock);
// MPTokenIssuanceSet MutableFlags:
// Set or Clear flags.
constexpr std::uint32_t const tmfMPTSetCanLock = 0x00000001;
constexpr std::uint32_t const tmfMPTClearCanLock = 0x00000002;
constexpr std::uint32_t const tmfMPTSetRequireAuth = 0x00000004;
constexpr std::uint32_t const tmfMPTClearRequireAuth = 0x00000008;
constexpr std::uint32_t const tmfMPTSetCanEscrow = 0x00000010;
constexpr std::uint32_t const tmfMPTClearCanEscrow = 0x00000020;
constexpr std::uint32_t const tmfMPTSetCanTrade = 0x00000040;
constexpr std::uint32_t const tmfMPTClearCanTrade = 0x00000080;
constexpr std::uint32_t const tmfMPTSetCanTransfer = 0x00000100;
constexpr std::uint32_t const tmfMPTClearCanTransfer = 0x00000200;
constexpr std::uint32_t const tmfMPTSetCanClawback = 0x00000400;
constexpr std::uint32_t const tmfMPTClearCanClawback = 0x00000800;
constexpr std::uint32_t const tmfMPTokenIssuanceSetMutableMask = ~(tmfMPTSetCanLock | tmfMPTClearCanLock |
tmfMPTSetRequireAuth | tmfMPTClearRequireAuth | tmfMPTSetCanEscrow | tmfMPTClearCanEscrow |
tmfMPTSetCanTrade | tmfMPTClearCanTrade | tmfMPTSetCanTransfer | tmfMPTClearCanTransfer |
tmfMPTSetCanClawback | tmfMPTClearCanClawback);
// MPTokenIssuanceDestroy flags:
constexpr std::uint32_t const tfMPTokenIssuanceDestroyMask = ~tfUniversal;
// Prior to fixRemoveNFTokenAutoTrustLine, transfer of an NFToken between
// accounts allowed a TrustLine to be added to the issuer of that token
// without explicit permission from that issuer. This was enabled by
// minting the NFToken with the tfTrustLine flag set.
// XMACRO parameters:
// - TRANSACTION: handles the transaction name, its flags, and mask adjustment
// - TF_FLAG: defines a new flag constant
// - TF_FLAG2: references an existing flag constant (no new definition)
// - MASK_ADJ: specifies flags to add back to the mask (making them invalid for this tx type)
//
// That capability could be used to attack the NFToken issuer. It
// would be possible for two accounts to trade the NFToken back and forth
// building up any number of TrustLines on the issuer, increasing the
// issuer's reserve without bound.
// Note: MASK_ADJ is used when a universal flag should be invalid for a specific transaction.
// For example, Batch uses MASK_ADJ(tfInnerBatchTxn) because the outer Batch transaction
// must not have tfInnerBatchTxn set (only inner transactions should have it).
//
// The fixRemoveNFTokenAutoTrustLine amendment disables minting with the
// tfTrustLine flag as a way to prevent the attack. But until the
// amendment passes we still need to keep the old behavior available.
constexpr std::uint32_t const tfNFTokenMintMask =
~(tfUniversal | tfBurnable | tfOnlyXRP | tfTransferable);
constexpr std::uint32_t const tfNFTokenMintOldMask =
~( ~tfNFTokenMintMask | tfTrustLine);
// if featureDynamicNFT enabled then new flag allowing mutable URI available.
constexpr std::uint32_t const tfNFTokenMintOldMaskWithMutable =
~( ~tfNFTokenMintOldMask | tfMutable);
constexpr std::uint32_t const tfNFTokenMintMaskWithMutable =
~( ~tfNFTokenMintMask | tfMutable);
// NFTokenCreateOffer flags:
constexpr std::uint32_t const tfSellNFToken = 0x00000001;
constexpr std::uint32_t const tfNFTokenCreateOfferMask =
~(tfUniversal | tfSellNFToken);
// NFTokenCancelOffer flags:
constexpr std::uint32_t const tfNFTokenCancelOfferMask = ~tfUniversal;
// NFTokenAcceptOffer flags:
constexpr std::uint32_t const tfNFTokenAcceptOfferMask = ~tfUniversal;
// Clawback flags:
constexpr std::uint32_t const tfClawbackMask = ~tfUniversal;
// AMM Flags:
constexpr std::uint32_t tfLPToken = 0x00010000;
constexpr std::uint32_t tfWithdrawAll = 0x00020000;
constexpr std::uint32_t tfOneAssetWithdrawAll = 0x00040000;
constexpr std::uint32_t tfSingleAsset = 0x00080000;
constexpr std::uint32_t tfTwoAsset = 0x00100000;
constexpr std::uint32_t tfOneAssetLPToken = 0x00200000;
constexpr std::uint32_t tfLimitLPToken = 0x00400000;
constexpr std::uint32_t tfTwoAssetIfEmpty = 0x00800000;
constexpr std::uint32_t tfWithdrawSubTx =
tfLPToken | tfSingleAsset | tfTwoAsset | tfOneAssetLPToken |
tfLimitLPToken | tfWithdrawAll | tfOneAssetWithdrawAll;
constexpr std::uint32_t tfDepositSubTx =
tfLPToken | tfSingleAsset | tfTwoAsset | tfOneAssetLPToken |
tfLimitLPToken | tfTwoAssetIfEmpty;
constexpr std::uint32_t tfWithdrawMask = ~(tfUniversal | tfWithdrawSubTx);
constexpr std::uint32_t tfDepositMask = ~(tfUniversal | tfDepositSubTx);
// AMMClawback flags:
constexpr std::uint32_t tfClawTwoAssets = 0x00000001;
constexpr std::uint32_t tfAMMClawbackMask = ~(tfUniversal | tfClawTwoAssets);
// BridgeModify flags:
constexpr std::uint32_t tfClearAccountCreateAmount = 0x00010000;
constexpr std::uint32_t tfBridgeModifyMask = ~(tfUniversal | tfClearAccountCreateAmount);
// VaultCreate flags:
constexpr std::uint32_t const tfVaultPrivate = 0x00010000;
static_assert(tfVaultPrivate == lsfVaultPrivate);
constexpr std::uint32_t const tfVaultShareNonTransferable = 0x00020000;
constexpr std::uint32_t const tfVaultCreateMask = ~(tfUniversal | tfVaultPrivate | tfVaultShareNonTransferable);
// Batch Flags:
constexpr std::uint32_t tfAllOrNothing = 0x00010000;
constexpr std::uint32_t tfOnlyOne = 0x00020000;
constexpr std::uint32_t tfUntilFailure = 0x00040000;
constexpr std::uint32_t tfIndependent = 0x00080000;
/**
* @note If nested Batch transactions are supported in the future, the tfInnerBatchTxn flag
* will need to be removed from this mask to allow Batch transaction to be inside
* the sfRawTransactions array.
*/
constexpr std::uint32_t const tfBatchMask =
~(tfUniversal | tfAllOrNothing | tfOnlyOne | tfUntilFailure | tfIndependent) | tfInnerBatchTxn;
// LoanSet and LoanPay flags:
// LoanSet: True, indicates the loan supports overpayments
// LoanPay: True, indicates any excess in this payment can be used
// as an overpayment. False, no overpayments will be taken.
constexpr std::uint32_t const tfLoanOverpayment = 0x00010000;
// LoanPay exclusive flags:
// tfLoanFullPayment: True, indicates that the payment is an early
// full payment. It must pay the entire loan including close
// interest and fees, or it will fail. False: Not a full payment.
constexpr std::uint32_t const tfLoanFullPayment = 0x00020000;
// tfLoanLatePayment: True, indicates that the payment is late,
// and includes late interest and fees. If the loan is not late,
// it will fail. False: not a late payment. If the current payment
// is overdue, the transaction will fail.
constexpr std::uint32_t const tfLoanLatePayment = 0x00040000;
constexpr std::uint32_t const tfLoanSetMask = ~(tfUniversal |
tfLoanOverpayment);
constexpr std::uint32_t const tfLoanPayMask = ~(tfUniversal |
tfLoanOverpayment | tfLoanFullPayment | tfLoanLatePayment);
// LoanManage flags:
constexpr std::uint32_t const tfLoanDefault = 0x00010000;
constexpr std::uint32_t const tfLoanImpair = 0x00020000;
constexpr std::uint32_t const tfLoanUnimpair = 0x00040000;
constexpr std::uint32_t const tfLoanManageMask = ~(tfUniversal | tfLoanDefault | tfLoanImpair | tfLoanUnimpair);
// TODO: Consider rewriting this using reflection in C++26 or later. Alternatively this could be a DSL processed by a script at build time.
#define XMACRO(TRANSACTION, TF_FLAG, TF_FLAG2, MASK_ADJ) \
TRANSACTION(AccountSet, \
TF_FLAG(tfRequireDestTag, 0x00010000) \
TF_FLAG(tfOptionalDestTag, 0x00020000) \
TF_FLAG(tfRequireAuth, 0x00040000) \
TF_FLAG(tfOptionalAuth, 0x00080000) \
TF_FLAG(tfDisallowXRP, 0x00100000) \
TF_FLAG(tfAllowXRP, 0x00200000), \
MASK_ADJ(0)) \
\
TRANSACTION(OfferCreate, \
TF_FLAG(tfPassive, 0x00010000) \
TF_FLAG(tfImmediateOrCancel, 0x00020000) \
TF_FLAG(tfFillOrKill, 0x00040000) \
TF_FLAG(tfSell, 0x00080000) \
TF_FLAG(tfHybrid, 0x00100000), \
MASK_ADJ(0)) \
\
TRANSACTION(Payment, \
TF_FLAG(tfNoRippleDirect, 0x00010000) \
TF_FLAG(tfPartialPayment, 0x00020000) \
TF_FLAG(tfLimitQuality, 0x00040000), \
MASK_ADJ(0)) \
\
TRANSACTION(TrustSet, \
TF_FLAG(tfSetfAuth, 0x00010000) \
TF_FLAG(tfSetNoRipple, 0x00020000) \
TF_FLAG(tfClearNoRipple, 0x00040000) \
TF_FLAG(tfSetFreeze, 0x00100000) \
TF_FLAG(tfClearFreeze, 0x00200000) \
TF_FLAG(tfSetDeepFreeze, 0x00400000) \
TF_FLAG(tfClearDeepFreeze, 0x00800000), \
MASK_ADJ(0)) \
\
TRANSACTION(EnableAmendment, \
TF_FLAG(tfGotMajority, 0x00010000) \
TF_FLAG(tfLostMajority, 0x00020000), \
MASK_ADJ(0)) \
\
TRANSACTION(PaymentChannelClaim, \
TF_FLAG(tfRenew, 0x00010000) \
TF_FLAG(tfClose, 0x00020000), \
MASK_ADJ(0)) \
\
TRANSACTION(NFTokenMint, \
TF_FLAG(tfBurnable, 0x00000001) \
TF_FLAG(tfOnlyXRP, 0x00000002) \
/* deprecated TF_FLAG(tfTrustLine, 0x00000004) */ \
TF_FLAG(tfTransferable, 0x00000008) \
TF_FLAG(tfMutable, 0x00000010), \
MASK_ADJ(0)) \
\
TRANSACTION(MPTokenIssuanceCreate, \
/* Note: tf/lsfMPTLocked is intentionally omitted since this transaction is not allowed to modify it. */ \
TF_FLAG(tfMPTCanLock, lsfMPTCanLock) \
TF_FLAG(tfMPTRequireAuth, lsfMPTRequireAuth) \
TF_FLAG(tfMPTCanEscrow, lsfMPTCanEscrow) \
TF_FLAG(tfMPTCanTrade, lsfMPTCanTrade) \
TF_FLAG(tfMPTCanTransfer, lsfMPTCanTransfer) \
TF_FLAG(tfMPTCanClawback, lsfMPTCanClawback), \
MASK_ADJ(0)) \
\
TRANSACTION(MPTokenAuthorize, \
TF_FLAG(tfMPTUnauthorize, 0x00000001), \
MASK_ADJ(0)) \
\
TRANSACTION(MPTokenIssuanceSet, \
TF_FLAG(tfMPTLock, 0x00000001) \
TF_FLAG(tfMPTUnlock, 0x00000002), \
MASK_ADJ(0)) \
\
TRANSACTION(NFTokenCreateOffer, \
TF_FLAG(tfSellNFToken, 0x00000001), \
MASK_ADJ(0)) \
\
TRANSACTION(AMMDeposit, \
TF_FLAG(tfLPToken, 0x00010000) \
TF_FLAG(tfSingleAsset, 0x00080000) \
TF_FLAG(tfTwoAsset, 0x00100000) \
TF_FLAG(tfOneAssetLPToken, 0x00200000) \
TF_FLAG(tfLimitLPToken, 0x00400000) \
TF_FLAG(tfTwoAssetIfEmpty, 0x00800000), \
MASK_ADJ(0)) \
\
TRANSACTION(AMMWithdraw, \
TF_FLAG2(tfLPToken, 0x00010000) \
TF_FLAG(tfWithdrawAll, 0x00020000) \
TF_FLAG(tfOneAssetWithdrawAll, 0x00040000) \
TF_FLAG2(tfSingleAsset, 0x00080000) \
TF_FLAG2(tfTwoAsset, 0x00100000) \
TF_FLAG2(tfOneAssetLPToken, 0x00200000) \
TF_FLAG2(tfLimitLPToken, 0x00400000), \
MASK_ADJ(0)) \
\
TRANSACTION(AMMClawback, \
TF_FLAG(tfClawTwoAssets, 0x00000001), \
MASK_ADJ(0)) \
\
TRANSACTION(XChainModifyBridge, \
TF_FLAG(tfClearAccountCreateAmount, 0x00010000), \
MASK_ADJ(0)) \
\
TRANSACTION(VaultCreate, \
TF_FLAG(tfVaultPrivate, lsfVaultPrivate) \
TF_FLAG(tfVaultShareNonTransferable, 0x00020000), \
MASK_ADJ(0)) \
\
TRANSACTION(Batch, \
TF_FLAG(tfAllOrNothing, 0x00010000) \
TF_FLAG(tfOnlyOne, 0x00020000) \
TF_FLAG(tfUntilFailure, 0x00040000) \
TF_FLAG(tfIndependent, 0x00080000), \
MASK_ADJ(tfInnerBatchTxn)) /* Batch must reject tfInnerBatchTxn - only inner transactions should have this flag */ \
\
TRANSACTION(LoanSet, /* True indicates the loan supports overpayments */ \
TF_FLAG(tfLoanOverpayment, 0x00010000), \
MASK_ADJ(0)) \
\
TRANSACTION(LoanPay, /* True indicates any excess in this payment can be used as an overpayment. */ \
/* False: no overpayments will be taken. */ \
TF_FLAG2(tfLoanOverpayment, 0x00010000) \
TF_FLAG(tfLoanFullPayment, 0x00020000) /* True indicates that the payment is an early full payment. */ \
/* It must pay the entire loan including close interest and fees, or it will fail. */ \
/* False: Not a full payment. */ \
TF_FLAG(tfLoanLatePayment, 0x00040000), /* True indicates that the payment is late, and includes late interest and fees. */ \
/* If the loan is not late, it will fail. */ \
/* False: not a late payment. If the current payment is overdue, the transaction will fail.*/ \
MASK_ADJ(0)) \
\
TRANSACTION(LoanManage, \
TF_FLAG(tfLoanDefault, 0x00010000) \
TF_FLAG(tfLoanImpair, 0x00020000) \
TF_FLAG(tfLoanUnimpair, 0x00040000), \
MASK_ADJ(0))
// clang-format on
// Create all the flag values.
//
// example:
// inline constexpr FlagValue tfAccountSetRequireDestTag = 0x00010000;
#define TO_VALUE(name, value) inline constexpr FlagValue name = value;
#define NULL_NAME(name, values, maskAdj) values
#define NULL_OUTPUT(name, value)
#define NULL_MASK_ADJ(value)
XMACRO(NULL_NAME, TO_VALUE, NULL_OUTPUT, NULL_MASK_ADJ)
// Create masks for each transaction type that has flags.
//
// example:
// inline constexpr FlagValue tfAccountSetMask = ~(tfUniversal | tfRequireDestTag |
// tfOptionalDestTag | tfRequireAuth | tfOptionalAuth | tfDisallowXRP | tfAllowXRP);
//
// The mask adjustment (maskAdj) allows adding flags back to the mask, making them invalid.
// For example, Batch uses MASK_ADJ(tfInnerBatchTxn) to reject tfInnerBatchTxn on outer Batch.
#define TO_MASK(name, values, maskAdj) \
inline constexpr FlagValue tf##name##Mask = ~(tfUniversal values) | maskAdj;
#define VALUE_TO_MASK(name, value) | name
#define MASK_ADJ_TO_MASK(value) value
XMACRO(TO_MASK, VALUE_TO_MASK, VALUE_TO_MASK, MASK_ADJ_TO_MASK)
// Verify that tfBatchMask correctly rejects tfInnerBatchTxn.
// The outer Batch transaction must NOT have tfInnerBatchTxn set; only inner transactions should
// have it.
static_assert(
(tfBatchMask & tfInnerBatchTxn) == tfInnerBatchTxn,
"tfBatchMask must include tfInnerBatchTxn to reject it on outer Batch");
// Verify that other transaction masks correctly allow tfInnerBatchTxn.
// Inner transactions need tfInnerBatchTxn to be valid, so these masks must not reject it.
static_assert(
(tfPaymentMask & tfInnerBatchTxn) == 0,
"tfPaymentMask must not reject tfInnerBatchTxn");
static_assert(
(tfAccountSetMask & tfInnerBatchTxn) == 0,
"tfAccountSetMask must not reject tfInnerBatchTxn");
// Create getter functions for each set of flags using Meyer's singleton pattern.
// This avoids static initialization order fiasco while still providing efficient access.
// This is used below in `getAllTxFlags()` to generate the server_definitions RPC
// output.
//
// example:
// inline FlagMap const& getAccountSetFlags() {
// static FlagMap const flags = {
// {"tfRequireDestTag", 0x00010000},
// {"tfOptionalDestTag", 0x00020000},
// ...};
// return flags;
// }
using FlagMap = std::map<std::string, FlagValue>;
#define VALUE_TO_MAP(name, value) {#name, value},
#define TO_MAP(name, values, maskAdj) \
inline FlagMap const& get##name##Flags() \
{ \
static FlagMap const flags = {values}; \
return flags; \
}
XMACRO(TO_MAP, VALUE_TO_MAP, VALUE_TO_MAP, NULL_MASK_ADJ)
inline FlagMap const&
getUniversalFlags()
{
static FlagMap const flags = {
{"tfFullyCanonicalSig", tfFullyCanonicalSig}, {"tfInnerBatchTxn", tfInnerBatchTxn}};
return flags;
}
// Create a getter function for all transaction flag maps using Meyer's singleton pattern.
// This is used to generate the server_definitions RPC output.
//
// example:
// inline FlagMapPairList const& getAllTxFlags() {
// static FlagMapPairList const flags = {
// {"AccountSet", getAccountSetFlags()},
// ...};
// return flags;
// }
using FlagMapPairList = std::vector<std::pair<std::string, FlagMap>>;
#define ALL_TX_FLAGS(name, values, maskAdj) {#name, get##name##Flags()},
inline FlagMapPairList const&
getAllTxFlags()
{
static FlagMapPairList const flags = {
{"universal", getUniversalFlags()},
XMACRO(ALL_TX_FLAGS, NULL_OUTPUT, NULL_OUTPUT, NULL_MASK_ADJ)};
return flags;
}
#undef XMACRO
#undef TO_VALUE
#undef VALUE_TO_MAP
#undef NULL_NAME
#undef NULL_OUTPUT
#undef TO_MAP
#undef TO_MASK
#undef VALUE_TO_MASK
#undef ALL_TX_FLAGS
#undef NULL_MASK_ADJ
#undef MASK_ADJ_TO_MASK
#pragma pop_macro("XMACRO")
#pragma pop_macro("TO_VALUE")
#pragma pop_macro("VALUE_TO_MAP")
#pragma pop_macro("NULL_NAME")
#pragma pop_macro("NULL_OUTPUT")
#pragma pop_macro("TO_MAP")
#pragma pop_macro("TO_MASK")
#pragma pop_macro("VALUE_TO_MASK")
#pragma pop_macro("ALL_TX_FLAGS")
#pragma pop_macro("NULL_MASK_ADJ")
#pragma pop_macro("MASK_ADJ_TO_MASK")
// Additional transaction masks and combos
inline constexpr FlagValue tfMPTPaymentMask = ~(tfUniversal | tfPartialPayment);
inline constexpr FlagValue tfTrustSetPermissionMask =
~(tfUniversal | tfSetfAuth | tfSetFreeze | tfClearFreeze);
// MPTokenIssuanceCreate MutableFlags:
// Indicating specific fields or flags may be changed after issuance.
inline constexpr FlagValue tmfMPTCanMutateCanLock = lsmfMPTCanMutateCanLock;
inline constexpr FlagValue tmfMPTCanMutateRequireAuth = lsmfMPTCanMutateRequireAuth;
inline constexpr FlagValue tmfMPTCanMutateCanEscrow = lsmfMPTCanMutateCanEscrow;
inline constexpr FlagValue tmfMPTCanMutateCanTrade = lsmfMPTCanMutateCanTrade;
inline constexpr FlagValue tmfMPTCanMutateCanTransfer = lsmfMPTCanMutateCanTransfer;
inline constexpr FlagValue tmfMPTCanMutateCanClawback = lsmfMPTCanMutateCanClawback;
inline constexpr FlagValue tmfMPTCanMutateMetadata = lsmfMPTCanMutateMetadata;
inline constexpr FlagValue tmfMPTCanMutateTransferFee = lsmfMPTCanMutateTransferFee;
inline constexpr FlagValue tmfMPTokenIssuanceCreateMutableMask =
~(tmfMPTCanMutateCanLock | tmfMPTCanMutateRequireAuth | tmfMPTCanMutateCanEscrow |
tmfMPTCanMutateCanTrade | tmfMPTCanMutateCanTransfer | tmfMPTCanMutateCanClawback |
tmfMPTCanMutateMetadata | tmfMPTCanMutateTransferFee);
// MPTokenIssuanceSet MutableFlags:
// Set or Clear flags.
inline constexpr FlagValue tmfMPTSetCanLock = 0x00000001;
inline constexpr FlagValue tmfMPTClearCanLock = 0x00000002;
inline constexpr FlagValue tmfMPTSetRequireAuth = 0x00000004;
inline constexpr FlagValue tmfMPTClearRequireAuth = 0x00000008;
inline constexpr FlagValue tmfMPTSetCanEscrow = 0x00000010;
inline constexpr FlagValue tmfMPTClearCanEscrow = 0x00000020;
inline constexpr FlagValue tmfMPTSetCanTrade = 0x00000040;
inline constexpr FlagValue tmfMPTClearCanTrade = 0x00000080;
inline constexpr FlagValue tmfMPTSetCanTransfer = 0x00000100;
inline constexpr FlagValue tmfMPTClearCanTransfer = 0x00000200;
inline constexpr FlagValue tmfMPTSetCanClawback = 0x00000400;
inline constexpr FlagValue tmfMPTClearCanClawback = 0x00000800;
inline constexpr FlagValue tmfMPTokenIssuanceSetMutableMask = ~(
tmfMPTSetCanLock | tmfMPTClearCanLock | tmfMPTSetRequireAuth | tmfMPTClearRequireAuth |
tmfMPTSetCanEscrow | tmfMPTClearCanEscrow | tmfMPTSetCanTrade | tmfMPTClearCanTrade |
tmfMPTSetCanTransfer | tmfMPTClearCanTransfer | tmfMPTSetCanClawback | tmfMPTClearCanClawback);
// Prior to fixRemoveNFTokenAutoTrustLine, transfer of an NFToken between accounts allowed a
// TrustLine to be added to the issuer of that token without explicit permission from that issuer.
// This was enabled by minting the NFToken with the tfTrustLine flag set.
//
// That capability could be used to attack the NFToken issuer.
// It would be possible for two accounts to trade the NFToken back and forth building up any number
// of TrustLines on the issuer, increasing the issuer's reserve without bound.
//
// The fixRemoveNFTokenAutoTrustLine amendment disables minting with the tfTrustLine flag as a way
// to prevent the attack. But until the amendment passes we still need to keep the old behavior
// available.
inline constexpr FlagValue tfTrustLine = 0x00000004; // needed for backwards compatibility
inline constexpr FlagValue tfNFTokenMintMaskWithoutMutable =
~(tfUniversal | tfBurnable | tfOnlyXRP | tfTransferable);
inline constexpr FlagValue tfNFTokenMintOldMask = ~(~tfNFTokenMintMaskWithoutMutable | tfTrustLine);
// if featureDynamicNFT enabled then new flag allowing mutable URI available.
inline constexpr FlagValue tfNFTokenMintOldMaskWithMutable = ~(~tfNFTokenMintOldMask | tfMutable);
inline constexpr FlagValue tfWithdrawSubTx = tfLPToken | tfSingleAsset | tfTwoAsset |
tfOneAssetLPToken | tfLimitLPToken | tfWithdrawAll | tfOneAssetWithdrawAll;
inline constexpr FlagValue tfDepositSubTx =
tfLPToken | tfSingleAsset | tfTwoAsset | tfOneAssetLPToken | tfLimitLPToken | tfTwoAssetIfEmpty;
#pragma push_macro("ACCOUNTSET_FLAGS")
#pragma push_macro("ACCOUNTSET_FLAG_TO_VALUE")
#pragma push_macro("ACCOUNTSET_FLAG_TO_MAP")
// AccountSet SetFlag/ClearFlag values
#define ACCOUNTSET_FLAGS(ASF_FLAG) \
ASF_FLAG(asfRequireDest, 1) \
ASF_FLAG(asfRequireAuth, 2) \
ASF_FLAG(asfDisallowXRP, 3) \
ASF_FLAG(asfDisableMaster, 4) \
ASF_FLAG(asfAccountTxnID, 5) \
ASF_FLAG(asfNoFreeze, 6) \
ASF_FLAG(asfGlobalFreeze, 7) \
ASF_FLAG(asfDefaultRipple, 8) \
ASF_FLAG(asfDepositAuth, 9) \
ASF_FLAG(asfAuthorizedNFTokenMinter, 10) \
/* 11 is reserved for Hooks amendment */ \
/* ASF_FLAG(asfTshCollect, 11) */ \
ASF_FLAG(asfDisallowIncomingNFTokenOffer, 12) \
ASF_FLAG(asfDisallowIncomingCheck, 13) \
ASF_FLAG(asfDisallowIncomingPayChan, 14) \
ASF_FLAG(asfDisallowIncomingTrustline, 15) \
ASF_FLAG(asfAllowTrustLineClawback, 16) \
ASF_FLAG(asfAllowTrustLineLocking, 17)
#define ACCOUNTSET_FLAG_TO_VALUE(name, value) inline constexpr FlagValue name = value;
#define ACCOUNTSET_FLAG_TO_MAP(name, value) {#name, value},
ACCOUNTSET_FLAGS(ACCOUNTSET_FLAG_TO_VALUE)
inline std::map<std::string, FlagValue> const&
getAsfFlagMap()
{
static std::map<std::string, FlagValue> const flags = {
ACCOUNTSET_FLAGS(ACCOUNTSET_FLAG_TO_MAP)};
return flags;
}
#undef ACCOUNTSET_FLAG_TO_VALUE
#undef ACCOUNTSET_FLAG_TO_MAP
#undef ACCOUNTSET_FLAGS
#pragma pop_macro("ACCOUNTSET_FLAG_TO_VALUE")
#pragma pop_macro("ACCOUNTSET_FLAG_TO_MAP")
#pragma pop_macro("ACCOUNTSET_FLAGS")
} // namespace xrpl

5
include/xrpl/protocol/TxFormats.h
View File

@@ -2,6 +2,8 @@
#include <xrpl/protocol/KnownFormats.h>
#include <vector>
namespace xrpl {
/** Transaction type identifiers.
@@ -73,6 +75,9 @@ private:
public:
static TxFormats const&
getInstance();
static std::vector<SOElement> const&
getCommonFields();
};
} // namespace xrpl

2
include/xrpl/protocol/detail/STVar.h
View File

@@ -44,7 +44,7 @@ private:
// The largest "small object" we can accommodate
static std::size_t constexpr max_size = 72;
std::aligned_storage<max_size>::type d_;
std::aligned_storage<max_size>::type d_ = {};
STBase* p_ = nullptr;
public:

2
include/xrpl/protocol/detail/features.macro
View File

@@ -16,7 +16,7 @@
// Add new amendments to the top of this list.
// Keep it sorted in reverse chronological order.
XRPL_FIX (LendingProtocolV1_1, Supported::yes, VoteBehavior::DefaultNo)
XRPL_FEATURE(LendingProtocolV1_1, Supported::yes, VoteBehavior::DefaultNo)
XRPL_FIX (PermissionedDomainInvariant, Supported::yes, VoteBehavior::DefaultNo)
XRPL_FIX (ExpiredNFTokenOfferRemoval, Supported::yes, VoteBehavior::DefaultNo)
XRPL_FIX (BatchInnerSigs, Supported::no, VoteBehavior::DefaultNo)

168
include/xrpl/protocol/detail/transactions.macro
View File

@@ -22,7 +22,7 @@
/** This transaction type executes a payment. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Payment.h>
# include <xrpl/tx/transactors/payment/Payment.h>
#endif
TRANSACTION(ttPAYMENT, 0, Payment,
Delegation::delegable,
@@ -42,7 +42,7 @@ TRANSACTION(ttPAYMENT, 0, Payment,
/** This transaction type creates an escrow object. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Escrow.h>
# include <xrpl/tx/transactors/escrow/EscrowCreate.h>
#endif
TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate,
Delegation::delegable,
@@ -58,6 +58,9 @@ TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate,
}))
/** This transaction type completes an existing escrow. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/escrow/EscrowFinish.h>
#endif
TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish,
Delegation::delegable,
uint256{},
@@ -73,7 +76,7 @@ TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish,
/** This transaction type adjusts various account settings. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/SetAccount.h>
# include <xrpl/tx/transactors/account/AccountSet.h>
#endif
TRANSACTION(ttACCOUNT_SET, 3, AccountSet,
Delegation::notDelegable,
@@ -94,7 +97,7 @@ TRANSACTION(ttACCOUNT_SET, 3, AccountSet,
/** This transaction type cancels an existing escrow. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Escrow.h>
# include <xrpl/tx/transactors/escrow/EscrowCancel.h>
#endif
TRANSACTION(ttESCROW_CANCEL, 4, EscrowCancel,
Delegation::delegable,
@@ -107,7 +110,7 @@ TRANSACTION(ttESCROW_CANCEL, 4, EscrowCancel,
/** This transaction type sets or clears an account's "regular key". */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/SetRegularKey.h>
# include <xrpl/tx/transactors/account/SetRegularKey.h>
#endif
TRANSACTION(ttREGULAR_KEY_SET, 5, SetRegularKey,
Delegation::notDelegable,
@@ -121,7 +124,7 @@ TRANSACTION(ttREGULAR_KEY_SET, 5, SetRegularKey,
/** This transaction type creates an offer to trade one asset for another. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Offer/CreateOffer.h>
# include <xrpl/tx/transactors/dex/OfferCreate.h>
#endif
TRANSACTION(ttOFFER_CREATE, 7, OfferCreate,
Delegation::delegable,
@@ -137,7 +140,7 @@ TRANSACTION(ttOFFER_CREATE, 7, OfferCreate,
/** This transaction type cancels existing offers to trade one asset for another. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Offer/CancelOffer.h>
# include <xrpl/tx/transactors/dex/OfferCancel.h>
#endif
TRANSACTION(ttOFFER_CANCEL, 8, OfferCancel,
Delegation::delegable,
@@ -151,7 +154,7 @@ TRANSACTION(ttOFFER_CANCEL, 8, OfferCancel,
/** This transaction type creates a new set of tickets. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/CreateTicket.h>
# include <xrpl/tx/transactors/system/TicketCreate.h>
#endif
TRANSACTION(ttTICKET_CREATE, 10, TicketCreate,
Delegation::delegable,
@@ -167,7 +170,7 @@ TRANSACTION(ttTICKET_CREATE, 10, TicketCreate,
// The SignerEntries are optional because a SignerList is deleted by
// setting the SignerQuorum to zero and omitting SignerEntries.
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/SetSignerList.h>
# include <xrpl/tx/transactors/account/SignerListSet.h>
#endif
TRANSACTION(ttSIGNER_LIST_SET, 12, SignerListSet,
Delegation::notDelegable,
@@ -180,7 +183,7 @@ TRANSACTION(ttSIGNER_LIST_SET, 12, SignerListSet,
/** This transaction type creates a new unidirectional XRP payment channel. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/PayChan.h>
# include <xrpl/tx/transactors/payment_channel/PaymentChannelCreate.h>
#endif
TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate,
Delegation::delegable,
@@ -196,6 +199,9 @@ TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate,
}))
/** This transaction type funds an existing unidirectional XRP payment channel. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/payment_channel/PaymentChannelFund.h>
#endif
TRANSACTION(ttPAYCHAN_FUND, 14, PaymentChannelFund,
Delegation::delegable,
uint256{},
@@ -207,6 +213,9 @@ TRANSACTION(ttPAYCHAN_FUND, 14, PaymentChannelFund,
}))
/** This transaction type submits a claim against an existing unidirectional payment channel. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/payment_channel/PaymentChannelClaim.h>
#endif
TRANSACTION(ttPAYCHAN_CLAIM, 15, PaymentChannelClaim,
Delegation::delegable,
uint256{},
@@ -222,7 +231,7 @@ TRANSACTION(ttPAYCHAN_CLAIM, 15, PaymentChannelClaim,
/** This transaction type creates a new check. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Check/CreateCheck.h>
# include <xrpl/tx/transactors/check/CheckCreate.h>
#endif
TRANSACTION(ttCHECK_CREATE, 16, CheckCreate,
Delegation::delegable,
@@ -238,7 +247,7 @@ TRANSACTION(ttCHECK_CREATE, 16, CheckCreate,
/** This transaction type cashes an existing check. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Check/CashCheck.h>
# include <xrpl/tx/transactors/check/CheckCash.h>
#endif
TRANSACTION(ttCHECK_CASH, 17, CheckCash,
Delegation::delegable,
@@ -252,7 +261,7 @@ TRANSACTION(ttCHECK_CASH, 17, CheckCash,
/** This transaction type cancels an existing check. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Check/CancelCheck.h>
# include <xrpl/tx/transactors/check/CheckCancel.h>
#endif
TRANSACTION(ttCHECK_CANCEL, 18, CheckCancel,
Delegation::delegable,
@@ -264,7 +273,7 @@ TRANSACTION(ttCHECK_CANCEL, 18, CheckCancel,
/** This transaction type grants or revokes authorization to transfer funds. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/DepositPreauth.h>
# include <xrpl/tx/transactors/payment/DepositPreauth.h>
#endif
TRANSACTION(ttDEPOSIT_PREAUTH, 19, DepositPreauth,
Delegation::delegable,
@@ -279,7 +288,7 @@ TRANSACTION(ttDEPOSIT_PREAUTH, 19, DepositPreauth,
/** This transaction type modifies a trustline between two accounts. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/SetTrust.h>
# include <xrpl/tx/transactors/token/TrustSet.h>
#endif
TRANSACTION(ttTRUST_SET, 20, TrustSet,
Delegation::delegable,
@@ -293,7 +302,7 @@ TRANSACTION(ttTRUST_SET, 20, TrustSet,
/** This transaction type deletes an existing account. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/DeleteAccount.h>
# include <xrpl/tx/transactors/account/AccountDelete.h>
#endif
TRANSACTION(ttACCOUNT_DELETE, 21, AccountDelete,
Delegation::notDelegable,
@@ -309,7 +318,7 @@ TRANSACTION(ttACCOUNT_DELETE, 21, AccountDelete,
/** This transaction mints a new NFT. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/NFT/NFTokenMint.h>
# include <xrpl/tx/transactors/nft/NFTokenMint.h>
#endif
TRANSACTION(ttNFTOKEN_MINT, 25, NFTokenMint,
Delegation::delegable,
@@ -327,7 +336,7 @@ TRANSACTION(ttNFTOKEN_MINT, 25, NFTokenMint,
/** This transaction burns (i.e. destroys) an existing NFT. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/NFT/NFTokenBurn.h>
# include <xrpl/tx/transactors/nft/NFTokenBurn.h>
#endif
TRANSACTION(ttNFTOKEN_BURN, 26, NFTokenBurn,
Delegation::delegable,
@@ -340,7 +349,7 @@ TRANSACTION(ttNFTOKEN_BURN, 26, NFTokenBurn,
/** This transaction creates a new offer to buy or sell an NFT. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/NFT/NFTokenCreateOffer.h>
# include <xrpl/tx/transactors/nft/NFTokenCreateOffer.h>
#endif
TRANSACTION(ttNFTOKEN_CREATE_OFFER, 27, NFTokenCreateOffer,
Delegation::delegable,
@@ -356,7 +365,7 @@ TRANSACTION(ttNFTOKEN_CREATE_OFFER, 27, NFTokenCreateOffer,
/** This transaction cancels an existing offer to buy or sell an existing NFT. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/NFT/NFTokenCancelOffer.h>
# include <xrpl/tx/transactors/nft/NFTokenCancelOffer.h>
#endif
TRANSACTION(ttNFTOKEN_CANCEL_OFFER, 28, NFTokenCancelOffer,
Delegation::delegable,
@@ -368,7 +377,7 @@ TRANSACTION(ttNFTOKEN_CANCEL_OFFER, 28, NFTokenCancelOffer,
/** This transaction accepts an existing offer to buy or sell an existing NFT. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/NFT/NFTokenAcceptOffer.h>
# include <xrpl/tx/transactors/nft/NFTokenAcceptOffer.h>
#endif
TRANSACTION(ttNFTOKEN_ACCEPT_OFFER, 29, NFTokenAcceptOffer,
Delegation::delegable,
@@ -382,7 +391,7 @@ TRANSACTION(ttNFTOKEN_ACCEPT_OFFER, 29, NFTokenAcceptOffer,
/** This transaction claws back issued tokens. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Clawback.h>
# include <xrpl/tx/transactors/token/Clawback.h>
#endif
TRANSACTION(ttCLAWBACK, 30, Clawback,
Delegation::delegable,
@@ -395,7 +404,7 @@ TRANSACTION(ttCLAWBACK, 30, Clawback,
/** This transaction claws back tokens from an AMM pool. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/AMM/AMMClawback.h>
# include <xrpl/tx/transactors/dex/AMMClawback.h>
#endif
TRANSACTION(ttAMM_CLAWBACK, 31, AMMClawback,
Delegation::delegable,
@@ -410,7 +419,7 @@ TRANSACTION(ttAMM_CLAWBACK, 31, AMMClawback,
/** This transaction type creates an AMM instance */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/AMM/AMMCreate.h>
# include <xrpl/tx/transactors/dex/AMMCreate.h>
#endif
TRANSACTION(ttAMM_CREATE, 35, AMMCreate,
Delegation::delegable,
@@ -424,7 +433,7 @@ TRANSACTION(ttAMM_CREATE, 35, AMMCreate,
/** This transaction type deposits into an AMM instance */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/AMM/AMMDeposit.h>
# include <xrpl/tx/transactors/dex/AMMDeposit.h>
#endif
TRANSACTION(ttAMM_DEPOSIT, 36, AMMDeposit,
Delegation::delegable,
@@ -442,7 +451,7 @@ TRANSACTION(ttAMM_DEPOSIT, 36, AMMDeposit,
/** This transaction type withdraws from an AMM instance */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/AMM/AMMWithdraw.h>
# include <xrpl/tx/transactors/dex/AMMWithdraw.h>
#endif
TRANSACTION(ttAMM_WITHDRAW, 37, AMMWithdraw,
Delegation::delegable,
@@ -459,7 +468,7 @@ TRANSACTION(ttAMM_WITHDRAW, 37, AMMWithdraw,
/** This transaction type votes for the trading fee */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/AMM/AMMVote.h>
# include <xrpl/tx/transactors/dex/AMMVote.h>
#endif
TRANSACTION(ttAMM_VOTE, 38, AMMVote,
Delegation::delegable,
@@ -473,7 +482,7 @@ TRANSACTION(ttAMM_VOTE, 38, AMMVote,
/** This transaction type bids for the auction slot */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/AMM/AMMBid.h>
# include <xrpl/tx/transactors/dex/AMMBid.h>
#endif
TRANSACTION(ttAMM_BID, 39, AMMBid,
Delegation::delegable,
@@ -489,7 +498,7 @@ TRANSACTION(ttAMM_BID, 39, AMMBid,
/** This transaction type deletes AMM in the empty state */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/AMM/AMMDelete.h>
# include <xrpl/tx/transactors/dex/AMMDelete.h>
#endif
TRANSACTION(ttAMM_DELETE, 40, AMMDelete,
Delegation::delegable,
@@ -502,7 +511,7 @@ TRANSACTION(ttAMM_DELETE, 40, AMMDelete,
/** This transactions creates a crosschain sequence number */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/XChainBridge.h>
# include <xrpl/tx/transactors/bridge/XChainBridge.h>
#endif
TRANSACTION(ttXCHAIN_CREATE_CLAIM_ID, 41, XChainCreateClaimID,
Delegation::delegable,
@@ -617,7 +626,7 @@ TRANSACTION(ttXCHAIN_CREATE_BRIDGE, 48, XChainCreateBridge,
/** This transaction type creates or updates a DID */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/DID.h>
# include <xrpl/tx/transactors/did/DIDSet.h>
#endif
TRANSACTION(ttDID_SET, 49, DIDSet,
Delegation::delegable,
@@ -630,6 +639,9 @@ TRANSACTION(ttDID_SET, 49, DIDSet,
}))
/** This transaction type deletes a DID */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/did/DIDDelete.h>
#endif
TRANSACTION(ttDID_DELETE, 50, DIDDelete,
Delegation::delegable,
featureDID,
@@ -638,7 +650,7 @@ TRANSACTION(ttDID_DELETE, 50, DIDDelete,
/** This transaction type creates an Oracle instance */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/SetOracle.h>
# include <xrpl/tx/transactors/oracle/OracleSet.h>
#endif
TRANSACTION(ttORACLE_SET, 51, OracleSet,
Delegation::delegable,
@@ -655,7 +667,7 @@ TRANSACTION(ttORACLE_SET, 51, OracleSet,
/** This transaction type deletes an Oracle instance */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/DeleteOracle.h>
# include <xrpl/tx/transactors/oracle/OracleDelete.h>
#endif
TRANSACTION(ttORACLE_DELETE, 52, OracleDelete,
Delegation::delegable,
@@ -667,7 +679,7 @@ TRANSACTION(ttORACLE_DELETE, 52, OracleDelete,
/** This transaction type fixes a problem in the ledger state */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/LedgerStateFix.h>
# include <xrpl/tx/transactors/system/LedgerStateFix.h>
#endif
TRANSACTION(ttLEDGER_STATE_FIX, 53, LedgerStateFix,
Delegation::delegable,
@@ -680,7 +692,7 @@ TRANSACTION(ttLEDGER_STATE_FIX, 53, LedgerStateFix,
/** This transaction type creates a MPTokensIssuance instance */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/MPT/MPTokenIssuanceCreate.h>
# include <xrpl/tx/transactors/token/MPTokenIssuanceCreate.h>
#endif
TRANSACTION(ttMPTOKEN_ISSUANCE_CREATE, 54, MPTokenIssuanceCreate,
Delegation::delegable,
@@ -697,7 +709,7 @@ TRANSACTION(ttMPTOKEN_ISSUANCE_CREATE, 54, MPTokenIssuanceCreate,
/** This transaction type destroys a MPTokensIssuance instance */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/MPT/MPTokenIssuanceDestroy.h>
# include <xrpl/tx/transactors/token/MPTokenIssuanceDestroy.h>
#endif
TRANSACTION(ttMPTOKEN_ISSUANCE_DESTROY, 55, MPTokenIssuanceDestroy,
Delegation::delegable,
@@ -709,7 +721,7 @@ TRANSACTION(ttMPTOKEN_ISSUANCE_DESTROY, 55, MPTokenIssuanceDestroy,
/** This transaction type sets flags on a MPTokensIssuance or MPToken instance */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/MPT/MPTokenIssuanceSet.h>
# include <xrpl/tx/transactors/token/MPTokenIssuanceSet.h>
#endif
TRANSACTION(ttMPTOKEN_ISSUANCE_SET, 56, MPTokenIssuanceSet,
Delegation::delegable,
@@ -726,7 +738,7 @@ TRANSACTION(ttMPTOKEN_ISSUANCE_SET, 56, MPTokenIssuanceSet,
/** This transaction type authorizes a MPToken instance */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/MPT/MPTokenAuthorize.h>
# include <xrpl/tx/transactors/token/MPTokenAuthorize.h>
#endif
TRANSACTION(ttMPTOKEN_AUTHORIZE, 57, MPTokenAuthorize,
Delegation::delegable,
@@ -739,7 +751,7 @@ TRANSACTION(ttMPTOKEN_AUTHORIZE, 57, MPTokenAuthorize,
/** This transaction type create an Credential instance */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Credentials.h>
# include <xrpl/tx/transactors/credentials/CredentialCreate.h>
#endif
TRANSACTION(ttCREDENTIAL_CREATE, 58, CredentialCreate,
Delegation::delegable,
@@ -753,6 +765,9 @@ TRANSACTION(ttCREDENTIAL_CREATE, 58, CredentialCreate,
}))
/** This transaction type accept an Credential object */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/credentials/CredentialAccept.h>
#endif
TRANSACTION(ttCREDENTIAL_ACCEPT, 59, CredentialAccept,
Delegation::delegable,
featureCredentials,
@@ -763,6 +778,9 @@ TRANSACTION(ttCREDENTIAL_ACCEPT, 59, CredentialAccept,
}))
/** This transaction type delete an Credential object */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/credentials/CredentialDelete.h>
#endif
TRANSACTION(ttCREDENTIAL_DELETE, 60, CredentialDelete,
Delegation::delegable,
featureCredentials,
@@ -775,7 +793,7 @@ TRANSACTION(ttCREDENTIAL_DELETE, 60, CredentialDelete,
/** This transaction type modify a NFToken */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/NFT/NFTokenModify.h>
# include <xrpl/tx/transactors/nft/NFTokenModify.h>
#endif
TRANSACTION(ttNFTOKEN_MODIFY, 61, NFTokenModify,
Delegation::delegable,
@@ -789,7 +807,7 @@ TRANSACTION(ttNFTOKEN_MODIFY, 61, NFTokenModify,
/** This transaction type creates or modifies a Permissioned Domain */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/PermissionedDomain/PermissionedDomainSet.h>
# include <xrpl/tx/transactors/permissioned_domain/PermissionedDomainSet.h>
#endif
TRANSACTION(ttPERMISSIONED_DOMAIN_SET, 62, PermissionedDomainSet,
Delegation::delegable,
@@ -802,7 +820,7 @@ TRANSACTION(ttPERMISSIONED_DOMAIN_SET, 62, PermissionedDomainSet,
/** This transaction type deletes a Permissioned Domain */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/PermissionedDomain/PermissionedDomainDelete.h>
# include <xrpl/tx/transactors/permissioned_domain/PermissionedDomainDelete.h>
#endif
TRANSACTION(ttPERMISSIONED_DOMAIN_DELETE, 63, PermissionedDomainDelete,
Delegation::delegable,
@@ -814,7 +832,7 @@ TRANSACTION(ttPERMISSIONED_DOMAIN_DELETE, 63, PermissionedDomainDelete,
/** This transaction type delegates authorized account specified permissions */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Delegate/DelegateSet.h>
# include <xrpl/tx/transactors/delegate/DelegateSet.h>
#endif
TRANSACTION(ttDELEGATE_SET, 64, DelegateSet,
Delegation::notDelegable,
@@ -827,10 +845,10 @@ TRANSACTION(ttDELEGATE_SET, 64, DelegateSet,
/** This transaction creates a single asset vault. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Vault/VaultCreate.h>
# include <xrpl/tx/transactors/vault/VaultCreate.h>
#endif
TRANSACTION(ttVAULT_CREATE, 65, VaultCreate,
Delegation::delegable,
Delegation::notDelegable,
featureSingleAssetVault,
createPseudoAcct | createMPTIssuance | mustModifyVault,
({
@@ -845,10 +863,10 @@ TRANSACTION(ttVAULT_CREATE, 65, VaultCreate,
/** This transaction updates a single asset vault. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Vault/VaultSet.h>
# include <xrpl/tx/transactors/vault/VaultSet.h>
#endif
TRANSACTION(ttVAULT_SET, 66, VaultSet,
Delegation::delegable,
Delegation::notDelegable,
featureSingleAssetVault,
mustModifyVault,
({
@@ -860,10 +878,10 @@ TRANSACTION(ttVAULT_SET, 66, VaultSet,
/** This transaction deletes a single asset vault. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Vault/VaultDelete.h>
# include <xrpl/tx/transactors/vault/VaultDelete.h>
#endif
TRANSACTION(ttVAULT_DELETE, 67, VaultDelete,
Delegation::delegable,
Delegation::notDelegable,
featureSingleAssetVault,
mustDeleteAcct | destroyMPTIssuance | mustModifyVault,
({
@@ -873,10 +891,10 @@ TRANSACTION(ttVAULT_DELETE, 67, VaultDelete,
/** This transaction trades assets for shares with a vault. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Vault/VaultDeposit.h>
# include <xrpl/tx/transactors/vault/VaultDeposit.h>
#endif
TRANSACTION(ttVAULT_DEPOSIT, 68, VaultDeposit,
Delegation::delegable,
Delegation::notDelegable,
featureSingleAssetVault,
mayAuthorizeMPT | mustModifyVault,
({
@@ -886,10 +904,10 @@ TRANSACTION(ttVAULT_DEPOSIT, 68, VaultDeposit,
/** This transaction trades shares for assets with a vault. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Vault/VaultWithdraw.h>
# include <xrpl/tx/transactors/vault/VaultWithdraw.h>
#endif
TRANSACTION(ttVAULT_WITHDRAW, 69, VaultWithdraw,
Delegation::delegable,
Delegation::notDelegable,
featureSingleAssetVault,
mayDeleteMPT | mayAuthorizeMPT | mustModifyVault,
({
@@ -901,10 +919,10 @@ TRANSACTION(ttVAULT_WITHDRAW, 69, VaultWithdraw,
/** This transaction claws back tokens from a vault. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Vault/VaultClawback.h>
# include <xrpl/tx/transactors/vault/VaultClawback.h>
#endif
TRANSACTION(ttVAULT_CLAWBACK, 70, VaultClawback,
Delegation::delegable,
Delegation::notDelegable,
featureSingleAssetVault,
mayDeleteMPT | mustModifyVault,
({
@@ -915,7 +933,7 @@ TRANSACTION(ttVAULT_CLAWBACK, 70, VaultClawback,
/** This transaction type batches together transactions. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Batch.h>
# include <xrpl/tx/transactors/system/Batch.h>
#endif
TRANSACTION(ttBATCH, 71, Batch,
Delegation::notDelegable,
@@ -930,10 +948,10 @@ TRANSACTION(ttBATCH, 71, Batch,
/** This transaction creates and updates a Loan Broker */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Lending/LoanBrokerSet.h>
# include <xrpl/tx/transactors/lending/LoanBrokerSet.h>
#endif
TRANSACTION(ttLOAN_BROKER_SET, 74, LoanBrokerSet,
Delegation::delegable,
Delegation::notDelegable,
featureLendingProtocol,
createPseudoAcct | mayAuthorizeMPT, ({
{sfVaultID, soeREQUIRED},
@@ -947,10 +965,10 @@ TRANSACTION(ttLOAN_BROKER_SET, 74, LoanBrokerSet,
/** This transaction deletes a Loan Broker */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Lending/LoanBrokerDelete.h>
# include <xrpl/tx/transactors/lending/LoanBrokerDelete.h>
#endif
TRANSACTION(ttLOAN_BROKER_DELETE, 75, LoanBrokerDelete,
Delegation::delegable,
Delegation::notDelegable,
featureLendingProtocol,
mustDeleteAcct | mayAuthorizeMPT, ({
{sfLoanBrokerID, soeREQUIRED},
@@ -958,10 +976,10 @@ TRANSACTION(ttLOAN_BROKER_DELETE, 75, LoanBrokerDelete,
/** This transaction deposits First Loss Capital into a Loan Broker */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Lending/LoanBrokerCoverDeposit.h>
# include <xrpl/tx/transactors/lending/LoanBrokerCoverDeposit.h>
#endif
TRANSACTION(ttLOAN_BROKER_COVER_DEPOSIT, 76, LoanBrokerCoverDeposit,
Delegation::delegable,
Delegation::notDelegable,
featureLendingProtocol,
noPriv, ({
{sfLoanBrokerID, soeREQUIRED},
@@ -970,10 +988,10 @@ TRANSACTION(ttLOAN_BROKER_COVER_DEPOSIT, 76, LoanBrokerCoverDeposit,
/** This transaction withdraws First Loss Capital from a Loan Broker */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Lending/LoanBrokerCoverWithdraw.h>
# include <xrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.h>
#endif
TRANSACTION(ttLOAN_BROKER_COVER_WITHDRAW, 77, LoanBrokerCoverWithdraw,
Delegation::delegable,
Delegation::notDelegable,
featureLendingProtocol,
mayAuthorizeMPT, ({
{sfLoanBrokerID, soeREQUIRED},
@@ -985,10 +1003,10 @@ TRANSACTION(ttLOAN_BROKER_COVER_WITHDRAW, 77, LoanBrokerCoverWithdraw,
/** This transaction claws back First Loss Capital from a Loan Broker to
the issuer of the capital */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Lending/LoanBrokerCoverClawback.h>
# include <xrpl/tx/transactors/lending/LoanBrokerCoverClawback.h>
#endif
TRANSACTION(ttLOAN_BROKER_COVER_CLAWBACK, 78, LoanBrokerCoverClawback,
Delegation::delegable,
Delegation::notDelegable,
featureLendingProtocol,
noPriv, ({
{sfLoanBrokerID, soeOPTIONAL},
@@ -997,10 +1015,10 @@ TRANSACTION(ttLOAN_BROKER_COVER_CLAWBACK, 78, LoanBrokerCoverClawback,
/** This transaction creates a Loan */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Lending/LoanSet.h>
# include <xrpl/tx/transactors/lending/LoanSet.h>
#endif
TRANSACTION(ttLOAN_SET, 80, LoanSet,
Delegation::delegable,
Delegation::notDelegable,
featureLendingProtocol,
mayAuthorizeMPT | mustModifyVault, ({
{sfLoanBrokerID, soeREQUIRED},
@@ -1024,10 +1042,10 @@ TRANSACTION(ttLOAN_SET, 80, LoanSet,
/** This transaction deletes an existing Loan */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Lending/LoanDelete.h>
# include <xrpl/tx/transactors/lending/LoanDelete.h>
#endif
TRANSACTION(ttLOAN_DELETE, 81, LoanDelete,
Delegation::delegable,
Delegation::notDelegable,
featureLendingProtocol,
noPriv, ({
{sfLoanID, soeREQUIRED},
@@ -1035,10 +1053,10 @@ TRANSACTION(ttLOAN_DELETE, 81, LoanDelete,
/** This transaction is used to change the delinquency status of an existing Loan */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Lending/LoanManage.h>
# include <xrpl/tx/transactors/lending/LoanManage.h>
#endif
TRANSACTION(ttLOAN_MANAGE, 82, LoanManage,
Delegation::delegable,
Delegation::notDelegable,
featureLendingProtocol,
// All of the LoanManage options will modify the vault, but the
// transaction can succeed without options, essentially making it
@@ -1049,10 +1067,10 @@ TRANSACTION(ttLOAN_MANAGE, 82, LoanManage,
/** The Borrower uses this transaction to make a Payment on the Loan. */
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Lending/LoanPay.h>
# include <xrpl/tx/transactors/lending/LoanPay.h>
#endif
TRANSACTION(ttLOAN_PAY, 84, LoanPay,
Delegation::delegable,
Delegation::notDelegable,
featureLendingProtocol,
mayAuthorizeMPT | mustModifyVault, ({
{sfLoanID, soeREQUIRED},
@@ -1064,7 +1082,7 @@ TRANSACTION(ttLOAN_PAY, 84, LoanPay,
For details, see: https://xrpl.org/amendments.html
*/
#if TRANSACTION_INCLUDE
# include <xrpl/tx/transactors/Change.h>
# include <xrpl/tx/transactors/system/Change.h>
#endif
TRANSACTION(ttAMENDMENT, 100, EnableAmendment,
Delegation::notDelegable,

6
include/xrpl/protocol/digest.h
View File

@@ -40,7 +40,7 @@ public:
operator result_type() noexcept;
private:
char ctx_[96];
char ctx_[96]{};
};
/** SHA-512 digest
@@ -63,7 +63,7 @@ public:
operator result_type() noexcept;
private:
char ctx_[216];
char ctx_[216]{};
};
/** SHA-256 digest
@@ -86,7 +86,7 @@ public:
operator result_type() noexcept;
private:
char ctx_[112];
char ctx_[112]{};
};
//------------------------------------------------------------------------------

10
include/xrpl/protocol/jss.h
View File

@@ -25,6 +25,7 @@ namespace jss {
JSS(AL_size); // out: GetCounts
JSS(AL_hit_rate); // out: GetCounts
JSS(AcceptedCredentials); // out: AccountObjects
JSS(ACCOUNT_SET_FLAGS); // out: RPC server_definitions
JSS(Account); // in: TransactionSign; field.
JSS(AMMID); // field
JSS(Amount); // in: TransactionSign; field.
@@ -111,6 +112,7 @@ JSS(accounts); // in: LedgerEntry, Subscribe,
// handlers/Ledger, Unsubscribe
JSS(accounts_proposed); // in: Subscribe, Unsubscribe
JSS(action);
JSS(active); // out: OverlayImpl
JSS(acquiring); // out: LedgerRequest
JSS(address); // out: PeerImp
JSS(affected); // out: AcceptedLedgerTx
@@ -187,6 +189,7 @@ JSS(closed_ledger); // out: NetworkOPs
JSS(cluster); // out: PeerImp
JSS(code); // out: errors
JSS(command); // in: RPCHandler
JSS(common); // out: RPC server_definitions
JSS(complete); // out: NetworkOPs, InboundLedger
JSS(complete_ledgers); // out: NetworkOPs, PeerImp
JSS(consensus); // out: NetworkOPs, LedgerConsensus
@@ -298,6 +301,7 @@ JSS(id); // websocket.
JSS(ident); // in: AccountCurrencies, AccountInfo,
// OwnerInfo
JSS(ignore_default); // in: AccountLines
JSS(in); // out: OverlayImpl
JSS(inLedger); // out: tx/Transaction
JSS(inbound); // out: PeerImp
JSS(index); // in: LedgerEntry
@@ -356,6 +360,8 @@ JSS(ledger_min); // in, out: AccountTx*
JSS(ledger_time); // out: NetworkOPs
JSS(LEDGER_ENTRY_TYPES); // out: RPC server_definitions
// matches definitions.json format
JSS(LEDGER_ENTRY_FLAGS); // out: RPC server_definitions
JSS(LEDGER_ENTRY_FORMATS); // out: RPC server_definitions
JSS(levels); // LogLevels
JSS(limit); // in/out: AccountTx*, AccountOffers,
// AccountLines, AccountObjects
@@ -457,8 +463,10 @@ JSS(open); // out: handlers/Ledger
JSS(open_ledger_cost); // out: SubmitTransaction
JSS(open_ledger_fee); // out: TxQ
JSS(open_ledger_level); // out: TxQ
JSS(optionality); // out: server_definitions
JSS(oracles); // in: get_aggregate_price
JSS(oracle_document_id); // in: get_aggregate_price
JSS(out); // out: OverlayImpl
JSS(owner); // in: LedgerEntry, out: NetworkOPs
JSS(owner_funds); // in/out: Ledger, NetworkOPs, AcceptedLedgerTx
JSS(page_index);
@@ -616,6 +624,8 @@ JSS(TRANSACTION_RESULTS); // out: RPC server_definitions
// matches definitions.json format
JSS(TRANSACTION_TYPES); // out: RPC server_definitions
// matches definitions.json format
JSS(TRANSACTION_FLAGS); // out: RPC server_definitions
JSS(TRANSACTION_FORMATS); // out: RPC server_definitions
JSS(TYPES); // out: RPC server_definitions
// matches definitions.json format
JSS(transfer_rate); // out: nft_info (clio)

152
include/xrpl/protocol_autogen/LedgerEntryBase.h Normal file
View File

@@ -0,0 +1,152 @@
#pragma once
#include <xrpl/protocol/LedgerFormats.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol_autogen/STObjectValidation.h>
#include <xrpl/protocol_autogen/Utils.h>
#include <optional>
#include <string>
namespace xrpl::ledger_entries {
/**
* @brief Base class for type-safe ledger entry wrappers.
*
* This class provides common functionality for all ledger entry types,
* including access to common fields (sfLedgerIndex, sfLedgerEntryType, sfFlags).
*
* This is an immutable wrapper around SLE (Serialized Ledger Entry).
* Use the corresponding Builder classes to construct new ledger entries.
*/
class LedgerEntryBase
{
public:
/**
* @brief Construct a ledger entry wrapper from an existing SLE object.
* @param sle The underlying serialized ledger entry to wrap
*/
explicit LedgerEntryBase(std::shared_ptr<SLE const> sle) : sle_(std::move(sle))
{
}
/**
* @brief Validate the ledger entry
* @return true if validation passes, false otherwise
*/
[[nodiscard]]
bool
validate() const
{
if (!sle_->isFieldPresent(sfLedgerEntryType))
{
return false; // LCOV_EXCL_LINE
}
auto ledgerEntryType = static_cast<LedgerEntryType>(sle_->getFieldU16(sfLedgerEntryType));
return protocol_autogen::validateSTObject(
*sle_, LedgerFormats::getInstance().findByType(ledgerEntryType)->getSOTemplate());
}
/**
* @brief Get the ledger entry type.
* @return The type of this ledger entry
*/
[[nodiscard]]
LedgerEntryType
getType() const
{
return sle_->getType();
}
/**
* @brief Get the key (index) of this ledger entry.
*
* The key uniquely identifies this ledger entry in the ledger state.
* @return A constant reference to the 256-bit key
*/
[[nodiscard]]
uint256 const&
getKey() const
{
return sle_->key();
}
// Common field getters (from LedgerFormats.cpp commonFields)
/**
* @brief Get the ledger index (sfLedgerIndex).
*
* This field is OPTIONAL and represents the index of the ledger entry.
* @return The ledger index if present, std::nullopt otherwise
*/
[[nodiscard]]
std::optional<uint256>
getLedgerIndex() const
{
if (sle_->isFieldPresent(sfLedgerIndex))
{
return sle_->at(sfLedgerIndex);
}
return std::nullopt;
}
/**
* @brief Check if the ledger entry has a ledger index.
* @return true if sfLedgerIndex is present, false otherwise
*/
[[nodiscard]]
bool
hasLedgerIndex() const
{
return sle_->isFieldPresent(sfLedgerIndex);
}
/**
* @brief Get the ledger entry type field (sfLedgerEntryType).
*
* This field is REQUIRED for all ledger entries and indicates the type
* of the ledger entry (e.g., AccountRoot, RippleState, Offer, etc.).
* @return The ledger entry type as a 16-bit unsigned integer
*/
[[nodiscard]]
uint16_t
getLedgerEntryType() const
{
return sle_->at(sfLedgerEntryType);
}
/**
* @brief Get the flags field (sfFlags).
*
* This field is REQUIRED for all ledger entries and contains
* type-specific flags that modify the behavior of the ledger entry.
* @return The flags value as a 32-bit unsigned integer
*/
[[nodiscard]]
std::uint32_t
getFlags() const
{
return sle_->at(sfFlags);
}
/**
* @brief Get the underlying SLE object.
*
* Provides direct access to the wrapped serialized ledger entry object
* for cases where the type-safe accessors are insufficient.
* @return A constant reference to the underlying SLE object
*/
[[nodiscard]]
std::shared_ptr<SLE const>
getSle() const
{
return sle_;
}
protected:
/** @brief The underlying serialized ledger entry being wrapped. */
std::shared_ptr<SLE const> sle_;
};
} // namespace xrpl::ledger_entries

84
include/xrpl/protocol_autogen/LedgerEntryBuilderBase.h Normal file
View File

@@ -0,0 +1,84 @@
#pragma once
#include <xrpl/protocol/LedgerFormats.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STAccount.h>
#include <xrpl/protocol/STAmount.h>
#include <xrpl/protocol/STBlob.h>
#include <xrpl/protocol/STInteger.h>
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STObject.h>
#include <xrpl/protocol_autogen/STObjectValidation.h>
namespace xrpl::ledger_entries {
/**
* Base class for all ledger entry builders.
* Provides common field setters that are available for all ledger entry types.
*/
template <typename Derived>
class LedgerEntryBuilderBase
{
public:
LedgerEntryBuilderBase() = default;
LedgerEntryBuilderBase(
SF_UINT16::type::value_type ledgerEntryType,
SF_UINT32::type::value_type flags = 0)
{
// Don't call object_.set(soTemplate) - keep object_ as a free object.
// This avoids creating STBase placeholders for soeDEFAULT fields,
// which would cause applyTemplate() to throw "may not be explicitly
// set to default" when building the SLE.
// The SLE constructor will call applyTemplate() which properly
// handles missing fields.
object_[sfLedgerEntryType] = ledgerEntryType;
object_[sfFlags] = flags;
}
/**
* @brief Validate the ledger entry
* @return true if validation passes, false otherwise
*/
[[nodiscard]]
bool
validate() const
{
if (!object_.isFieldPresent(sfLedgerEntryType))
{
return false; // LCOV_EXCL_LINE
}
auto ledgerEntryType = static_cast<LedgerEntryType>(object_.getFieldU16(sfLedgerEntryType));
return protocol_autogen::validateSTObject(
object_, LedgerFormats::getInstance().findByType(ledgerEntryType)->getSOTemplate());
}
/**
* Set the ledger index.
* @param value Ledger index
* @return Reference to the derived builder for method chaining.
*/
Derived&
setLedgerIndex(uint256 const& value)
{
object_[sfLedgerIndex] = value;
return static_cast<Derived&>(*this);
}
/**
* Set the flags.
* @param value Flags value
* @return Reference to the derived builder for method chaining.
*/
Derived&
setFlags(uint32_t value)
{
object_.setFieldU32(sfFlags, value);
return static_cast<Derived&>(*this);
}
protected:
STObject object_{sfLedgerEntry};
};
} // namespace xrpl::ledger_entries

79
include/xrpl/protocol_autogen/README.md Normal file
View File

@@ -0,0 +1,79 @@
# Protocol Autogen
This directory contains auto-generated C++ wrapper classes for XRP Ledger protocol types.
## Generated Files
The files in this directory are automatically generated at **CMake configure time** from macro definition files:
- **Transaction classes** (in `transactions/`): Generated from `include/xrpl/protocol/detail/transactions.macro` by `scripts/generate_tx_classes.py`
- **Ledger entry classes** (in `ledger_entries/`): Generated from `include/xrpl/protocol/detail/ledger_entries.macro` by `scripts/generate_ledger_classes.py`
## Generation Process
The generation happens automatically when you **configure** the project (not during build). When you run CMake, the system:
1. Creates a Python virtual environment in the build directory (`codegen_venv`)
2. Installs Python dependencies from `scripts/requirements.txt` into the venv (only if needed)
3. Runs the Python generation scripts using the venv Python interpreter
4. Parses the macro files to extract type definitions
5. Generates type-safe C++ wrapper classes using Mako templates
6. Places the generated headers in this directory
### When Regeneration Happens
The code is regenerated when:
- You run CMake configure for the first time
- The Python virtual environment doesn't exist
- `scripts/requirements.txt` has been modified
To force regeneration, delete the build directory and reconfigure.
### Python Dependencies
The code generation requires the following Python packages (automatically installed):
- `pcpp` - C preprocessor for Python
- `pyparsing` - Parser combinator library
- `Mako` - Template engine
These are isolated in a virtual environment and won't affect your system Python installation.
## Version Control
The generated `.h` files **are checked into version control**. This means:
- Developers without Python 3 can still build the project using the committed files
- CI/CD systems don't need to run code generation if files are up to date
- Changes to generated files are visible in code review
## Modifying Generated Code
**Do not manually edit generated files.** Any changes will be overwritten the next time CMake configure runs.
To modify the generated classes:
- Edit the macro files in `include/xrpl/protocol/detail/`
- Edit the Mako templates in `scripts/templates/`
- Edit the generation scripts in `scripts/`
- Update Python dependencies in `scripts/requirements.txt`
- Run CMake configure to regenerate
## Adding Common Fields
If you add a new common field to `TxFormats.cpp` or `LedgerFormats.cpp`, you should also update the corresponding base classes and templates manually:
Base classes:
- `TransactionBase.h` - Add getters for new common transaction fields
- `TransactionBuilderBase.h` - Add setters, and if the field is required, add it to the constructor parameters
- `LedgerEntryBase.h` - Add getters for new common ledger entry fields
- `LedgerEntryBuilderBase.h` - Add setters, and if the field is required, add it to the constructor parameters
Templates (update to pass required common fields to base class constructors):
- `scripts/templates/Transaction.h.mako`
- `scripts/templates/LedgerEntry.h.mako`
These files are **not auto-generated** and must be updated by hand.

43
include/xrpl/protocol_autogen/STObjectValidation.h Normal file
View File

@@ -0,0 +1,43 @@
#pragma once
#include <xrpl/protocol/SOTemplate.h>
#include <xrpl/protocol/STObject.h>
namespace xrpl::protocol_autogen {
[[nodiscard]]
inline bool
validateSTObject(STObject const& obj, SOTemplate const& format)
{
for (auto const& field : format)
{
if (!obj.isFieldPresent(field.sField()) && field.style() == soeREQUIRED)
{
return false; // LCOV_EXCL_LINE
}
if (field.supportMPT() == soeMPTNotSupported && obj.isFieldPresent(field.sField()))
{
if (field.sField().fieldType == STI_AMOUNT)
{
auto const& amount = obj.getFieldAmount(field.sField());
if (amount.asset().holds<MPTIssue>())
return false; // LCOV_EXCL_LINE
}
else if (field.sField().fieldType == STI_ISSUE)
{
auto issue = dynamic_cast<STIssue const*>(obj.peekAtPField(field.sField()));
if (!issue)
return false; // LCOV_EXCL_LINE
if (issue->holds<MPTIssue>())
return false; // LCOV_EXCL_LINE
}
}
}
return true;
}
} // namespace xrpl::protocol_autogen

457
include/xrpl/protocol_autogen/TransactionBase.h Normal file
View File

@@ -0,0 +1,457 @@
#pragma once
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STAccount.h>
#include <xrpl/protocol/STArray.h>
#include <xrpl/protocol/STObject.h>
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/TxFormats.h>
#include <xrpl/protocol_autogen/STObjectValidation.h>
#include <xrpl/protocol_autogen/Utils.h>
#include <optional>
#include <string>
namespace xrpl::transactions {
/**
* @brief Base class for all transaction wrapper types.
*
* Provides type-safe read-only accessors for common transaction fields.
* This is an immutable wrapper around STTx. Use the corresponding Builder classes
* to construct new transactions.
*/
class TransactionBase
{
public:
/**
* @brief Construct a transaction wrapper from an existing STTx object.
* @param tx The underlying transaction object to wrap
*/
explicit TransactionBase(std::shared_ptr<STTx const> tx) : tx_(std::move(tx))
{
}
/**
* @brief Validate the transaction
* @return true if validation passes, false otherwise
*/
[[nodiscard]]
bool
validate(std::string& reason) const
{
if (!protocol_autogen::validateSTObject(
*tx_, TxFormats::getInstance().findByType(tx_->getTxnType())->getSOTemplate()))
{
// LCOV_EXCL_START
reason = "Transaction failed schema validation";
return false;
// LCOV_EXCL_STOP
}
// Pseudo transactions are not submitted to the network
if (isPseudoTx(*tx_))
{
return true;
}
return passesLocalChecks(*tx_, reason);
}
/**
* @brief Get the transaction type.
* @return The type of this transaction
*/
[[nodiscard]]
xrpl::TxType
getTransactionType() const
{
return tx_->getTxnType();
}
/**
* @brief Get the account initiating the transaction (sfAccount).
*
* This field is REQUIRED for all transactions.
* @return The account ID of the transaction sender
*/
[[nodiscard]]
AccountID
getAccount() const
{
return tx_->at(sfAccount);
}
/**
* @brief Get the sequence number of the transaction (sfSequence).
*
* This field is REQUIRED for all transactions.
* @return The sequence number
*/
[[nodiscard]]
std::uint32_t
getSequence() const
{
return tx_->at(sfSequence);
}
/**
* @brief Get the transaction fee (sfFee).
*
* This field is REQUIRED for all transactions.
* @return The fee amount
*/
[[nodiscard]]
STAmount
getFee() const
{
return tx_->at(sfFee);
}
/**
* @brief Get the signing public key (sfSigningPubKey).
*
* This field is REQUIRED for all transactions.
* @return The public key used for signing as a blob
*/
[[nodiscard]]
Blob
getSigningPubKey() const
{
return tx_->getFieldVL(sfSigningPubKey);
}
/**
* @brief Get the transaction flags (sfFlags).
*
* This field is OPTIONAL.
* @return The flags value if present, std::nullopt otherwise
*/
[[nodiscard]]
std::optional<uint32_t>
getFlags() const
{
if (tx_->isFieldPresent(sfFlags))
return tx_->at(sfFlags);
return std::nullopt;
}
/**
* @brief Check if the transaction has flags set.
* @return true if sfFlags is present, false otherwise
*/
[[nodiscard]]
bool
hasFlags() const
{
return tx_->isFieldPresent(sfFlags);
}
/**
* @brief Get the source tag (sfSourceTag).
*
* This field is OPTIONAL and used to identify the source of a payment.
* @return The source tag value if present, std::nullopt otherwise
*/
[[nodiscard]]
std::optional<uint32_t>
getSourceTag() const
{
if (tx_->isFieldPresent(sfSourceTag))
return tx_->at(sfSourceTag);
return std::nullopt;
}
/**
* @brief Check if the transaction has a source tag.
* @return true if sfSourceTag is present, false otherwise
*/
[[nodiscard]]
bool
hasSourceTag() const
{
return tx_->isFieldPresent(sfSourceTag);
}
/**
* @brief Get the previous transaction ID (sfPreviousTxnID).
*
* This field is OPTIONAL and used for transaction chaining.
* @return The previous transaction ID if present, std::nullopt otherwise
*/
[[nodiscard]]
std::optional<uint256>
getPreviousTxnID() const
{
if (tx_->isFieldPresent(sfPreviousTxnID))
return tx_->at(sfPreviousTxnID);
return std::nullopt;
}
/**
* @brief Check if the transaction has a previous transaction ID.
* @return true if sfPreviousTxnID is present, false otherwise
*/
[[nodiscard]]
bool
hasPreviousTxnID() const
{
return tx_->isFieldPresent(sfPreviousTxnID);
}
/**
* @brief Get the last ledger sequence (sfLastLedgerSequence).
*
* This field is OPTIONAL and specifies the latest ledger sequence
* in which this transaction can be included.
* @return The last ledger sequence if present, std::nullopt otherwise
*/
[[nodiscard]]
std::optional<uint32_t>
getLastLedgerSequence() const
{
if (tx_->isFieldPresent(sfLastLedgerSequence))
return tx_->at(sfLastLedgerSequence);
return std::nullopt;
}
/**
* @brief Check if the transaction has a last ledger sequence.
* @return true if sfLastLedgerSequence is present, false otherwise
*/
[[nodiscard]]
bool
hasLastLedgerSequence() const
{
return tx_->isFieldPresent(sfLastLedgerSequence);
}
/**
* @brief Get the account transaction ID (sfAccountTxnID).
*
* This field is OPTIONAL and used to track transaction sequences.
* @return The account transaction ID if present, std::nullopt otherwise
*/
[[nodiscard]]
std::optional<uint256>
getAccountTxnID() const
{
if (tx_->isFieldPresent(sfAccountTxnID))
return tx_->at(sfAccountTxnID);
return std::nullopt;
}
/**
* @brief Check if the transaction has an account transaction ID.
* @return true if sfAccountTxnID is present, false otherwise
*/
[[nodiscard]]
bool
hasAccountTxnID() const
{
return tx_->isFieldPresent(sfAccountTxnID);
}
/**
* @brief Get the operation limit (sfOperationLimit).
*
* This field is OPTIONAL and limits the number of operations in a transaction.
* @return The operation limit if present, std::nullopt otherwise
*/
[[nodiscard]]
std::optional<uint32_t>
getOperationLimit() const
{
if (tx_->isFieldPresent(sfOperationLimit))
return tx_->at(sfOperationLimit);
return std::nullopt;
}
/**
* @brief Check if the transaction has an operation limit.
* @return true if sfOperationLimit is present, false otherwise
*/
[[nodiscard]]
bool
hasOperationLimit() const
{
return tx_->isFieldPresent(sfOperationLimit);
}
/**
* @brief Get the memos array (sfMemos).
*
* This field is OPTIONAL and contains arbitrary data attached to the transaction.
* @note This is an untyped field (STArray).
* @return A reference wrapper to the memos array if present, std::nullopt otherwise
*/
[[nodiscard]]
std::optional<std::reference_wrapper<STArray const>>
getMemos() const
{
if (tx_->isFieldPresent(sfMemos))
return tx_->getFieldArray(sfMemos);
return std::nullopt;
}
/**
* @brief Check if the transaction has memos.
* @return true if sfMemos is present, false otherwise
*/
[[nodiscard]]
bool
hasMemos() const
{
return tx_->isFieldPresent(sfMemos);
}
/**
* @brief Get the ticket sequence (sfTicketSequence).
*
* This field is OPTIONAL and used when consuming a ticket instead of a sequence number.
* @return The ticket sequence if present, std::nullopt otherwise
*/
[[nodiscard]]
std::optional<uint32_t>
getTicketSequence() const
{
if (tx_->isFieldPresent(sfTicketSequence))
return tx_->at(sfTicketSequence);
return std::nullopt;
}
/**
* @brief Check if the transaction has a ticket sequence.
* @return true if sfTicketSequence is present, false otherwise
*/
[[nodiscard]]
bool
hasTicketSequence() const
{
return tx_->isFieldPresent(sfTicketSequence);
}
/**
* @brief Get the transaction signature (sfTxnSignature).
*
* This field is OPTIONAL and contains the signature for single-signed transactions.
* @return The transaction signature as a blob if present, std::nullopt otherwise
*/
[[nodiscard]]
std::optional<Blob>
getTxnSignature() const
{
if (tx_->isFieldPresent(sfTxnSignature))
return tx_->getFieldVL(sfTxnSignature);
return std::nullopt;
}
/**
* @brief Check if the transaction has a transaction signature.
* @return true if sfTxnSignature is present, false otherwise
*/
[[nodiscard]]
bool
hasTxnSignature() const
{
return tx_->isFieldPresent(sfTxnSignature);
}
/**
* @brief Get the signers array (sfSigners).
*
* This field is OPTIONAL and contains the list of signers for multi-signed transactions.
* @note This is an untyped field (STArray).
* @return A reference wrapper to the signers array if present, std::nullopt otherwise
*/
[[nodiscard]]
std::optional<std::reference_wrapper<STArray const>>
getSigners() const
{
if (tx_->isFieldPresent(sfSigners))
return tx_->getFieldArray(sfSigners);
return std::nullopt;
}
/**
* @brief Check if the transaction has signers.
* @return true if sfSigners is present, false otherwise
*/
[[nodiscard]]
bool
hasSigners() const
{
return tx_->isFieldPresent(sfSigners);
}
/**
* @brief Get the network ID (sfNetworkID).
*
* This field is OPTIONAL and identifies the network this transaction is intended for.
* @return The network ID if present, std::nullopt otherwise
*/
[[nodiscard]]
std::optional<uint32_t>
getNetworkID() const
{
if (tx_->isFieldPresent(sfNetworkID))
return tx_->at(sfNetworkID);
return std::nullopt;
}
/**
* @brief Check if the transaction has a network ID.
* @return true if sfNetworkID is present, false otherwise
*/
[[nodiscard]]
bool
hasNetworkID() const
{
return tx_->isFieldPresent(sfNetworkID);
}
/**
* @brief Get the delegate account (sfDelegate).
*
* This field is OPTIONAL and specifies a delegate account for the transaction.
* @return The delegate account ID if present, std::nullopt otherwise
*/
[[nodiscard]]
std::optional<AccountID>
getDelegate() const
{
if (tx_->isFieldPresent(sfDelegate))
return tx_->at(sfDelegate);
return std::nullopt;
}
/**
* @brief Check if the transaction has a delegate account.
* @return true if sfDelegate is present, false otherwise
*/
[[nodiscard]]
bool
hasDelegate() const
{
return tx_->isFieldPresent(sfDelegate);
}
/**
* @brief Get the underlying STTx object.
*
* Provides direct access to the wrapped transaction object for cases
* where the type-safe accessors are insufficient.
* @return A constant reference to the underlying STTx object
*/
[[nodiscard]]
std::shared_ptr<STTx const>
getSTTx() const
{
return tx_;
}
protected:
/** @brief The underlying transaction object being wrapped. */
std::shared_ptr<STTx const> tx_;
};
} // namespace xrpl::transactions

269
include/xrpl/protocol_autogen/TransactionBuilderBase.h Normal file
View File

@@ -0,0 +1,269 @@
#pragma once
#include <xrpl/protocol/HashPrefix.h>
#include <xrpl/protocol/PublicKey.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STAccount.h>
#include <xrpl/protocol/STAmount.h>
#include <xrpl/protocol/STArray.h>
#include <xrpl/protocol/STBlob.h>
#include <xrpl/protocol/STInteger.h>
#include <xrpl/protocol/STObject.h>
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/STXChainBridge.h>
#include <xrpl/protocol/SecretKey.h>
#include <xrpl/protocol/Serializer.h>
#include <xrpl/protocol/TxFormats.h>
#include <xrpl/protocol/jss.h>
namespace xrpl::transactions {
/**
* Base class for all transaction builders.
* Provides common field setters that are available for all transaction types.
*/
template <typename Derived>
class TransactionBuilderBase
{
public:
TransactionBuilderBase() = default;
TransactionBuilderBase(
SF_UINT16::type::value_type transactionType,
SF_ACCOUNT::type::value_type account,
std::optional<SF_UINT32::type::value_type> sequence,
std::optional<SF_AMOUNT::type::value_type> fee)
{
// Don't call object_.set(soTemplate) - keep object_ as a free object.
// This avoids creating STBase placeholders for soeDEFAULT fields,
// which would cause applyTemplate() to throw "may not be explicitly
// set to default" when building the STTx.
// The STTx constructor will call applyTemplate() which properly
// handles missing fields.
object_[sfTransactionType] = transactionType;
setAccount(account);
if (sequence)
{
setSequence(*sequence);
}
if (fee)
{
setFee(*fee);
}
}
/**
* Set the account that is sending the transaction.
* @param value Account address (typically as a string)
* @return Reference to the derived builder for method chaining.
*/
Derived&
setAccount(AccountID const& value)
{
object_[sfAccount] = value;
return static_cast<Derived&>(*this);
}
/**
* Set the transaction fee.
* @param value Fee in drops (typically as a string or number)
* @return Reference to the derived builder for method chaining.
*/
Derived&
setFee(STAmount const& value)
{
object_[sfFee] = value;
return static_cast<Derived&>(*this);
}
/**
* Set the sequence number.
* @param value Sequence number
* @return Reference to the derived builder for method chaining.
*/
Derived&
setSequence(std::uint32_t const& value)
{
object_[sfSequence] = value;
return static_cast<Derived&>(*this);
}
/**
* Set the ticket sequence to use for this transaction.
* When using a ticket, the regular sequence number is set to 0.
* @param value Ticket sequence number
* @return Reference to the derived builder for method chaining.
*/
Derived&
setTicketSequence(std::uint32_t const& value)
{
object_[sfSequence] = 0u;
object_[sfTicketSequence] = value;
return static_cast<Derived&>(*this);
}
/**
* Set transaction flags.
* @param value Flags value
* @return Reference to the derived builder for method chaining.
*/
Derived&
setFlags(std::uint32_t const& value)
{
object_[sfFlags] = value;
return static_cast<Derived&>(*this);
}
/**
* Set the source tag.
* @param value Source tag
* @return Reference to the derived builder for method chaining.
*/
Derived&
setSourceTag(std::uint32_t const& value)
{
object_[sfSourceTag] = value;
return static_cast<Derived&>(*this);
}
/**
* Set the last ledger sequence.
* @param value Last ledger sequence number
* @return Reference to the derived builder for method chaining.
*/
Derived&
setLastLedgerSequence(std::uint32_t const& value)
{
object_[sfLastLedgerSequence] = value;
return static_cast<Derived&>(*this);
}
/**
* Set the account transaction ID.
* @param value Account transaction ID (typically as a hex string)
* @return Reference to the derived builder for method chaining.
*/
Derived&
setAccountTxnID(uint256 const& value)
{
object_[sfAccountTxnID] = value;
return static_cast<Derived&>(*this);
}
/**
* Set the previous transaction ID.
* Used for emulate027 compatibility.
* @param value Previous transaction ID
* @return Reference to the derived builder for method chaining.
*/
Derived&
setPreviousTxnID(uint256 const& value)
{
object_[sfPreviousTxnID] = value;
return static_cast<Derived&>(*this);
}
/**
* Set the operation limit.
* @param value Operation limit
* @return Reference to the derived builder for method chaining.
*/
Derived&
setOperationLimit(std::uint32_t const& value)
{
object_[sfOperationLimit] = value;
return static_cast<Derived&>(*this);
}
/**
* Set the memos array.
* @param value Array of memo objects
* @return Reference to the derived builder for method chaining.
*/
Derived&
setMemos(STArray const& value)
{
object_.setFieldArray(sfMemos, value);
return static_cast<Derived&>(*this);
}
/**
* Set the signers array for multi-signing.
* @param value Array of signer objects
* @return Reference to the derived builder for method chaining.
*/
Derived&
setSigners(STArray const& value)
{
object_.setFieldArray(sfSigners, value);
return static_cast<Derived&>(*this);
}
/**
* Set the network ID.
* @param value Network ID
* @return Reference to the derived builder for method chaining.
*/
Derived&
setNetworkID(std::uint32_t const& value)
{
object_[sfNetworkID] = value;
return static_cast<Derived&>(*this);
}
/**
* Set the delegate account for delegated transactions.
* @param value Delegate account ID
* @return Reference to the derived builder for method chaining.
*/
Derived&
setDelegate(AccountID const& value)
{
object_[sfDelegate] = value;
return static_cast<Derived&>(*this);
}
/**
* Get the underlying STObject.
* @return The STObject
*/
STObject const&
getSTObject() const
{
return object_;
}
protected:
/**
* Sign the transaction with the given keys.
*
* This sets the SigningPubKey field and computes the TxnSignature.
*
* @param publicKey The public key for signing
* @param secretKey The secret key for signing
* @return Reference to the derived builder for method chaining.
*/
Derived&
sign(PublicKey const& publicKey, SecretKey const& secretKey)
{
// Set the signing public key
object_.setFieldVL(sfSigningPubKey, publicKey.slice());
// Build the signing data: HashPrefix::txSign + serialized object
// (without signing fields)
Serializer s;
s.add32(HashPrefix::txSign);
object_.addWithoutSigningFields(s);
// Sign and set the signature
auto const sig = xrpl::sign(publicKey, secretKey, s.slice());
object_.setFieldVL(sfTxnSignature, sig);
return static_cast<Derived&>(*this);
}
STObject object_{sfTransaction};
};
} // namespace xrpl::transactions

14
include/xrpl/protocol_autogen/Utils.h Normal file
View File

@@ -0,0 +1,14 @@
#pragma once
#include <optional>
#include <type_traits>
namespace xrpl::protocol_autogen {
template <typename ValueType>
using Optional = std::conditional_t<
std::is_reference_v<ValueType>,
std::optional<std::reference_wrapper<std::remove_reference_t<ValueType>>>,
std::optional<ValueType>>;
}

392
include/xrpl/protocol_autogen/ledger_entries/AMM.h Normal file
View File

@@ -0,0 +1,392 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class AMMBuilder;
/**
* @brief Ledger Entry: AMM
*
* Type: ltAMM (0x0079)
* RPC Name: amm
*
* Immutable wrapper around SLE providing type-safe field access.
* Use AMMBuilder to construct new ledger entries.
*/
class AMM : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltAMM;
/**
* @brief Construct a AMM ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit AMM(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for AMM");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfAccount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getAccount() const
{
return this->sle_->at(sfAccount);
}
/**
* @brief Get sfTradingFee (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT16::type::value_type>
getTradingFee() const
{
if (hasTradingFee())
return this->sle_->at(sfTradingFee);
return std::nullopt;
}
/**
* @brief Check if sfTradingFee is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasTradingFee() const
{
return this->sle_->isFieldPresent(sfTradingFee);
}
/**
* @brief Get sfVoteSlots (soeOPTIONAL)
* @note This is an untyped field (unknown).
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
std::optional<std::reference_wrapper<STArray const>>
getVoteSlots() const
{
if (this->sle_->isFieldPresent(sfVoteSlots))
return this->sle_->getFieldArray(sfVoteSlots);
return std::nullopt;
}
/**
* @brief Check if sfVoteSlots is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasVoteSlots() const
{
return this->sle_->isFieldPresent(sfVoteSlots);
}
/**
* @brief Get sfAuctionSlot (soeOPTIONAL)
* @note This is an untyped field (unknown).
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
std::optional<STObject>
getAuctionSlot() const
{
if (this->sle_->isFieldPresent(sfAuctionSlot))
return this->sle_->getFieldObject(sfAuctionSlot);
return std::nullopt;
}
/**
* @brief Check if sfAuctionSlot is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasAuctionSlot() const
{
return this->sle_->isFieldPresent(sfAuctionSlot);
}
/**
* @brief Get sfLPTokenBalance (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_AMOUNT::type::value_type
getLPTokenBalance() const
{
return this->sle_->at(sfLPTokenBalance);
}
/**
* @brief Get sfAsset (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ISSUE::type::value_type
getAsset() const
{
return this->sle_->at(sfAsset);
}
/**
* @brief Get sfAsset2 (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ISSUE::type::value_type
getAsset2() const
{
return this->sle_->at(sfAsset2);
}
/**
* @brief Get sfOwnerNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getOwnerNode() const
{
return this->sle_->at(sfOwnerNode);
}
/**
* @brief Get sfPreviousTxnID (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT256::type::value_type>
getPreviousTxnID() const
{
if (hasPreviousTxnID())
return this->sle_->at(sfPreviousTxnID);
return std::nullopt;
}
/**
* @brief Check if sfPreviousTxnID is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasPreviousTxnID() const
{
return this->sle_->isFieldPresent(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getPreviousTxnLgrSeq() const
{
if (hasPreviousTxnLgrSeq())
return this->sle_->at(sfPreviousTxnLgrSeq);
return std::nullopt;
}
/**
* @brief Check if sfPreviousTxnLgrSeq is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasPreviousTxnLgrSeq() const
{
return this->sle_->isFieldPresent(sfPreviousTxnLgrSeq);
}
};
/**
* @brief Builder for AMM ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class AMMBuilder : public LedgerEntryBuilderBase<AMMBuilder>
{
public:
/**
* @brief Construct a new AMMBuilder with required fields.
* @param account The sfAccount field value.
* @param lPTokenBalance The sfLPTokenBalance field value.
* @param asset The sfAsset field value.
* @param asset2 The sfAsset2 field value.
* @param ownerNode The sfOwnerNode field value.
*/
AMMBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_AMOUNT::type::value_type> const& lPTokenBalance,std::decay_t<typename SF_ISSUE::type::value_type> const& asset,std::decay_t<typename SF_ISSUE::type::value_type> const& asset2,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode)
: LedgerEntryBuilderBase<AMMBuilder>(ltAMM)
{
setAccount(account);
setLPTokenBalance(lPTokenBalance);
setAsset(asset);
setAsset2(asset2);
setOwnerNode(ownerNode);
}
/**
* @brief Construct a AMMBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
AMMBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltAMM)
{
throw std::runtime_error("Invalid ledger entry type for AMM");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfAccount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AMMBuilder&
setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfAccount] = value;
return *this;
}
/**
* @brief Set sfTradingFee (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
AMMBuilder&
setTradingFee(std::decay_t<typename SF_UINT16::type::value_type> const& value)
{
object_[sfTradingFee] = value;
return *this;
}
/**
* @brief Set sfVoteSlots (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AMMBuilder&
setVoteSlots(STArray const& value)
{
object_.setFieldArray(sfVoteSlots, value);
return *this;
}
/**
* @brief Set sfAuctionSlot (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AMMBuilder&
setAuctionSlot(STObject const& value)
{
object_.setFieldObject(sfAuctionSlot, value);
return *this;
}
/**
* @brief Set sfLPTokenBalance (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AMMBuilder&
setLPTokenBalance(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfLPTokenBalance] = value;
return *this;
}
/**
* @brief Set sfAsset (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AMMBuilder&
setAsset(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
{
object_[sfAsset] = STIssue(sfAsset, value);
return *this;
}
/**
* @brief Set sfAsset2 (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AMMBuilder&
setAsset2(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
{
object_[sfAsset2] = STIssue(sfAsset2, value);
return *this;
}
/**
* @brief Set sfOwnerNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AMMBuilder&
setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfOwnerNode] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AMMBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AMMBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Build and return the completed AMM wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
AMM
build(uint256 const& index)
{
return AMM{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

834
include/xrpl/protocol_autogen/ledger_entries/AccountRoot.h Normal file
View File

@@ -0,0 +1,834 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class AccountRootBuilder;
/**
* @brief Ledger Entry: AccountRoot
*
* Type: ltACCOUNT_ROOT (0x0061)
* RPC Name: account
*
* Immutable wrapper around SLE providing type-safe field access.
* Use AccountRootBuilder to construct new ledger entries.
*/
class AccountRoot : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltACCOUNT_ROOT;
/**
* @brief Construct a AccountRoot ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit AccountRoot(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for AccountRoot");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfAccount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getAccount() const
{
return this->sle_->at(sfAccount);
}
/**
* @brief Get sfSequence (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getSequence() const
{
return this->sle_->at(sfSequence);
}
/**
* @brief Get sfBalance (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_AMOUNT::type::value_type
getBalance() const
{
return this->sle_->at(sfBalance);
}
/**
* @brief Get sfOwnerCount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getOwnerCount() const
{
return this->sle_->at(sfOwnerCount);
}
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
/**
* @brief Get sfAccountTxnID (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT256::type::value_type>
getAccountTxnID() const
{
if (hasAccountTxnID())
return this->sle_->at(sfAccountTxnID);
return std::nullopt;
}
/**
* @brief Check if sfAccountTxnID is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasAccountTxnID() const
{
return this->sle_->isFieldPresent(sfAccountTxnID);
}
/**
* @brief Get sfRegularKey (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
getRegularKey() const
{
if (hasRegularKey())
return this->sle_->at(sfRegularKey);
return std::nullopt;
}
/**
* @brief Check if sfRegularKey is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasRegularKey() const
{
return this->sle_->isFieldPresent(sfRegularKey);
}
/**
* @brief Get sfEmailHash (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT128::type::value_type>
getEmailHash() const
{
if (hasEmailHash())
return this->sle_->at(sfEmailHash);
return std::nullopt;
}
/**
* @brief Check if sfEmailHash is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasEmailHash() const
{
return this->sle_->isFieldPresent(sfEmailHash);
}
/**
* @brief Get sfWalletLocator (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT256::type::value_type>
getWalletLocator() const
{
if (hasWalletLocator())
return this->sle_->at(sfWalletLocator);
return std::nullopt;
}
/**
* @brief Check if sfWalletLocator is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasWalletLocator() const
{
return this->sle_->isFieldPresent(sfWalletLocator);
}
/**
* @brief Get sfWalletSize (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getWalletSize() const
{
if (hasWalletSize())
return this->sle_->at(sfWalletSize);
return std::nullopt;
}
/**
* @brief Check if sfWalletSize is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasWalletSize() const
{
return this->sle_->isFieldPresent(sfWalletSize);
}
/**
* @brief Get sfMessageKey (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_VL::type::value_type>
getMessageKey() const
{
if (hasMessageKey())
return this->sle_->at(sfMessageKey);
return std::nullopt;
}
/**
* @brief Check if sfMessageKey is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasMessageKey() const
{
return this->sle_->isFieldPresent(sfMessageKey);
}
/**
* @brief Get sfTransferRate (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getTransferRate() const
{
if (hasTransferRate())
return this->sle_->at(sfTransferRate);
return std::nullopt;
}
/**
* @brief Check if sfTransferRate is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasTransferRate() const
{
return this->sle_->isFieldPresent(sfTransferRate);
}
/**
* @brief Get sfDomain (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_VL::type::value_type>
getDomain() const
{
if (hasDomain())
return this->sle_->at(sfDomain);
return std::nullopt;
}
/**
* @brief Check if sfDomain is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasDomain() const
{
return this->sle_->isFieldPresent(sfDomain);
}
/**
* @brief Get sfTickSize (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT8::type::value_type>
getTickSize() const
{
if (hasTickSize())
return this->sle_->at(sfTickSize);
return std::nullopt;
}
/**
* @brief Check if sfTickSize is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasTickSize() const
{
return this->sle_->isFieldPresent(sfTickSize);
}
/**
* @brief Get sfTicketCount (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getTicketCount() const
{
if (hasTicketCount())
return this->sle_->at(sfTicketCount);
return std::nullopt;
}
/**
* @brief Check if sfTicketCount is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasTicketCount() const
{
return this->sle_->isFieldPresent(sfTicketCount);
}
/**
* @brief Get sfNFTokenMinter (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
getNFTokenMinter() const
{
if (hasNFTokenMinter())
return this->sle_->at(sfNFTokenMinter);
return std::nullopt;
}
/**
* @brief Check if sfNFTokenMinter is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasNFTokenMinter() const
{
return this->sle_->isFieldPresent(sfNFTokenMinter);
}
/**
* @brief Get sfMintedNFTokens (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getMintedNFTokens() const
{
if (hasMintedNFTokens())
return this->sle_->at(sfMintedNFTokens);
return std::nullopt;
}
/**
* @brief Check if sfMintedNFTokens is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasMintedNFTokens() const
{
return this->sle_->isFieldPresent(sfMintedNFTokens);
}
/**
* @brief Get sfBurnedNFTokens (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getBurnedNFTokens() const
{
if (hasBurnedNFTokens())
return this->sle_->at(sfBurnedNFTokens);
return std::nullopt;
}
/**
* @brief Check if sfBurnedNFTokens is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasBurnedNFTokens() const
{
return this->sle_->isFieldPresent(sfBurnedNFTokens);
}
/**
* @brief Get sfFirstNFTokenSequence (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getFirstNFTokenSequence() const
{
if (hasFirstNFTokenSequence())
return this->sle_->at(sfFirstNFTokenSequence);
return std::nullopt;
}
/**
* @brief Check if sfFirstNFTokenSequence is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasFirstNFTokenSequence() const
{
return this->sle_->isFieldPresent(sfFirstNFTokenSequence);
}
/**
* @brief Get sfAMMID (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT256::type::value_type>
getAMMID() const
{
if (hasAMMID())
return this->sle_->at(sfAMMID);
return std::nullopt;
}
/**
* @brief Check if sfAMMID is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasAMMID() const
{
return this->sle_->isFieldPresent(sfAMMID);
}
/**
* @brief Get sfVaultID (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT256::type::value_type>
getVaultID() const
{
if (hasVaultID())
return this->sle_->at(sfVaultID);
return std::nullopt;
}
/**
* @brief Check if sfVaultID is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasVaultID() const
{
return this->sle_->isFieldPresent(sfVaultID);
}
/**
* @brief Get sfLoanBrokerID (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT256::type::value_type>
getLoanBrokerID() const
{
if (hasLoanBrokerID())
return this->sle_->at(sfLoanBrokerID);
return std::nullopt;
}
/**
* @brief Check if sfLoanBrokerID is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasLoanBrokerID() const
{
return this->sle_->isFieldPresent(sfLoanBrokerID);
}
};
/**
* @brief Builder for AccountRoot ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class AccountRootBuilder : public LedgerEntryBuilderBase<AccountRootBuilder>
{
public:
/**
* @brief Construct a new AccountRootBuilder with required fields.
* @param account The sfAccount field value.
* @param sequence The sfSequence field value.
* @param balance The sfBalance field value.
* @param ownerCount The sfOwnerCount field value.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
*/
AccountRootBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_UINT32::type::value_type> const& sequence,std::decay_t<typename SF_AMOUNT::type::value_type> const& balance,std::decay_t<typename SF_UINT32::type::value_type> const& ownerCount,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
: LedgerEntryBuilderBase<AccountRootBuilder>(ltACCOUNT_ROOT)
{
setAccount(account);
setSequence(sequence);
setBalance(balance);
setOwnerCount(ownerCount);
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
}
/**
* @brief Construct a AccountRootBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
AccountRootBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltACCOUNT_ROOT)
{
throw std::runtime_error("Invalid ledger entry type for AccountRoot");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfAccount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AccountRootBuilder&
setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfAccount] = value;
return *this;
}
/**
* @brief Set sfSequence (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AccountRootBuilder&
setSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfSequence] = value;
return *this;
}
/**
* @brief Set sfBalance (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AccountRootBuilder&
setBalance(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfBalance] = value;
return *this;
}
/**
* @brief Set sfOwnerCount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AccountRootBuilder&
setOwnerCount(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfOwnerCount] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AccountRootBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AccountRootBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Set sfAccountTxnID (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountRootBuilder&
setAccountTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfAccountTxnID] = value;
return *this;
}
/**
* @brief Set sfRegularKey (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountRootBuilder&
setRegularKey(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfRegularKey] = value;
return *this;
}
/**
* @brief Set sfEmailHash (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountRootBuilder&
setEmailHash(std::decay_t<typename SF_UINT128::type::value_type> const& value)
{
object_[sfEmailHash] = value;
return *this;
}
/**
* @brief Set sfWalletLocator (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountRootBuilder&
setWalletLocator(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfWalletLocator] = value;
return *this;
}
/**
* @brief Set sfWalletSize (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountRootBuilder&
setWalletSize(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfWalletSize] = value;
return *this;
}
/**
* @brief Set sfMessageKey (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountRootBuilder&
setMessageKey(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfMessageKey] = value;
return *this;
}
/**
* @brief Set sfTransferRate (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountRootBuilder&
setTransferRate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfTransferRate] = value;
return *this;
}
/**
* @brief Set sfDomain (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountRootBuilder&
setDomain(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfDomain] = value;
return *this;
}
/**
* @brief Set sfTickSize (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountRootBuilder&
setTickSize(std::decay_t<typename SF_UINT8::type::value_type> const& value)
{
object_[sfTickSize] = value;
return *this;
}
/**
* @brief Set sfTicketCount (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountRootBuilder&
setTicketCount(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfTicketCount] = value;
return *this;
}
/**
* @brief Set sfNFTokenMinter (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountRootBuilder&
setNFTokenMinter(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfNFTokenMinter] = value;
return *this;
}
/**
* @brief Set sfMintedNFTokens (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
AccountRootBuilder&
setMintedNFTokens(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfMintedNFTokens] = value;
return *this;
}
/**
* @brief Set sfBurnedNFTokens (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
AccountRootBuilder&
setBurnedNFTokens(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfBurnedNFTokens] = value;
return *this;
}
/**
* @brief Set sfFirstNFTokenSequence (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountRootBuilder&
setFirstNFTokenSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfFirstNFTokenSequence] = value;
return *this;
}
/**
* @brief Set sfAMMID (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountRootBuilder&
setAMMID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfAMMID] = value;
return *this;
}
/**
* @brief Set sfVaultID (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountRootBuilder&
setVaultID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfVaultID] = value;
return *this;
}
/**
* @brief Set sfLoanBrokerID (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountRootBuilder&
setLoanBrokerID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfLoanBrokerID] = value;
return *this;
}
/**
* @brief Build and return the completed AccountRoot wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
AccountRoot
build(uint256 const& index)
{
return AccountRoot{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

236
include/xrpl/protocol_autogen/ledger_entries/Amendments.h Normal file
View File

@@ -0,0 +1,236 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class AmendmentsBuilder;
/**
* @brief Ledger Entry: Amendments
*
* Type: ltAMENDMENTS (0x0066)
* RPC Name: amendments
*
* Immutable wrapper around SLE providing type-safe field access.
* Use AmendmentsBuilder to construct new ledger entries.
*/
class Amendments : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltAMENDMENTS;
/**
* @brief Construct a Amendments ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit Amendments(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for Amendments");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfAmendments (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_VECTOR256::type::value_type>
getAmendments() const
{
if (hasAmendments())
return this->sle_->at(sfAmendments);
return std::nullopt;
}
/**
* @brief Check if sfAmendments is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasAmendments() const
{
return this->sle_->isFieldPresent(sfAmendments);
}
/**
* @brief Get sfMajorities (soeOPTIONAL)
* @note This is an untyped field (unknown).
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
std::optional<std::reference_wrapper<STArray const>>
getMajorities() const
{
if (this->sle_->isFieldPresent(sfMajorities))
return this->sle_->getFieldArray(sfMajorities);
return std::nullopt;
}
/**
* @brief Check if sfMajorities is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasMajorities() const
{
return this->sle_->isFieldPresent(sfMajorities);
}
/**
* @brief Get sfPreviousTxnID (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT256::type::value_type>
getPreviousTxnID() const
{
if (hasPreviousTxnID())
return this->sle_->at(sfPreviousTxnID);
return std::nullopt;
}
/**
* @brief Check if sfPreviousTxnID is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasPreviousTxnID() const
{
return this->sle_->isFieldPresent(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getPreviousTxnLgrSeq() const
{
if (hasPreviousTxnLgrSeq())
return this->sle_->at(sfPreviousTxnLgrSeq);
return std::nullopt;
}
/**
* @brief Check if sfPreviousTxnLgrSeq is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasPreviousTxnLgrSeq() const
{
return this->sle_->isFieldPresent(sfPreviousTxnLgrSeq);
}
};
/**
* @brief Builder for Amendments ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class AmendmentsBuilder : public LedgerEntryBuilderBase<AmendmentsBuilder>
{
public:
/**
* @brief Construct a new AmendmentsBuilder with required fields.
*/
AmendmentsBuilder()
: LedgerEntryBuilderBase<AmendmentsBuilder>(ltAMENDMENTS)
{
}
/**
* @brief Construct a AmendmentsBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
AmendmentsBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltAMENDMENTS)
{
throw std::runtime_error("Invalid ledger entry type for Amendments");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfAmendments (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AmendmentsBuilder&
setAmendments(std::decay_t<typename SF_VECTOR256::type::value_type> const& value)
{
object_[sfAmendments] = value;
return *this;
}
/**
* @brief Set sfMajorities (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AmendmentsBuilder&
setMajorities(STArray const& value)
{
object_.setFieldArray(sfMajorities, value);
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AmendmentsBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AmendmentsBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Build and return the completed Amendments wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
Amendments
build(uint256 const& index)
{
return Amendments{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

346
include/xrpl/protocol_autogen/ledger_entries/Bridge.h Normal file
View File

@@ -0,0 +1,346 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class BridgeBuilder;
/**
* @brief Ledger Entry: Bridge
*
* Type: ltBRIDGE (0x0069)
* RPC Name: bridge
*
* Immutable wrapper around SLE providing type-safe field access.
* Use BridgeBuilder to construct new ledger entries.
*/
class Bridge : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltBRIDGE;
/**
* @brief Construct a Bridge ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit Bridge(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for Bridge");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfAccount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getAccount() const
{
return this->sle_->at(sfAccount);
}
/**
* @brief Get sfSignatureReward (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_AMOUNT::type::value_type
getSignatureReward() const
{
return this->sle_->at(sfSignatureReward);
}
/**
* @brief Get sfMinAccountCreateAmount (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_AMOUNT::type::value_type>
getMinAccountCreateAmount() const
{
if (hasMinAccountCreateAmount())
return this->sle_->at(sfMinAccountCreateAmount);
return std::nullopt;
}
/**
* @brief Check if sfMinAccountCreateAmount is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasMinAccountCreateAmount() const
{
return this->sle_->isFieldPresent(sfMinAccountCreateAmount);
}
/**
* @brief Get sfXChainBridge (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_XCHAIN_BRIDGE::type::value_type
getXChainBridge() const
{
return this->sle_->at(sfXChainBridge);
}
/**
* @brief Get sfXChainClaimID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getXChainClaimID() const
{
return this->sle_->at(sfXChainClaimID);
}
/**
* @brief Get sfXChainAccountCreateCount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getXChainAccountCreateCount() const
{
return this->sle_->at(sfXChainAccountCreateCount);
}
/**
* @brief Get sfXChainAccountClaimCount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getXChainAccountClaimCount() const
{
return this->sle_->at(sfXChainAccountClaimCount);
}
/**
* @brief Get sfOwnerNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getOwnerNode() const
{
return this->sle_->at(sfOwnerNode);
}
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
};
/**
* @brief Builder for Bridge ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class BridgeBuilder : public LedgerEntryBuilderBase<BridgeBuilder>
{
public:
/**
* @brief Construct a new BridgeBuilder with required fields.
* @param account The sfAccount field value.
* @param signatureReward The sfSignatureReward field value.
* @param xChainBridge The sfXChainBridge field value.
* @param xChainClaimID The sfXChainClaimID field value.
* @param xChainAccountCreateCount The sfXChainAccountCreateCount field value.
* @param xChainAccountClaimCount The sfXChainAccountClaimCount field value.
* @param ownerNode The sfOwnerNode field value.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
*/
BridgeBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_AMOUNT::type::value_type> const& signatureReward,std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& xChainBridge,std::decay_t<typename SF_UINT64::type::value_type> const& xChainClaimID,std::decay_t<typename SF_UINT64::type::value_type> const& xChainAccountCreateCount,std::decay_t<typename SF_UINT64::type::value_type> const& xChainAccountClaimCount,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
: LedgerEntryBuilderBase<BridgeBuilder>(ltBRIDGE)
{
setAccount(account);
setSignatureReward(signatureReward);
setXChainBridge(xChainBridge);
setXChainClaimID(xChainClaimID);
setXChainAccountCreateCount(xChainAccountCreateCount);
setXChainAccountClaimCount(xChainAccountClaimCount);
setOwnerNode(ownerNode);
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
}
/**
* @brief Construct a BridgeBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
BridgeBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltBRIDGE)
{
throw std::runtime_error("Invalid ledger entry type for Bridge");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfAccount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
BridgeBuilder&
setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfAccount] = value;
return *this;
}
/**
* @brief Set sfSignatureReward (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
BridgeBuilder&
setSignatureReward(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfSignatureReward] = value;
return *this;
}
/**
* @brief Set sfMinAccountCreateAmount (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
BridgeBuilder&
setMinAccountCreateAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfMinAccountCreateAmount] = value;
return *this;
}
/**
* @brief Set sfXChainBridge (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
BridgeBuilder&
setXChainBridge(std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& value)
{
object_[sfXChainBridge] = value;
return *this;
}
/**
* @brief Set sfXChainClaimID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
BridgeBuilder&
setXChainClaimID(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfXChainClaimID] = value;
return *this;
}
/**
* @brief Set sfXChainAccountCreateCount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
BridgeBuilder&
setXChainAccountCreateCount(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfXChainAccountCreateCount] = value;
return *this;
}
/**
* @brief Set sfXChainAccountClaimCount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
BridgeBuilder&
setXChainAccountClaimCount(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfXChainAccountClaimCount] = value;
return *this;
}
/**
* @brief Set sfOwnerNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
BridgeBuilder&
setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfOwnerNode] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
BridgeBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
BridgeBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Build and return the completed Bridge wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
Bridge
build(uint256 const& index)
{
return Bridge{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

427
include/xrpl/protocol_autogen/ledger_entries/Check.h Normal file
View File

@@ -0,0 +1,427 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class CheckBuilder;
/**
* @brief Ledger Entry: Check
*
* Type: ltCHECK (0x0043)
* RPC Name: check
*
* Immutable wrapper around SLE providing type-safe field access.
* Use CheckBuilder to construct new ledger entries.
*/
class Check : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltCHECK;
/**
* @brief Construct a Check ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit Check(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for Check");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfAccount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getAccount() const
{
return this->sle_->at(sfAccount);
}
/**
* @brief Get sfDestination (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getDestination() const
{
return this->sle_->at(sfDestination);
}
/**
* @brief Get sfSendMax (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_AMOUNT::type::value_type
getSendMax() const
{
return this->sle_->at(sfSendMax);
}
/**
* @brief Get sfSequence (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getSequence() const
{
return this->sle_->at(sfSequence);
}
/**
* @brief Get sfOwnerNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getOwnerNode() const
{
return this->sle_->at(sfOwnerNode);
}
/**
* @brief Get sfDestinationNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getDestinationNode() const
{
return this->sle_->at(sfDestinationNode);
}
/**
* @brief Get sfExpiration (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getExpiration() const
{
if (hasExpiration())
return this->sle_->at(sfExpiration);
return std::nullopt;
}
/**
* @brief Check if sfExpiration is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasExpiration() const
{
return this->sle_->isFieldPresent(sfExpiration);
}
/**
* @brief Get sfInvoiceID (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT256::type::value_type>
getInvoiceID() const
{
if (hasInvoiceID())
return this->sle_->at(sfInvoiceID);
return std::nullopt;
}
/**
* @brief Check if sfInvoiceID is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasInvoiceID() const
{
return this->sle_->isFieldPresent(sfInvoiceID);
}
/**
* @brief Get sfSourceTag (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getSourceTag() const
{
if (hasSourceTag())
return this->sle_->at(sfSourceTag);
return std::nullopt;
}
/**
* @brief Check if sfSourceTag is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasSourceTag() const
{
return this->sle_->isFieldPresent(sfSourceTag);
}
/**
* @brief Get sfDestinationTag (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getDestinationTag() const
{
if (hasDestinationTag())
return this->sle_->at(sfDestinationTag);
return std::nullopt;
}
/**
* @brief Check if sfDestinationTag is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasDestinationTag() const
{
return this->sle_->isFieldPresent(sfDestinationTag);
}
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
};
/**
* @brief Builder for Check ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class CheckBuilder : public LedgerEntryBuilderBase<CheckBuilder>
{
public:
/**
* @brief Construct a new CheckBuilder with required fields.
* @param account The sfAccount field value.
* @param destination The sfDestination field value.
* @param sendMax The sfSendMax field value.
* @param sequence The sfSequence field value.
* @param ownerNode The sfOwnerNode field value.
* @param destinationNode The sfDestinationNode field value.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
*/
CheckBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_ACCOUNT::type::value_type> const& destination,std::decay_t<typename SF_AMOUNT::type::value_type> const& sendMax,std::decay_t<typename SF_UINT32::type::value_type> const& sequence,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT64::type::value_type> const& destinationNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
: LedgerEntryBuilderBase<CheckBuilder>(ltCHECK)
{
setAccount(account);
setDestination(destination);
setSendMax(sendMax);
setSequence(sequence);
setOwnerNode(ownerNode);
setDestinationNode(destinationNode);
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
}
/**
* @brief Construct a CheckBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
CheckBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltCHECK)
{
throw std::runtime_error("Invalid ledger entry type for Check");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfAccount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
CheckBuilder&
setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfAccount] = value;
return *this;
}
/**
* @brief Set sfDestination (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
CheckBuilder&
setDestination(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfDestination] = value;
return *this;
}
/**
* @brief Set sfSendMax (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
CheckBuilder&
setSendMax(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfSendMax] = value;
return *this;
}
/**
* @brief Set sfSequence (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
CheckBuilder&
setSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfSequence] = value;
return *this;
}
/**
* @brief Set sfOwnerNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
CheckBuilder&
setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfOwnerNode] = value;
return *this;
}
/**
* @brief Set sfDestinationNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
CheckBuilder&
setDestinationNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfDestinationNode] = value;
return *this;
}
/**
* @brief Set sfExpiration (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
CheckBuilder&
setExpiration(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfExpiration] = value;
return *this;
}
/**
* @brief Set sfInvoiceID (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
CheckBuilder&
setInvoiceID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfInvoiceID] = value;
return *this;
}
/**
* @brief Set sfSourceTag (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
CheckBuilder&
setSourceTag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfSourceTag] = value;
return *this;
}
/**
* @brief Set sfDestinationTag (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
CheckBuilder&
setDestinationTag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfDestinationTag] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
CheckBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
CheckBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Build and return the completed Check wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
Check
build(uint256 const& index)
{
return Check{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

344
include/xrpl/protocol_autogen/ledger_entries/Credential.h Normal file
View File

@@ -0,0 +1,344 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class CredentialBuilder;
/**
* @brief Ledger Entry: Credential
*
* Type: ltCREDENTIAL (0x0081)
* RPC Name: credential
*
* Immutable wrapper around SLE providing type-safe field access.
* Use CredentialBuilder to construct new ledger entries.
*/
class Credential : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltCREDENTIAL;
/**
* @brief Construct a Credential ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit Credential(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for Credential");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfSubject (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getSubject() const
{
return this->sle_->at(sfSubject);
}
/**
* @brief Get sfIssuer (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getIssuer() const
{
return this->sle_->at(sfIssuer);
}
/**
* @brief Get sfCredentialType (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_VL::type::value_type
getCredentialType() const
{
return this->sle_->at(sfCredentialType);
}
/**
* @brief Get sfExpiration (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getExpiration() const
{
if (hasExpiration())
return this->sle_->at(sfExpiration);
return std::nullopt;
}
/**
* @brief Check if sfExpiration is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasExpiration() const
{
return this->sle_->isFieldPresent(sfExpiration);
}
/**
* @brief Get sfURI (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_VL::type::value_type>
getURI() const
{
if (hasURI())
return this->sle_->at(sfURI);
return std::nullopt;
}
/**
* @brief Check if sfURI is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasURI() const
{
return this->sle_->isFieldPresent(sfURI);
}
/**
* @brief Get sfIssuerNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getIssuerNode() const
{
return this->sle_->at(sfIssuerNode);
}
/**
* @brief Get sfSubjectNode (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT64::type::value_type>
getSubjectNode() const
{
if (hasSubjectNode())
return this->sle_->at(sfSubjectNode);
return std::nullopt;
}
/**
* @brief Check if sfSubjectNode is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasSubjectNode() const
{
return this->sle_->isFieldPresent(sfSubjectNode);
}
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
};
/**
* @brief Builder for Credential ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class CredentialBuilder : public LedgerEntryBuilderBase<CredentialBuilder>
{
public:
/**
* @brief Construct a new CredentialBuilder with required fields.
* @param subject The sfSubject field value.
* @param issuer The sfIssuer field value.
* @param credentialType The sfCredentialType field value.
* @param issuerNode The sfIssuerNode field value.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
*/
CredentialBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& subject,std::decay_t<typename SF_ACCOUNT::type::value_type> const& issuer,std::decay_t<typename SF_VL::type::value_type> const& credentialType,std::decay_t<typename SF_UINT64::type::value_type> const& issuerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
: LedgerEntryBuilderBase<CredentialBuilder>(ltCREDENTIAL)
{
setSubject(subject);
setIssuer(issuer);
setCredentialType(credentialType);
setIssuerNode(issuerNode);
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
}
/**
* @brief Construct a CredentialBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
CredentialBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltCREDENTIAL)
{
throw std::runtime_error("Invalid ledger entry type for Credential");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfSubject (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
CredentialBuilder&
setSubject(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfSubject] = value;
return *this;
}
/**
* @brief Set sfIssuer (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
CredentialBuilder&
setIssuer(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfIssuer] = value;
return *this;
}
/**
* @brief Set sfCredentialType (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
CredentialBuilder&
setCredentialType(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfCredentialType] = value;
return *this;
}
/**
* @brief Set sfExpiration (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
CredentialBuilder&
setExpiration(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfExpiration] = value;
return *this;
}
/**
* @brief Set sfURI (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
CredentialBuilder&
setURI(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfURI] = value;
return *this;
}
/**
* @brief Set sfIssuerNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
CredentialBuilder&
setIssuerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfIssuerNode] = value;
return *this;
}
/**
* @brief Set sfSubjectNode (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
CredentialBuilder&
setSubjectNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfSubjectNode] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
CredentialBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
CredentialBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Build and return the completed Credential wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
Credential
build(uint256 const& index)
{
return Credential{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

296
include/xrpl/protocol_autogen/ledger_entries/DID.h Normal file
View File

@@ -0,0 +1,296 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class DIDBuilder;
/**
* @brief Ledger Entry: DID
*
* Type: ltDID (0x0049)
* RPC Name: did
*
* Immutable wrapper around SLE providing type-safe field access.
* Use DIDBuilder to construct new ledger entries.
*/
class DID : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltDID;
/**
* @brief Construct a DID ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit DID(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for DID");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfAccount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getAccount() const
{
return this->sle_->at(sfAccount);
}
/**
* @brief Get sfDIDDocument (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_VL::type::value_type>
getDIDDocument() const
{
if (hasDIDDocument())
return this->sle_->at(sfDIDDocument);
return std::nullopt;
}
/**
* @brief Check if sfDIDDocument is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasDIDDocument() const
{
return this->sle_->isFieldPresent(sfDIDDocument);
}
/**
* @brief Get sfURI (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_VL::type::value_type>
getURI() const
{
if (hasURI())
return this->sle_->at(sfURI);
return std::nullopt;
}
/**
* @brief Check if sfURI is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasURI() const
{
return this->sle_->isFieldPresent(sfURI);
}
/**
* @brief Get sfData (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_VL::type::value_type>
getData() const
{
if (hasData())
return this->sle_->at(sfData);
return std::nullopt;
}
/**
* @brief Check if sfData is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasData() const
{
return this->sle_->isFieldPresent(sfData);
}
/**
* @brief Get sfOwnerNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getOwnerNode() const
{
return this->sle_->at(sfOwnerNode);
}
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
};
/**
* @brief Builder for DID ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class DIDBuilder : public LedgerEntryBuilderBase<DIDBuilder>
{
public:
/**
* @brief Construct a new DIDBuilder with required fields.
* @param account The sfAccount field value.
* @param ownerNode The sfOwnerNode field value.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
*/
DIDBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
: LedgerEntryBuilderBase<DIDBuilder>(ltDID)
{
setAccount(account);
setOwnerNode(ownerNode);
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
}
/**
* @brief Construct a DIDBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
DIDBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltDID)
{
throw std::runtime_error("Invalid ledger entry type for DID");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfAccount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
DIDBuilder&
setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfAccount] = value;
return *this;
}
/**
* @brief Set sfDIDDocument (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
DIDBuilder&
setDIDDocument(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfDIDDocument] = value;
return *this;
}
/**
* @brief Set sfURI (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
DIDBuilder&
setURI(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfURI] = value;
return *this;
}
/**
* @brief Set sfData (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
DIDBuilder&
setData(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfData] = value;
return *this;
}
/**
* @brief Set sfOwnerNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
DIDBuilder&
setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfOwnerNode] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
DIDBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
DIDBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Build and return the completed DID wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
DID
build(uint256 const& index)
{
return DID{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

240
include/xrpl/protocol_autogen/ledger_entries/Delegate.h Normal file
View File

@@ -0,0 +1,240 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class DelegateBuilder;
/**
* @brief Ledger Entry: Delegate
*
* Type: ltDELEGATE (0x0083)
* RPC Name: delegate
*
* Immutable wrapper around SLE providing type-safe field access.
* Use DelegateBuilder to construct new ledger entries.
*/
class Delegate : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltDELEGATE;
/**
* @brief Construct a Delegate ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit Delegate(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for Delegate");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfAccount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getAccount() const
{
return this->sle_->at(sfAccount);
}
/**
* @brief Get sfAuthorize (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getAuthorize() const
{
return this->sle_->at(sfAuthorize);
}
/**
* @brief Get sfPermissions (soeREQUIRED)
* @note This is an untyped field (unknown).
* @return The field value.
*/
[[nodiscard]]
STArray const&
getPermissions() const
{
return this->sle_->getFieldArray(sfPermissions);
}
/**
* @brief Get sfOwnerNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getOwnerNode() const
{
return this->sle_->at(sfOwnerNode);
}
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
};
/**
* @brief Builder for Delegate ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class DelegateBuilder : public LedgerEntryBuilderBase<DelegateBuilder>
{
public:
/**
* @brief Construct a new DelegateBuilder with required fields.
* @param account The sfAccount field value.
* @param authorize The sfAuthorize field value.
* @param permissions The sfPermissions field value.
* @param ownerNode The sfOwnerNode field value.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
*/
DelegateBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_ACCOUNT::type::value_type> const& authorize,STArray const& permissions,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
: LedgerEntryBuilderBase<DelegateBuilder>(ltDELEGATE)
{
setAccount(account);
setAuthorize(authorize);
setPermissions(permissions);
setOwnerNode(ownerNode);
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
}
/**
* @brief Construct a DelegateBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
DelegateBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltDELEGATE)
{
throw std::runtime_error("Invalid ledger entry type for Delegate");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfAccount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
DelegateBuilder&
setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfAccount] = value;
return *this;
}
/**
* @brief Set sfAuthorize (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
DelegateBuilder&
setAuthorize(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfAuthorize] = value;
return *this;
}
/**
* @brief Set sfPermissions (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
DelegateBuilder&
setPermissions(STArray const& value)
{
object_.setFieldArray(sfPermissions, value);
return *this;
}
/**
* @brief Set sfOwnerNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
DelegateBuilder&
setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfOwnerNode] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
DelegateBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
DelegateBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Build and return the completed Delegate wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
Delegate
build(uint256 const& index)
{
return Delegate{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

262
include/xrpl/protocol_autogen/ledger_entries/DepositPreauth.h Normal file
View File

@@ -0,0 +1,262 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class DepositPreauthBuilder;
/**
* @brief Ledger Entry: DepositPreauth
*
* Type: ltDEPOSIT_PREAUTH (0x0070)
* RPC Name: deposit_preauth
*
* Immutable wrapper around SLE providing type-safe field access.
* Use DepositPreauthBuilder to construct new ledger entries.
*/
class DepositPreauth : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltDEPOSIT_PREAUTH;
/**
* @brief Construct a DepositPreauth ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit DepositPreauth(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for DepositPreauth");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfAccount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getAccount() const
{
return this->sle_->at(sfAccount);
}
/**
* @brief Get sfAuthorize (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
getAuthorize() const
{
if (hasAuthorize())
return this->sle_->at(sfAuthorize);
return std::nullopt;
}
/**
* @brief Check if sfAuthorize is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasAuthorize() const
{
return this->sle_->isFieldPresent(sfAuthorize);
}
/**
* @brief Get sfOwnerNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getOwnerNode() const
{
return this->sle_->at(sfOwnerNode);
}
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
/**
* @brief Get sfAuthorizeCredentials (soeOPTIONAL)
* @note This is an untyped field (unknown).
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
std::optional<std::reference_wrapper<STArray const>>
getAuthorizeCredentials() const
{
if (this->sle_->isFieldPresent(sfAuthorizeCredentials))
return this->sle_->getFieldArray(sfAuthorizeCredentials);
return std::nullopt;
}
/**
* @brief Check if sfAuthorizeCredentials is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasAuthorizeCredentials() const
{
return this->sle_->isFieldPresent(sfAuthorizeCredentials);
}
};
/**
* @brief Builder for DepositPreauth ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class DepositPreauthBuilder : public LedgerEntryBuilderBase<DepositPreauthBuilder>
{
public:
/**
* @brief Construct a new DepositPreauthBuilder with required fields.
* @param account The sfAccount field value.
* @param ownerNode The sfOwnerNode field value.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
*/
DepositPreauthBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
: LedgerEntryBuilderBase<DepositPreauthBuilder>(ltDEPOSIT_PREAUTH)
{
setAccount(account);
setOwnerNode(ownerNode);
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
}
/**
* @brief Construct a DepositPreauthBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
DepositPreauthBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltDEPOSIT_PREAUTH)
{
throw std::runtime_error("Invalid ledger entry type for DepositPreauth");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfAccount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
DepositPreauthBuilder&
setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfAccount] = value;
return *this;
}
/**
* @brief Set sfAuthorize (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
DepositPreauthBuilder&
setAuthorize(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfAuthorize] = value;
return *this;
}
/**
* @brief Set sfOwnerNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
DepositPreauthBuilder&
setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfOwnerNode] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
DepositPreauthBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
DepositPreauthBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Set sfAuthorizeCredentials (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
DepositPreauthBuilder&
setAuthorizeCredentials(STArray const& value)
{
object_.setFieldArray(sfAuthorizeCredentials, value);
return *this;
}
/**
* @brief Build and return the completed DepositPreauth wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
DepositPreauth
build(uint256 const& index)
{
return DepositPreauth{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

563
include/xrpl/protocol_autogen/ledger_entries/DirectoryNode.h Normal file
View File

@@ -0,0 +1,563 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class DirectoryNodeBuilder;
/**
* @brief Ledger Entry: DirectoryNode
*
* Type: ltDIR_NODE (0x0064)
* RPC Name: directory
*
* Immutable wrapper around SLE providing type-safe field access.
* Use DirectoryNodeBuilder to construct new ledger entries.
*/
class DirectoryNode : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltDIR_NODE;
/**
* @brief Construct a DirectoryNode ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit DirectoryNode(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for DirectoryNode");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfOwner (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
getOwner() const
{
if (hasOwner())
return this->sle_->at(sfOwner);
return std::nullopt;
}
/**
* @brief Check if sfOwner is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasOwner() const
{
return this->sle_->isFieldPresent(sfOwner);
}
/**
* @brief Get sfTakerPaysCurrency (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT160::type::value_type>
getTakerPaysCurrency() const
{
if (hasTakerPaysCurrency())
return this->sle_->at(sfTakerPaysCurrency);
return std::nullopt;
}
/**
* @brief Check if sfTakerPaysCurrency is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasTakerPaysCurrency() const
{
return this->sle_->isFieldPresent(sfTakerPaysCurrency);
}
/**
* @brief Get sfTakerPaysIssuer (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT160::type::value_type>
getTakerPaysIssuer() const
{
if (hasTakerPaysIssuer())
return this->sle_->at(sfTakerPaysIssuer);
return std::nullopt;
}
/**
* @brief Check if sfTakerPaysIssuer is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasTakerPaysIssuer() const
{
return this->sle_->isFieldPresent(sfTakerPaysIssuer);
}
/**
* @brief Get sfTakerGetsCurrency (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT160::type::value_type>
getTakerGetsCurrency() const
{
if (hasTakerGetsCurrency())
return this->sle_->at(sfTakerGetsCurrency);
return std::nullopt;
}
/**
* @brief Check if sfTakerGetsCurrency is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasTakerGetsCurrency() const
{
return this->sle_->isFieldPresent(sfTakerGetsCurrency);
}
/**
* @brief Get sfTakerGetsIssuer (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT160::type::value_type>
getTakerGetsIssuer() const
{
if (hasTakerGetsIssuer())
return this->sle_->at(sfTakerGetsIssuer);
return std::nullopt;
}
/**
* @brief Check if sfTakerGetsIssuer is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasTakerGetsIssuer() const
{
return this->sle_->isFieldPresent(sfTakerGetsIssuer);
}
/**
* @brief Get sfExchangeRate (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT64::type::value_type>
getExchangeRate() const
{
if (hasExchangeRate())
return this->sle_->at(sfExchangeRate);
return std::nullopt;
}
/**
* @brief Check if sfExchangeRate is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasExchangeRate() const
{
return this->sle_->isFieldPresent(sfExchangeRate);
}
/**
* @brief Get sfIndexes (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_VECTOR256::type::value_type
getIndexes() const
{
return this->sle_->at(sfIndexes);
}
/**
* @brief Get sfRootIndex (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getRootIndex() const
{
return this->sle_->at(sfRootIndex);
}
/**
* @brief Get sfIndexNext (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT64::type::value_type>
getIndexNext() const
{
if (hasIndexNext())
return this->sle_->at(sfIndexNext);
return std::nullopt;
}
/**
* @brief Check if sfIndexNext is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasIndexNext() const
{
return this->sle_->isFieldPresent(sfIndexNext);
}
/**
* @brief Get sfIndexPrevious (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT64::type::value_type>
getIndexPrevious() const
{
if (hasIndexPrevious())
return this->sle_->at(sfIndexPrevious);
return std::nullopt;
}
/**
* @brief Check if sfIndexPrevious is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasIndexPrevious() const
{
return this->sle_->isFieldPresent(sfIndexPrevious);
}
/**
* @brief Get sfNFTokenID (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT256::type::value_type>
getNFTokenID() const
{
if (hasNFTokenID())
return this->sle_->at(sfNFTokenID);
return std::nullopt;
}
/**
* @brief Check if sfNFTokenID is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasNFTokenID() const
{
return this->sle_->isFieldPresent(sfNFTokenID);
}
/**
* @brief Get sfPreviousTxnID (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT256::type::value_type>
getPreviousTxnID() const
{
if (hasPreviousTxnID())
return this->sle_->at(sfPreviousTxnID);
return std::nullopt;
}
/**
* @brief Check if sfPreviousTxnID is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasPreviousTxnID() const
{
return this->sle_->isFieldPresent(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getPreviousTxnLgrSeq() const
{
if (hasPreviousTxnLgrSeq())
return this->sle_->at(sfPreviousTxnLgrSeq);
return std::nullopt;
}
/**
* @brief Check if sfPreviousTxnLgrSeq is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasPreviousTxnLgrSeq() const
{
return this->sle_->isFieldPresent(sfPreviousTxnLgrSeq);
}
/**
* @brief Get sfDomainID (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT256::type::value_type>
getDomainID() const
{
if (hasDomainID())
return this->sle_->at(sfDomainID);
return std::nullopt;
}
/**
* @brief Check if sfDomainID is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasDomainID() const
{
return this->sle_->isFieldPresent(sfDomainID);
}
};
/**
* @brief Builder for DirectoryNode ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class DirectoryNodeBuilder : public LedgerEntryBuilderBase<DirectoryNodeBuilder>
{
public:
/**
* @brief Construct a new DirectoryNodeBuilder with required fields.
* @param indexes The sfIndexes field value.
* @param rootIndex The sfRootIndex field value.
*/
DirectoryNodeBuilder(std::decay_t<typename SF_VECTOR256::type::value_type> const& indexes,std::decay_t<typename SF_UINT256::type::value_type> const& rootIndex)
: LedgerEntryBuilderBase<DirectoryNodeBuilder>(ltDIR_NODE)
{
setIndexes(indexes);
setRootIndex(rootIndex);
}
/**
* @brief Construct a DirectoryNodeBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
DirectoryNodeBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltDIR_NODE)
{
throw std::runtime_error("Invalid ledger entry type for DirectoryNode");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfOwner (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
DirectoryNodeBuilder&
setOwner(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfOwner] = value;
return *this;
}
/**
* @brief Set sfTakerPaysCurrency (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
DirectoryNodeBuilder&
setTakerPaysCurrency(std::decay_t<typename SF_UINT160::type::value_type> const& value)
{
object_[sfTakerPaysCurrency] = value;
return *this;
}
/**
* @brief Set sfTakerPaysIssuer (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
DirectoryNodeBuilder&
setTakerPaysIssuer(std::decay_t<typename SF_UINT160::type::value_type> const& value)
{
object_[sfTakerPaysIssuer] = value;
return *this;
}
/**
* @brief Set sfTakerGetsCurrency (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
DirectoryNodeBuilder&
setTakerGetsCurrency(std::decay_t<typename SF_UINT160::type::value_type> const& value)
{
object_[sfTakerGetsCurrency] = value;
return *this;
}
/**
* @brief Set sfTakerGetsIssuer (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
DirectoryNodeBuilder&
setTakerGetsIssuer(std::decay_t<typename SF_UINT160::type::value_type> const& value)
{
object_[sfTakerGetsIssuer] = value;
return *this;
}
/**
* @brief Set sfExchangeRate (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
DirectoryNodeBuilder&
setExchangeRate(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfExchangeRate] = value;
return *this;
}
/**
* @brief Set sfIndexes (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
DirectoryNodeBuilder&
setIndexes(std::decay_t<typename SF_VECTOR256::type::value_type> const& value)
{
object_[sfIndexes] = value;
return *this;
}
/**
* @brief Set sfRootIndex (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
DirectoryNodeBuilder&
setRootIndex(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfRootIndex] = value;
return *this;
}
/**
* @brief Set sfIndexNext (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
DirectoryNodeBuilder&
setIndexNext(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfIndexNext] = value;
return *this;
}
/**
* @brief Set sfIndexPrevious (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
DirectoryNodeBuilder&
setIndexPrevious(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfIndexPrevious] = value;
return *this;
}
/**
* @brief Set sfNFTokenID (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
DirectoryNodeBuilder&
setNFTokenID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfNFTokenID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
DirectoryNodeBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
DirectoryNodeBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Set sfDomainID (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
DirectoryNodeBuilder&
setDomainID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfDomainID] = value;
return *this;
}
/**
* @brief Build and return the completed DirectoryNode wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
DirectoryNode
build(uint256 const& index)
{
return DirectoryNode{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

554
include/xrpl/protocol_autogen/ledger_entries/Escrow.h Normal file
View File

@@ -0,0 +1,554 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class EscrowBuilder;
/**
* @brief Ledger Entry: Escrow
*
* Type: ltESCROW (0x0075)
* RPC Name: escrow
*
* Immutable wrapper around SLE providing type-safe field access.
* Use EscrowBuilder to construct new ledger entries.
*/
class Escrow : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltESCROW;
/**
* @brief Construct a Escrow ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit Escrow(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for Escrow");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfAccount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getAccount() const
{
return this->sle_->at(sfAccount);
}
/**
* @brief Get sfSequence (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getSequence() const
{
if (hasSequence())
return this->sle_->at(sfSequence);
return std::nullopt;
}
/**
* @brief Check if sfSequence is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasSequence() const
{
return this->sle_->isFieldPresent(sfSequence);
}
/**
* @brief Get sfDestination (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getDestination() const
{
return this->sle_->at(sfDestination);
}
/**
* @brief Get sfAmount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_AMOUNT::type::value_type
getAmount() const
{
return this->sle_->at(sfAmount);
}
/**
* @brief Get sfCondition (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_VL::type::value_type>
getCondition() const
{
if (hasCondition())
return this->sle_->at(sfCondition);
return std::nullopt;
}
/**
* @brief Check if sfCondition is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasCondition() const
{
return this->sle_->isFieldPresent(sfCondition);
}
/**
* @brief Get sfCancelAfter (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getCancelAfter() const
{
if (hasCancelAfter())
return this->sle_->at(sfCancelAfter);
return std::nullopt;
}
/**
* @brief Check if sfCancelAfter is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasCancelAfter() const
{
return this->sle_->isFieldPresent(sfCancelAfter);
}
/**
* @brief Get sfFinishAfter (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getFinishAfter() const
{
if (hasFinishAfter())
return this->sle_->at(sfFinishAfter);
return std::nullopt;
}
/**
* @brief Check if sfFinishAfter is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasFinishAfter() const
{
return this->sle_->isFieldPresent(sfFinishAfter);
}
/**
* @brief Get sfSourceTag (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getSourceTag() const
{
if (hasSourceTag())
return this->sle_->at(sfSourceTag);
return std::nullopt;
}
/**
* @brief Check if sfSourceTag is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasSourceTag() const
{
return this->sle_->isFieldPresent(sfSourceTag);
}
/**
* @brief Get sfDestinationTag (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getDestinationTag() const
{
if (hasDestinationTag())
return this->sle_->at(sfDestinationTag);
return std::nullopt;
}
/**
* @brief Check if sfDestinationTag is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasDestinationTag() const
{
return this->sle_->isFieldPresent(sfDestinationTag);
}
/**
* @brief Get sfOwnerNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getOwnerNode() const
{
return this->sle_->at(sfOwnerNode);
}
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
/**
* @brief Get sfDestinationNode (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT64::type::value_type>
getDestinationNode() const
{
if (hasDestinationNode())
return this->sle_->at(sfDestinationNode);
return std::nullopt;
}
/**
* @brief Check if sfDestinationNode is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasDestinationNode() const
{
return this->sle_->isFieldPresent(sfDestinationNode);
}
/**
* @brief Get sfTransferRate (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getTransferRate() const
{
if (hasTransferRate())
return this->sle_->at(sfTransferRate);
return std::nullopt;
}
/**
* @brief Check if sfTransferRate is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasTransferRate() const
{
return this->sle_->isFieldPresent(sfTransferRate);
}
/**
* @brief Get sfIssuerNode (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT64::type::value_type>
getIssuerNode() const
{
if (hasIssuerNode())
return this->sle_->at(sfIssuerNode);
return std::nullopt;
}
/**
* @brief Check if sfIssuerNode is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasIssuerNode() const
{
return this->sle_->isFieldPresent(sfIssuerNode);
}
};
/**
* @brief Builder for Escrow ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class EscrowBuilder : public LedgerEntryBuilderBase<EscrowBuilder>
{
public:
/**
* @brief Construct a new EscrowBuilder with required fields.
* @param account The sfAccount field value.
* @param destination The sfDestination field value.
* @param amount The sfAmount field value.
* @param ownerNode The sfOwnerNode field value.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
*/
EscrowBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_ACCOUNT::type::value_type> const& destination,std::decay_t<typename SF_AMOUNT::type::value_type> const& amount,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
: LedgerEntryBuilderBase<EscrowBuilder>(ltESCROW)
{
setAccount(account);
setDestination(destination);
setAmount(amount);
setOwnerNode(ownerNode);
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
}
/**
* @brief Construct a EscrowBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
EscrowBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltESCROW)
{
throw std::runtime_error("Invalid ledger entry type for Escrow");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfAccount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
EscrowBuilder&
setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfAccount] = value;
return *this;
}
/**
* @brief Set sfSequence (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
EscrowBuilder&
setSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfSequence] = value;
return *this;
}
/**
* @brief Set sfDestination (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
EscrowBuilder&
setDestination(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfDestination] = value;
return *this;
}
/**
* @brief Set sfAmount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
EscrowBuilder&
setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfAmount] = value;
return *this;
}
/**
* @brief Set sfCondition (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
EscrowBuilder&
setCondition(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfCondition] = value;
return *this;
}
/**
* @brief Set sfCancelAfter (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
EscrowBuilder&
setCancelAfter(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfCancelAfter] = value;
return *this;
}
/**
* @brief Set sfFinishAfter (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
EscrowBuilder&
setFinishAfter(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfFinishAfter] = value;
return *this;
}
/**
* @brief Set sfSourceTag (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
EscrowBuilder&
setSourceTag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfSourceTag] = value;
return *this;
}
/**
* @brief Set sfDestinationTag (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
EscrowBuilder&
setDestinationTag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfDestinationTag] = value;
return *this;
}
/**
* @brief Set sfOwnerNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
EscrowBuilder&
setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfOwnerNode] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
EscrowBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
EscrowBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Set sfDestinationNode (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
EscrowBuilder&
setDestinationNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfDestinationNode] = value;
return *this;
}
/**
* @brief Set sfTransferRate (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
EscrowBuilder&
setTransferRate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfTransferRate] = value;
return *this;
}
/**
* @brief Set sfIssuerNode (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
EscrowBuilder&
setIssuerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfIssuerNode] = value;
return *this;
}
/**
* @brief Build and return the completed Escrow wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
Escrow
build(uint256 const& index)
{
return Escrow{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

410
include/xrpl/protocol_autogen/ledger_entries/FeeSettings.h Normal file
View File

@@ -0,0 +1,410 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class FeeSettingsBuilder;
/**
* @brief Ledger Entry: FeeSettings
*
* Type: ltFEE_SETTINGS (0x0073)
* RPC Name: fee
*
* Immutable wrapper around SLE providing type-safe field access.
* Use FeeSettingsBuilder to construct new ledger entries.
*/
class FeeSettings : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltFEE_SETTINGS;
/**
* @brief Construct a FeeSettings ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit FeeSettings(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for FeeSettings");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfBaseFee (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT64::type::value_type>
getBaseFee() const
{
if (hasBaseFee())
return this->sle_->at(sfBaseFee);
return std::nullopt;
}
/**
* @brief Check if sfBaseFee is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasBaseFee() const
{
return this->sle_->isFieldPresent(sfBaseFee);
}
/**
* @brief Get sfReferenceFeeUnits (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getReferenceFeeUnits() const
{
if (hasReferenceFeeUnits())
return this->sle_->at(sfReferenceFeeUnits);
return std::nullopt;
}
/**
* @brief Check if sfReferenceFeeUnits is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasReferenceFeeUnits() const
{
return this->sle_->isFieldPresent(sfReferenceFeeUnits);
}
/**
* @brief Get sfReserveBase (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getReserveBase() const
{
if (hasReserveBase())
return this->sle_->at(sfReserveBase);
return std::nullopt;
}
/**
* @brief Check if sfReserveBase is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasReserveBase() const
{
return this->sle_->isFieldPresent(sfReserveBase);
}
/**
* @brief Get sfReserveIncrement (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getReserveIncrement() const
{
if (hasReserveIncrement())
return this->sle_->at(sfReserveIncrement);
return std::nullopt;
}
/**
* @brief Check if sfReserveIncrement is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasReserveIncrement() const
{
return this->sle_->isFieldPresent(sfReserveIncrement);
}
/**
* @brief Get sfBaseFeeDrops (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_AMOUNT::type::value_type>
getBaseFeeDrops() const
{
if (hasBaseFeeDrops())
return this->sle_->at(sfBaseFeeDrops);
return std::nullopt;
}
/**
* @brief Check if sfBaseFeeDrops is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasBaseFeeDrops() const
{
return this->sle_->isFieldPresent(sfBaseFeeDrops);
}
/**
* @brief Get sfReserveBaseDrops (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_AMOUNT::type::value_type>
getReserveBaseDrops() const
{
if (hasReserveBaseDrops())
return this->sle_->at(sfReserveBaseDrops);
return std::nullopt;
}
/**
* @brief Check if sfReserveBaseDrops is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasReserveBaseDrops() const
{
return this->sle_->isFieldPresent(sfReserveBaseDrops);
}
/**
* @brief Get sfReserveIncrementDrops (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_AMOUNT::type::value_type>
getReserveIncrementDrops() const
{
if (hasReserveIncrementDrops())
return this->sle_->at(sfReserveIncrementDrops);
return std::nullopt;
}
/**
* @brief Check if sfReserveIncrementDrops is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasReserveIncrementDrops() const
{
return this->sle_->isFieldPresent(sfReserveIncrementDrops);
}
/**
* @brief Get sfPreviousTxnID (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT256::type::value_type>
getPreviousTxnID() const
{
if (hasPreviousTxnID())
return this->sle_->at(sfPreviousTxnID);
return std::nullopt;
}
/**
* @brief Check if sfPreviousTxnID is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasPreviousTxnID() const
{
return this->sle_->isFieldPresent(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getPreviousTxnLgrSeq() const
{
if (hasPreviousTxnLgrSeq())
return this->sle_->at(sfPreviousTxnLgrSeq);
return std::nullopt;
}
/**
* @brief Check if sfPreviousTxnLgrSeq is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasPreviousTxnLgrSeq() const
{
return this->sle_->isFieldPresent(sfPreviousTxnLgrSeq);
}
};
/**
* @brief Builder for FeeSettings ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class FeeSettingsBuilder : public LedgerEntryBuilderBase<FeeSettingsBuilder>
{
public:
/**
* @brief Construct a new FeeSettingsBuilder with required fields.
*/
FeeSettingsBuilder()
: LedgerEntryBuilderBase<FeeSettingsBuilder>(ltFEE_SETTINGS)
{
}
/**
* @brief Construct a FeeSettingsBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
FeeSettingsBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltFEE_SETTINGS)
{
throw std::runtime_error("Invalid ledger entry type for FeeSettings");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfBaseFee (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
FeeSettingsBuilder&
setBaseFee(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfBaseFee] = value;
return *this;
}
/**
* @brief Set sfReferenceFeeUnits (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
FeeSettingsBuilder&
setReferenceFeeUnits(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfReferenceFeeUnits] = value;
return *this;
}
/**
* @brief Set sfReserveBase (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
FeeSettingsBuilder&
setReserveBase(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfReserveBase] = value;
return *this;
}
/**
* @brief Set sfReserveIncrement (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
FeeSettingsBuilder&
setReserveIncrement(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfReserveIncrement] = value;
return *this;
}
/**
* @brief Set sfBaseFeeDrops (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
FeeSettingsBuilder&
setBaseFeeDrops(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfBaseFeeDrops] = value;
return *this;
}
/**
* @brief Set sfReserveBaseDrops (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
FeeSettingsBuilder&
setReserveBaseDrops(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfReserveBaseDrops] = value;
return *this;
}
/**
* @brief Set sfReserveIncrementDrops (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
FeeSettingsBuilder&
setReserveIncrementDrops(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfReserveIncrementDrops] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
FeeSettingsBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
FeeSettingsBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Build and return the completed FeeSettings wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
FeeSettings
build(uint256 const& index)
{
return FeeSettings{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

189
include/xrpl/protocol_autogen/ledger_entries/LedgerHashes.h Normal file
View File

@@ -0,0 +1,189 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class LedgerHashesBuilder;
/**
* @brief Ledger Entry: LedgerHashes
*
* Type: ltLEDGER_HASHES (0x0068)
* RPC Name: hashes
*
* Immutable wrapper around SLE providing type-safe field access.
* Use LedgerHashesBuilder to construct new ledger entries.
*/
class LedgerHashes : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltLEDGER_HASHES;
/**
* @brief Construct a LedgerHashes ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit LedgerHashes(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for LedgerHashes");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfFirstLedgerSequence (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getFirstLedgerSequence() const
{
if (hasFirstLedgerSequence())
return this->sle_->at(sfFirstLedgerSequence);
return std::nullopt;
}
/**
* @brief Check if sfFirstLedgerSequence is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasFirstLedgerSequence() const
{
return this->sle_->isFieldPresent(sfFirstLedgerSequence);
}
/**
* @brief Get sfLastLedgerSequence (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getLastLedgerSequence() const
{
if (hasLastLedgerSequence())
return this->sle_->at(sfLastLedgerSequence);
return std::nullopt;
}
/**
* @brief Check if sfLastLedgerSequence is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasLastLedgerSequence() const
{
return this->sle_->isFieldPresent(sfLastLedgerSequence);
}
/**
* @brief Get sfHashes (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_VECTOR256::type::value_type
getHashes() const
{
return this->sle_->at(sfHashes);
}
};
/**
* @brief Builder for LedgerHashes ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class LedgerHashesBuilder : public LedgerEntryBuilderBase<LedgerHashesBuilder>
{
public:
/**
* @brief Construct a new LedgerHashesBuilder with required fields.
* @param hashes The sfHashes field value.
*/
LedgerHashesBuilder(std::decay_t<typename SF_VECTOR256::type::value_type> const& hashes)
: LedgerEntryBuilderBase<LedgerHashesBuilder>(ltLEDGER_HASHES)
{
setHashes(hashes);
}
/**
* @brief Construct a LedgerHashesBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
LedgerHashesBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltLEDGER_HASHES)
{
throw std::runtime_error("Invalid ledger entry type for LedgerHashes");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfFirstLedgerSequence (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
LedgerHashesBuilder&
setFirstLedgerSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfFirstLedgerSequence] = value;
return *this;
}
/**
* @brief Set sfLastLedgerSequence (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
LedgerHashesBuilder&
setLastLedgerSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfLastLedgerSequence] = value;
return *this;
}
/**
* @brief Set sfHashes (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
LedgerHashesBuilder&
setHashes(std::decay_t<typename SF_VECTOR256::type::value_type> const& value)
{
object_[sfHashes] = value;
return *this;
}
/**
* @brief Build and return the completed LedgerHashes wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
LedgerHashes
build(uint256 const& index)
{
return LedgerHashes{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

930
include/xrpl/protocol_autogen/ledger_entries/Loan.h Normal file
View File

@@ -0,0 +1,930 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class LoanBuilder;
/**
* @brief Ledger Entry: Loan
*
* Type: ltLOAN (0x0089)
* RPC Name: loan
*
* Immutable wrapper around SLE providing type-safe field access.
* Use LoanBuilder to construct new ledger entries.
*/
class Loan : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltLOAN;
/**
* @brief Construct a Loan ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit Loan(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for Loan");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
/**
* @brief Get sfOwnerNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getOwnerNode() const
{
return this->sle_->at(sfOwnerNode);
}
/**
* @brief Get sfLoanBrokerNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getLoanBrokerNode() const
{
return this->sle_->at(sfLoanBrokerNode);
}
/**
* @brief Get sfLoanBrokerID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getLoanBrokerID() const
{
return this->sle_->at(sfLoanBrokerID);
}
/**
* @brief Get sfLoanSequence (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getLoanSequence() const
{
return this->sle_->at(sfLoanSequence);
}
/**
* @brief Get sfBorrower (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getBorrower() const
{
return this->sle_->at(sfBorrower);
}
/**
* @brief Get sfLoanOriginationFee (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_NUMBER::type::value_type>
getLoanOriginationFee() const
{
if (hasLoanOriginationFee())
return this->sle_->at(sfLoanOriginationFee);
return std::nullopt;
}
/**
* @brief Check if sfLoanOriginationFee is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasLoanOriginationFee() const
{
return this->sle_->isFieldPresent(sfLoanOriginationFee);
}
/**
* @brief Get sfLoanServiceFee (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_NUMBER::type::value_type>
getLoanServiceFee() const
{
if (hasLoanServiceFee())
return this->sle_->at(sfLoanServiceFee);
return std::nullopt;
}
/**
* @brief Check if sfLoanServiceFee is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasLoanServiceFee() const
{
return this->sle_->isFieldPresent(sfLoanServiceFee);
}
/**
* @brief Get sfLatePaymentFee (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_NUMBER::type::value_type>
getLatePaymentFee() const
{
if (hasLatePaymentFee())
return this->sle_->at(sfLatePaymentFee);
return std::nullopt;
}
/**
* @brief Check if sfLatePaymentFee is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasLatePaymentFee() const
{
return this->sle_->isFieldPresent(sfLatePaymentFee);
}
/**
* @brief Get sfClosePaymentFee (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_NUMBER::type::value_type>
getClosePaymentFee() const
{
if (hasClosePaymentFee())
return this->sle_->at(sfClosePaymentFee);
return std::nullopt;
}
/**
* @brief Check if sfClosePaymentFee is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasClosePaymentFee() const
{
return this->sle_->isFieldPresent(sfClosePaymentFee);
}
/**
* @brief Get sfOverpaymentFee (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getOverpaymentFee() const
{
if (hasOverpaymentFee())
return this->sle_->at(sfOverpaymentFee);
return std::nullopt;
}
/**
* @brief Check if sfOverpaymentFee is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasOverpaymentFee() const
{
return this->sle_->isFieldPresent(sfOverpaymentFee);
}
/**
* @brief Get sfInterestRate (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getInterestRate() const
{
if (hasInterestRate())
return this->sle_->at(sfInterestRate);
return std::nullopt;
}
/**
* @brief Check if sfInterestRate is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasInterestRate() const
{
return this->sle_->isFieldPresent(sfInterestRate);
}
/**
* @brief Get sfLateInterestRate (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getLateInterestRate() const
{
if (hasLateInterestRate())
return this->sle_->at(sfLateInterestRate);
return std::nullopt;
}
/**
* @brief Check if sfLateInterestRate is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasLateInterestRate() const
{
return this->sle_->isFieldPresent(sfLateInterestRate);
}
/**
* @brief Get sfCloseInterestRate (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getCloseInterestRate() const
{
if (hasCloseInterestRate())
return this->sle_->at(sfCloseInterestRate);
return std::nullopt;
}
/**
* @brief Check if sfCloseInterestRate is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasCloseInterestRate() const
{
return this->sle_->isFieldPresent(sfCloseInterestRate);
}
/**
* @brief Get sfOverpaymentInterestRate (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getOverpaymentInterestRate() const
{
if (hasOverpaymentInterestRate())
return this->sle_->at(sfOverpaymentInterestRate);
return std::nullopt;
}
/**
* @brief Check if sfOverpaymentInterestRate is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasOverpaymentInterestRate() const
{
return this->sle_->isFieldPresent(sfOverpaymentInterestRate);
}
/**
* @brief Get sfStartDate (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getStartDate() const
{
return this->sle_->at(sfStartDate);
}
/**
* @brief Get sfPaymentInterval (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPaymentInterval() const
{
return this->sle_->at(sfPaymentInterval);
}
/**
* @brief Get sfGracePeriod (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getGracePeriod() const
{
if (hasGracePeriod())
return this->sle_->at(sfGracePeriod);
return std::nullopt;
}
/**
* @brief Check if sfGracePeriod is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasGracePeriod() const
{
return this->sle_->isFieldPresent(sfGracePeriod);
}
/**
* @brief Get sfPreviousPaymentDueDate (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getPreviousPaymentDueDate() const
{
if (hasPreviousPaymentDueDate())
return this->sle_->at(sfPreviousPaymentDueDate);
return std::nullopt;
}
/**
* @brief Check if sfPreviousPaymentDueDate is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasPreviousPaymentDueDate() const
{
return this->sle_->isFieldPresent(sfPreviousPaymentDueDate);
}
/**
* @brief Get sfNextPaymentDueDate (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getNextPaymentDueDate() const
{
if (hasNextPaymentDueDate())
return this->sle_->at(sfNextPaymentDueDate);
return std::nullopt;
}
/**
* @brief Check if sfNextPaymentDueDate is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasNextPaymentDueDate() const
{
return this->sle_->isFieldPresent(sfNextPaymentDueDate);
}
/**
* @brief Get sfPaymentRemaining (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getPaymentRemaining() const
{
if (hasPaymentRemaining())
return this->sle_->at(sfPaymentRemaining);
return std::nullopt;
}
/**
* @brief Check if sfPaymentRemaining is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasPaymentRemaining() const
{
return this->sle_->isFieldPresent(sfPaymentRemaining);
}
/**
* @brief Get sfPeriodicPayment (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_NUMBER::type::value_type
getPeriodicPayment() const
{
return this->sle_->at(sfPeriodicPayment);
}
/**
* @brief Get sfPrincipalOutstanding (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_NUMBER::type::value_type>
getPrincipalOutstanding() const
{
if (hasPrincipalOutstanding())
return this->sle_->at(sfPrincipalOutstanding);
return std::nullopt;
}
/**
* @brief Check if sfPrincipalOutstanding is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasPrincipalOutstanding() const
{
return this->sle_->isFieldPresent(sfPrincipalOutstanding);
}
/**
* @brief Get sfTotalValueOutstanding (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_NUMBER::type::value_type>
getTotalValueOutstanding() const
{
if (hasTotalValueOutstanding())
return this->sle_->at(sfTotalValueOutstanding);
return std::nullopt;
}
/**
* @brief Check if sfTotalValueOutstanding is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasTotalValueOutstanding() const
{
return this->sle_->isFieldPresent(sfTotalValueOutstanding);
}
/**
* @brief Get sfManagementFeeOutstanding (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_NUMBER::type::value_type>
getManagementFeeOutstanding() const
{
if (hasManagementFeeOutstanding())
return this->sle_->at(sfManagementFeeOutstanding);
return std::nullopt;
}
/**
* @brief Check if sfManagementFeeOutstanding is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasManagementFeeOutstanding() const
{
return this->sle_->isFieldPresent(sfManagementFeeOutstanding);
}
/**
* @brief Get sfLoanScale (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_INT32::type::value_type>
getLoanScale() const
{
if (hasLoanScale())
return this->sle_->at(sfLoanScale);
return std::nullopt;
}
/**
* @brief Check if sfLoanScale is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasLoanScale() const
{
return this->sle_->isFieldPresent(sfLoanScale);
}
};
/**
* @brief Builder for Loan ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class LoanBuilder : public LedgerEntryBuilderBase<LoanBuilder>
{
public:
/**
* @brief Construct a new LoanBuilder with required fields.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
* @param ownerNode The sfOwnerNode field value.
* @param loanBrokerNode The sfLoanBrokerNode field value.
* @param loanBrokerID The sfLoanBrokerID field value.
* @param loanSequence The sfLoanSequence field value.
* @param borrower The sfBorrower field value.
* @param startDate The sfStartDate field value.
* @param paymentInterval The sfPaymentInterval field value.
* @param periodicPayment The sfPeriodicPayment field value.
*/
LoanBuilder(std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT64::type::value_type> const& loanBrokerNode,std::decay_t<typename SF_UINT256::type::value_type> const& loanBrokerID,std::decay_t<typename SF_UINT32::type::value_type> const& loanSequence,std::decay_t<typename SF_ACCOUNT::type::value_type> const& borrower,std::decay_t<typename SF_UINT32::type::value_type> const& startDate,std::decay_t<typename SF_UINT32::type::value_type> const& paymentInterval,std::decay_t<typename SF_NUMBER::type::value_type> const& periodicPayment)
: LedgerEntryBuilderBase<LoanBuilder>(ltLOAN)
{
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
setOwnerNode(ownerNode);
setLoanBrokerNode(loanBrokerNode);
setLoanBrokerID(loanBrokerID);
setLoanSequence(loanSequence);
setBorrower(borrower);
setStartDate(startDate);
setPaymentInterval(paymentInterval);
setPeriodicPayment(periodicPayment);
}
/**
* @brief Construct a LoanBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
LoanBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltLOAN)
{
throw std::runtime_error("Invalid ledger entry type for Loan");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Set sfOwnerNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfOwnerNode] = value;
return *this;
}
/**
* @brief Set sfLoanBrokerNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setLoanBrokerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfLoanBrokerNode] = value;
return *this;
}
/**
* @brief Set sfLoanBrokerID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setLoanBrokerID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfLoanBrokerID] = value;
return *this;
}
/**
* @brief Set sfLoanSequence (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setLoanSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfLoanSequence] = value;
return *this;
}
/**
* @brief Set sfBorrower (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setBorrower(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfBorrower] = value;
return *this;
}
/**
* @brief Set sfLoanOriginationFee (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setLoanOriginationFee(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
{
object_[sfLoanOriginationFee] = value;
return *this;
}
/**
* @brief Set sfLoanServiceFee (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setLoanServiceFee(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
{
object_[sfLoanServiceFee] = value;
return *this;
}
/**
* @brief Set sfLatePaymentFee (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setLatePaymentFee(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
{
object_[sfLatePaymentFee] = value;
return *this;
}
/**
* @brief Set sfClosePaymentFee (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setClosePaymentFee(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
{
object_[sfClosePaymentFee] = value;
return *this;
}
/**
* @brief Set sfOverpaymentFee (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setOverpaymentFee(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfOverpaymentFee] = value;
return *this;
}
/**
* @brief Set sfInterestRate (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setInterestRate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfInterestRate] = value;
return *this;
}
/**
* @brief Set sfLateInterestRate (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setLateInterestRate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfLateInterestRate] = value;
return *this;
}
/**
* @brief Set sfCloseInterestRate (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setCloseInterestRate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfCloseInterestRate] = value;
return *this;
}
/**
* @brief Set sfOverpaymentInterestRate (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setOverpaymentInterestRate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfOverpaymentInterestRate] = value;
return *this;
}
/**
* @brief Set sfStartDate (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setStartDate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfStartDate] = value;
return *this;
}
/**
* @brief Set sfPaymentInterval (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setPaymentInterval(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPaymentInterval] = value;
return *this;
}
/**
* @brief Set sfGracePeriod (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setGracePeriod(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfGracePeriod] = value;
return *this;
}
/**
* @brief Set sfPreviousPaymentDueDate (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setPreviousPaymentDueDate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousPaymentDueDate] = value;
return *this;
}
/**
* @brief Set sfNextPaymentDueDate (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setNextPaymentDueDate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfNextPaymentDueDate] = value;
return *this;
}
/**
* @brief Set sfPaymentRemaining (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setPaymentRemaining(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPaymentRemaining] = value;
return *this;
}
/**
* @brief Set sfPeriodicPayment (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setPeriodicPayment(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
{
object_[sfPeriodicPayment] = value;
return *this;
}
/**
* @brief Set sfPrincipalOutstanding (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setPrincipalOutstanding(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
{
object_[sfPrincipalOutstanding] = value;
return *this;
}
/**
* @brief Set sfTotalValueOutstanding (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setTotalValueOutstanding(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
{
object_[sfTotalValueOutstanding] = value;
return *this;
}
/**
* @brief Set sfManagementFeeOutstanding (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setManagementFeeOutstanding(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
{
object_[sfManagementFeeOutstanding] = value;
return *this;
}
/**
* @brief Set sfLoanScale (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBuilder&
setLoanScale(std::decay_t<typename SF_INT32::type::value_type> const& value)
{
object_[sfLoanScale] = value;
return *this;
}
/**
* @brief Build and return the completed Loan wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
Loan
build(uint256 const& index)
{
return Loan{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

591
include/xrpl/protocol_autogen/ledger_entries/LoanBroker.h Normal file
View File

@@ -0,0 +1,591 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class LoanBrokerBuilder;
/**
* @brief Ledger Entry: LoanBroker
*
* Type: ltLOAN_BROKER (0x0088)
* RPC Name: loan_broker
*
* Immutable wrapper around SLE providing type-safe field access.
* Use LoanBrokerBuilder to construct new ledger entries.
*/
class LoanBroker : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltLOAN_BROKER;
/**
* @brief Construct a LoanBroker ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit LoanBroker(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for LoanBroker");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
/**
* @brief Get sfSequence (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getSequence() const
{
return this->sle_->at(sfSequence);
}
/**
* @brief Get sfOwnerNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getOwnerNode() const
{
return this->sle_->at(sfOwnerNode);
}
/**
* @brief Get sfVaultNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getVaultNode() const
{
return this->sle_->at(sfVaultNode);
}
/**
* @brief Get sfVaultID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getVaultID() const
{
return this->sle_->at(sfVaultID);
}
/**
* @brief Get sfAccount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getAccount() const
{
return this->sle_->at(sfAccount);
}
/**
* @brief Get sfOwner (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getOwner() const
{
return this->sle_->at(sfOwner);
}
/**
* @brief Get sfLoanSequence (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getLoanSequence() const
{
return this->sle_->at(sfLoanSequence);
}
/**
* @brief Get sfData (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_VL::type::value_type>
getData() const
{
if (hasData())
return this->sle_->at(sfData);
return std::nullopt;
}
/**
* @brief Check if sfData is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasData() const
{
return this->sle_->isFieldPresent(sfData);
}
/**
* @brief Get sfManagementFeeRate (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT16::type::value_type>
getManagementFeeRate() const
{
if (hasManagementFeeRate())
return this->sle_->at(sfManagementFeeRate);
return std::nullopt;
}
/**
* @brief Check if sfManagementFeeRate is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasManagementFeeRate() const
{
return this->sle_->isFieldPresent(sfManagementFeeRate);
}
/**
* @brief Get sfOwnerCount (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getOwnerCount() const
{
if (hasOwnerCount())
return this->sle_->at(sfOwnerCount);
return std::nullopt;
}
/**
* @brief Check if sfOwnerCount is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasOwnerCount() const
{
return this->sle_->isFieldPresent(sfOwnerCount);
}
/**
* @brief Get sfDebtTotal (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_NUMBER::type::value_type>
getDebtTotal() const
{
if (hasDebtTotal())
return this->sle_->at(sfDebtTotal);
return std::nullopt;
}
/**
* @brief Check if sfDebtTotal is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasDebtTotal() const
{
return this->sle_->isFieldPresent(sfDebtTotal);
}
/**
* @brief Get sfDebtMaximum (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_NUMBER::type::value_type>
getDebtMaximum() const
{
if (hasDebtMaximum())
return this->sle_->at(sfDebtMaximum);
return std::nullopt;
}
/**
* @brief Check if sfDebtMaximum is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasDebtMaximum() const
{
return this->sle_->isFieldPresent(sfDebtMaximum);
}
/**
* @brief Get sfCoverAvailable (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_NUMBER::type::value_type>
getCoverAvailable() const
{
if (hasCoverAvailable())
return this->sle_->at(sfCoverAvailable);
return std::nullopt;
}
/**
* @brief Check if sfCoverAvailable is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasCoverAvailable() const
{
return this->sle_->isFieldPresent(sfCoverAvailable);
}
/**
* @brief Get sfCoverRateMinimum (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getCoverRateMinimum() const
{
if (hasCoverRateMinimum())
return this->sle_->at(sfCoverRateMinimum);
return std::nullopt;
}
/**
* @brief Check if sfCoverRateMinimum is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasCoverRateMinimum() const
{
return this->sle_->isFieldPresent(sfCoverRateMinimum);
}
/**
* @brief Get sfCoverRateLiquidation (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getCoverRateLiquidation() const
{
if (hasCoverRateLiquidation())
return this->sle_->at(sfCoverRateLiquidation);
return std::nullopt;
}
/**
* @brief Check if sfCoverRateLiquidation is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasCoverRateLiquidation() const
{
return this->sle_->isFieldPresent(sfCoverRateLiquidation);
}
};
/**
* @brief Builder for LoanBroker ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class LoanBrokerBuilder : public LedgerEntryBuilderBase<LoanBrokerBuilder>
{
public:
/**
* @brief Construct a new LoanBrokerBuilder with required fields.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
* @param sequence The sfSequence field value.
* @param ownerNode The sfOwnerNode field value.
* @param vaultNode The sfVaultNode field value.
* @param vaultID The sfVaultID field value.
* @param account The sfAccount field value.
* @param owner The sfOwner field value.
* @param loanSequence The sfLoanSequence field value.
*/
LoanBrokerBuilder(std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq,std::decay_t<typename SF_UINT32::type::value_type> const& sequence,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT64::type::value_type> const& vaultNode,std::decay_t<typename SF_UINT256::type::value_type> const& vaultID,std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_ACCOUNT::type::value_type> const& owner,std::decay_t<typename SF_UINT32::type::value_type> const& loanSequence)
: LedgerEntryBuilderBase<LoanBrokerBuilder>(ltLOAN_BROKER)
{
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
setSequence(sequence);
setOwnerNode(ownerNode);
setVaultNode(vaultNode);
setVaultID(vaultID);
setAccount(account);
setOwner(owner);
setLoanSequence(loanSequence);
}
/**
* @brief Construct a LoanBrokerBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
LoanBrokerBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltLOAN_BROKER)
{
throw std::runtime_error("Invalid ledger entry type for LoanBroker");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
LoanBrokerBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
LoanBrokerBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Set sfSequence (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
LoanBrokerBuilder&
setSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfSequence] = value;
return *this;
}
/**
* @brief Set sfOwnerNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
LoanBrokerBuilder&
setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfOwnerNode] = value;
return *this;
}
/**
* @brief Set sfVaultNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
LoanBrokerBuilder&
setVaultNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfVaultNode] = value;
return *this;
}
/**
* @brief Set sfVaultID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
LoanBrokerBuilder&
setVaultID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfVaultID] = value;
return *this;
}
/**
* @brief Set sfAccount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
LoanBrokerBuilder&
setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfAccount] = value;
return *this;
}
/**
* @brief Set sfOwner (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
LoanBrokerBuilder&
setOwner(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfOwner] = value;
return *this;
}
/**
* @brief Set sfLoanSequence (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
LoanBrokerBuilder&
setLoanSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfLoanSequence] = value;
return *this;
}
/**
* @brief Set sfData (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBrokerBuilder&
setData(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfData] = value;
return *this;
}
/**
* @brief Set sfManagementFeeRate (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBrokerBuilder&
setManagementFeeRate(std::decay_t<typename SF_UINT16::type::value_type> const& value)
{
object_[sfManagementFeeRate] = value;
return *this;
}
/**
* @brief Set sfOwnerCount (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBrokerBuilder&
setOwnerCount(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfOwnerCount] = value;
return *this;
}
/**
* @brief Set sfDebtTotal (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBrokerBuilder&
setDebtTotal(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
{
object_[sfDebtTotal] = value;
return *this;
}
/**
* @brief Set sfDebtMaximum (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBrokerBuilder&
setDebtMaximum(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
{
object_[sfDebtMaximum] = value;
return *this;
}
/**
* @brief Set sfCoverAvailable (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBrokerBuilder&
setCoverAvailable(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
{
object_[sfCoverAvailable] = value;
return *this;
}
/**
* @brief Set sfCoverRateMinimum (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBrokerBuilder&
setCoverRateMinimum(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfCoverRateMinimum] = value;
return *this;
}
/**
* @brief Set sfCoverRateLiquidation (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
LoanBrokerBuilder&
setCoverRateLiquidation(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfCoverRateLiquidation] = value;
return *this;
}
/**
* @brief Build and return the completed LoanBroker wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
LoanBroker
build(uint256 const& index)
{
return LoanBroker{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

285
include/xrpl/protocol_autogen/ledger_entries/MPToken.h Normal file
View File

@@ -0,0 +1,285 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class MPTokenBuilder;
/**
* @brief Ledger Entry: MPToken
*
* Type: ltMPTOKEN (0x007f)
* RPC Name: mptoken
*
* Immutable wrapper around SLE providing type-safe field access.
* Use MPTokenBuilder to construct new ledger entries.
*/
class MPToken : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltMPTOKEN;
/**
* @brief Construct a MPToken ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit MPToken(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for MPToken");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfAccount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getAccount() const
{
return this->sle_->at(sfAccount);
}
/**
* @brief Get sfMPTokenIssuanceID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT192::type::value_type
getMPTokenIssuanceID() const
{
return this->sle_->at(sfMPTokenIssuanceID);
}
/**
* @brief Get sfMPTAmount (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT64::type::value_type>
getMPTAmount() const
{
if (hasMPTAmount())
return this->sle_->at(sfMPTAmount);
return std::nullopt;
}
/**
* @brief Check if sfMPTAmount is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasMPTAmount() const
{
return this->sle_->isFieldPresent(sfMPTAmount);
}
/**
* @brief Get sfLockedAmount (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT64::type::value_type>
getLockedAmount() const
{
if (hasLockedAmount())
return this->sle_->at(sfLockedAmount);
return std::nullopt;
}
/**
* @brief Check if sfLockedAmount is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasLockedAmount() const
{
return this->sle_->isFieldPresent(sfLockedAmount);
}
/**
* @brief Get sfOwnerNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getOwnerNode() const
{
return this->sle_->at(sfOwnerNode);
}
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
};
/**
* @brief Builder for MPToken ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class MPTokenBuilder : public LedgerEntryBuilderBase<MPTokenBuilder>
{
public:
/**
* @brief Construct a new MPTokenBuilder with required fields.
* @param account The sfAccount field value.
* @param mPTokenIssuanceID The sfMPTokenIssuanceID field value.
* @param ownerNode The sfOwnerNode field value.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
*/
MPTokenBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_UINT192::type::value_type> const& mPTokenIssuanceID,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
: LedgerEntryBuilderBase<MPTokenBuilder>(ltMPTOKEN)
{
setAccount(account);
setMPTokenIssuanceID(mPTokenIssuanceID);
setOwnerNode(ownerNode);
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
}
/**
* @brief Construct a MPTokenBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
MPTokenBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltMPTOKEN)
{
throw std::runtime_error("Invalid ledger entry type for MPToken");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfAccount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
MPTokenBuilder&
setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfAccount] = value;
return *this;
}
/**
* @brief Set sfMPTokenIssuanceID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
MPTokenBuilder&
setMPTokenIssuanceID(std::decay_t<typename SF_UINT192::type::value_type> const& value)
{
object_[sfMPTokenIssuanceID] = value;
return *this;
}
/**
* @brief Set sfMPTAmount (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
MPTokenBuilder&
setMPTAmount(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfMPTAmount] = value;
return *this;
}
/**
* @brief Set sfLockedAmount (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
MPTokenBuilder&
setLockedAmount(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfLockedAmount] = value;
return *this;
}
/**
* @brief Set sfOwnerNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
MPTokenBuilder&
setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfOwnerNode] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
MPTokenBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
MPTokenBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Build and return the completed MPToken wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
MPToken
build(uint256 const& index)
{
return MPToken{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

484
include/xrpl/protocol_autogen/ledger_entries/MPTokenIssuance.h Normal file
View File

@@ -0,0 +1,484 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class MPTokenIssuanceBuilder;
/**
* @brief Ledger Entry: MPTokenIssuance
*
* Type: ltMPTOKEN_ISSUANCE (0x007e)
* RPC Name: mpt_issuance
*
* Immutable wrapper around SLE providing type-safe field access.
* Use MPTokenIssuanceBuilder to construct new ledger entries.
*/
class MPTokenIssuance : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltMPTOKEN_ISSUANCE;
/**
* @brief Construct a MPTokenIssuance ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit MPTokenIssuance(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for MPTokenIssuance");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfIssuer (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getIssuer() const
{
return this->sle_->at(sfIssuer);
}
/**
* @brief Get sfSequence (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getSequence() const
{
return this->sle_->at(sfSequence);
}
/**
* @brief Get sfTransferFee (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT16::type::value_type>
getTransferFee() const
{
if (hasTransferFee())
return this->sle_->at(sfTransferFee);
return std::nullopt;
}
/**
* @brief Check if sfTransferFee is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasTransferFee() const
{
return this->sle_->isFieldPresent(sfTransferFee);
}
/**
* @brief Get sfOwnerNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getOwnerNode() const
{
return this->sle_->at(sfOwnerNode);
}
/**
* @brief Get sfAssetScale (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT8::type::value_type>
getAssetScale() const
{
if (hasAssetScale())
return this->sle_->at(sfAssetScale);
return std::nullopt;
}
/**
* @brief Check if sfAssetScale is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasAssetScale() const
{
return this->sle_->isFieldPresent(sfAssetScale);
}
/**
* @brief Get sfMaximumAmount (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT64::type::value_type>
getMaximumAmount() const
{
if (hasMaximumAmount())
return this->sle_->at(sfMaximumAmount);
return std::nullopt;
}
/**
* @brief Check if sfMaximumAmount is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasMaximumAmount() const
{
return this->sle_->isFieldPresent(sfMaximumAmount);
}
/**
* @brief Get sfOutstandingAmount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getOutstandingAmount() const
{
return this->sle_->at(sfOutstandingAmount);
}
/**
* @brief Get sfLockedAmount (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT64::type::value_type>
getLockedAmount() const
{
if (hasLockedAmount())
return this->sle_->at(sfLockedAmount);
return std::nullopt;
}
/**
* @brief Check if sfLockedAmount is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasLockedAmount() const
{
return this->sle_->isFieldPresent(sfLockedAmount);
}
/**
* @brief Get sfMPTokenMetadata (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_VL::type::value_type>
getMPTokenMetadata() const
{
if (hasMPTokenMetadata())
return this->sle_->at(sfMPTokenMetadata);
return std::nullopt;
}
/**
* @brief Check if sfMPTokenMetadata is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasMPTokenMetadata() const
{
return this->sle_->isFieldPresent(sfMPTokenMetadata);
}
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
/**
* @brief Get sfDomainID (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT256::type::value_type>
getDomainID() const
{
if (hasDomainID())
return this->sle_->at(sfDomainID);
return std::nullopt;
}
/**
* @brief Check if sfDomainID is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasDomainID() const
{
return this->sle_->isFieldPresent(sfDomainID);
}
/**
* @brief Get sfMutableFlags (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getMutableFlags() const
{
if (hasMutableFlags())
return this->sle_->at(sfMutableFlags);
return std::nullopt;
}
/**
* @brief Check if sfMutableFlags is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasMutableFlags() const
{
return this->sle_->isFieldPresent(sfMutableFlags);
}
};
/**
* @brief Builder for MPTokenIssuance ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class MPTokenIssuanceBuilder : public LedgerEntryBuilderBase<MPTokenIssuanceBuilder>
{
public:
/**
* @brief Construct a new MPTokenIssuanceBuilder with required fields.
* @param issuer The sfIssuer field value.
* @param sequence The sfSequence field value.
* @param ownerNode The sfOwnerNode field value.
* @param outstandingAmount The sfOutstandingAmount field value.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
*/
MPTokenIssuanceBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& issuer,std::decay_t<typename SF_UINT32::type::value_type> const& sequence,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT64::type::value_type> const& outstandingAmount,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
: LedgerEntryBuilderBase<MPTokenIssuanceBuilder>(ltMPTOKEN_ISSUANCE)
{
setIssuer(issuer);
setSequence(sequence);
setOwnerNode(ownerNode);
setOutstandingAmount(outstandingAmount);
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
}
/**
* @brief Construct a MPTokenIssuanceBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
MPTokenIssuanceBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltMPTOKEN_ISSUANCE)
{
throw std::runtime_error("Invalid ledger entry type for MPTokenIssuance");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfIssuer (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
MPTokenIssuanceBuilder&
setIssuer(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfIssuer] = value;
return *this;
}
/**
* @brief Set sfSequence (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
MPTokenIssuanceBuilder&
setSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfSequence] = value;
return *this;
}
/**
* @brief Set sfTransferFee (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
MPTokenIssuanceBuilder&
setTransferFee(std::decay_t<typename SF_UINT16::type::value_type> const& value)
{
object_[sfTransferFee] = value;
return *this;
}
/**
* @brief Set sfOwnerNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
MPTokenIssuanceBuilder&
setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfOwnerNode] = value;
return *this;
}
/**
* @brief Set sfAssetScale (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
MPTokenIssuanceBuilder&
setAssetScale(std::decay_t<typename SF_UINT8::type::value_type> const& value)
{
object_[sfAssetScale] = value;
return *this;
}
/**
* @brief Set sfMaximumAmount (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
MPTokenIssuanceBuilder&
setMaximumAmount(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfMaximumAmount] = value;
return *this;
}
/**
* @brief Set sfOutstandingAmount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
MPTokenIssuanceBuilder&
setOutstandingAmount(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfOutstandingAmount] = value;
return *this;
}
/**
* @brief Set sfLockedAmount (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
MPTokenIssuanceBuilder&
setLockedAmount(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfLockedAmount] = value;
return *this;
}
/**
* @brief Set sfMPTokenMetadata (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
MPTokenIssuanceBuilder&
setMPTokenMetadata(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfMPTokenMetadata] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
MPTokenIssuanceBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
MPTokenIssuanceBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Set sfDomainID (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
MPTokenIssuanceBuilder&
setDomainID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfDomainID] = value;
return *this;
}
/**
* @brief Set sfMutableFlags (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
MPTokenIssuanceBuilder&
setMutableFlags(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfMutableFlags] = value;
return *this;
}
/**
* @brief Build and return the completed MPTokenIssuance wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
MPTokenIssuance
build(uint256 const& index)
{
return MPTokenIssuance{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

333
include/xrpl/protocol_autogen/ledger_entries/NFTokenOffer.h Normal file
View File

@@ -0,0 +1,333 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class NFTokenOfferBuilder;
/**
* @brief Ledger Entry: NFTokenOffer
*
* Type: ltNFTOKEN_OFFER (0x0037)
* RPC Name: nft_offer
*
* Immutable wrapper around SLE providing type-safe field access.
* Use NFTokenOfferBuilder to construct new ledger entries.
*/
class NFTokenOffer : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltNFTOKEN_OFFER;
/**
* @brief Construct a NFTokenOffer ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit NFTokenOffer(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for NFTokenOffer");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfOwner (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getOwner() const
{
return this->sle_->at(sfOwner);
}
/**
* @brief Get sfNFTokenID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getNFTokenID() const
{
return this->sle_->at(sfNFTokenID);
}
/**
* @brief Get sfAmount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_AMOUNT::type::value_type
getAmount() const
{
return this->sle_->at(sfAmount);
}
/**
* @brief Get sfOwnerNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getOwnerNode() const
{
return this->sle_->at(sfOwnerNode);
}
/**
* @brief Get sfNFTokenOfferNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getNFTokenOfferNode() const
{
return this->sle_->at(sfNFTokenOfferNode);
}
/**
* @brief Get sfDestination (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
getDestination() const
{
if (hasDestination())
return this->sle_->at(sfDestination);
return std::nullopt;
}
/**
* @brief Check if sfDestination is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasDestination() const
{
return this->sle_->isFieldPresent(sfDestination);
}
/**
* @brief Get sfExpiration (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getExpiration() const
{
if (hasExpiration())
return this->sle_->at(sfExpiration);
return std::nullopt;
}
/**
* @brief Check if sfExpiration is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasExpiration() const
{
return this->sle_->isFieldPresent(sfExpiration);
}
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
};
/**
* @brief Builder for NFTokenOffer ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class NFTokenOfferBuilder : public LedgerEntryBuilderBase<NFTokenOfferBuilder>
{
public:
/**
* @brief Construct a new NFTokenOfferBuilder with required fields.
* @param owner The sfOwner field value.
* @param nFTokenID The sfNFTokenID field value.
* @param amount The sfAmount field value.
* @param ownerNode The sfOwnerNode field value.
* @param nFTokenOfferNode The sfNFTokenOfferNode field value.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
*/
NFTokenOfferBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& owner,std::decay_t<typename SF_UINT256::type::value_type> const& nFTokenID,std::decay_t<typename SF_AMOUNT::type::value_type> const& amount,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT64::type::value_type> const& nFTokenOfferNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
: LedgerEntryBuilderBase<NFTokenOfferBuilder>(ltNFTOKEN_OFFER)
{
setOwner(owner);
setNFTokenID(nFTokenID);
setAmount(amount);
setOwnerNode(ownerNode);
setNFTokenOfferNode(nFTokenOfferNode);
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
}
/**
* @brief Construct a NFTokenOfferBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
NFTokenOfferBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltNFTOKEN_OFFER)
{
throw std::runtime_error("Invalid ledger entry type for NFTokenOffer");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfOwner (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
NFTokenOfferBuilder&
setOwner(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfOwner] = value;
return *this;
}
/**
* @brief Set sfNFTokenID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
NFTokenOfferBuilder&
setNFTokenID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfNFTokenID] = value;
return *this;
}
/**
* @brief Set sfAmount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
NFTokenOfferBuilder&
setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfAmount] = value;
return *this;
}
/**
* @brief Set sfOwnerNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
NFTokenOfferBuilder&
setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfOwnerNode] = value;
return *this;
}
/**
* @brief Set sfNFTokenOfferNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
NFTokenOfferBuilder&
setNFTokenOfferNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfNFTokenOfferNode] = value;
return *this;
}
/**
* @brief Set sfDestination (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
NFTokenOfferBuilder&
setDestination(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfDestination] = value;
return *this;
}
/**
* @brief Set sfExpiration (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
NFTokenOfferBuilder&
setExpiration(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfExpiration] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
NFTokenOfferBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
NFTokenOfferBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Build and return the completed NFTokenOffer wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
NFTokenOffer
build(uint256 const& index)
{
return NFTokenOffer{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

238
include/xrpl/protocol_autogen/ledger_entries/NFTokenPage.h Normal file
View File

@@ -0,0 +1,238 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class NFTokenPageBuilder;
/**
* @brief Ledger Entry: NFTokenPage
*
* Type: ltNFTOKEN_PAGE (0x0050)
* RPC Name: nft_page
*
* Immutable wrapper around SLE providing type-safe field access.
* Use NFTokenPageBuilder to construct new ledger entries.
*/
class NFTokenPage : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltNFTOKEN_PAGE;
/**
* @brief Construct a NFTokenPage ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit NFTokenPage(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for NFTokenPage");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfPreviousPageMin (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT256::type::value_type>
getPreviousPageMin() const
{
if (hasPreviousPageMin())
return this->sle_->at(sfPreviousPageMin);
return std::nullopt;
}
/**
* @brief Check if sfPreviousPageMin is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasPreviousPageMin() const
{
return this->sle_->isFieldPresent(sfPreviousPageMin);
}
/**
* @brief Get sfNextPageMin (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT256::type::value_type>
getNextPageMin() const
{
if (hasNextPageMin())
return this->sle_->at(sfNextPageMin);
return std::nullopt;
}
/**
* @brief Check if sfNextPageMin is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasNextPageMin() const
{
return this->sle_->isFieldPresent(sfNextPageMin);
}
/**
* @brief Get sfNFTokens (soeREQUIRED)
* @note This is an untyped field (unknown).
* @return The field value.
*/
[[nodiscard]]
STArray const&
getNFTokens() const
{
return this->sle_->getFieldArray(sfNFTokens);
}
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
};
/**
* @brief Builder for NFTokenPage ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class NFTokenPageBuilder : public LedgerEntryBuilderBase<NFTokenPageBuilder>
{
public:
/**
* @brief Construct a new NFTokenPageBuilder with required fields.
* @param nFTokens The sfNFTokens field value.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
*/
NFTokenPageBuilder(STArray const& nFTokens,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
: LedgerEntryBuilderBase<NFTokenPageBuilder>(ltNFTOKEN_PAGE)
{
setNFTokens(nFTokens);
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
}
/**
* @brief Construct a NFTokenPageBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
NFTokenPageBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltNFTOKEN_PAGE)
{
throw std::runtime_error("Invalid ledger entry type for NFTokenPage");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfPreviousPageMin (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
NFTokenPageBuilder&
setPreviousPageMin(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousPageMin] = value;
return *this;
}
/**
* @brief Set sfNextPageMin (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
NFTokenPageBuilder&
setNextPageMin(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfNextPageMin] = value;
return *this;
}
/**
* @brief Set sfNFTokens (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
NFTokenPageBuilder&
setNFTokens(STArray const& value)
{
object_.setFieldArray(sfNFTokens, value);
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
NFTokenPageBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
NFTokenPageBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Build and return the completed NFTokenPage wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
NFTokenPage
build(uint256 const& index)
{
return NFTokenPage{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

271
include/xrpl/protocol_autogen/ledger_entries/NegativeUNL.h Normal file
View File

@@ -0,0 +1,271 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class NegativeUNLBuilder;
/**
* @brief Ledger Entry: NegativeUNL
*
* Type: ltNEGATIVE_UNL (0x004e)
* RPC Name: nunl
*
* Immutable wrapper around SLE providing type-safe field access.
* Use NegativeUNLBuilder to construct new ledger entries.
*/
class NegativeUNL : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltNEGATIVE_UNL;
/**
* @brief Construct a NegativeUNL ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit NegativeUNL(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for NegativeUNL");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfDisabledValidators (soeOPTIONAL)
* @note This is an untyped field (unknown).
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
std::optional<std::reference_wrapper<STArray const>>
getDisabledValidators() const
{
if (this->sle_->isFieldPresent(sfDisabledValidators))
return this->sle_->getFieldArray(sfDisabledValidators);
return std::nullopt;
}
/**
* @brief Check if sfDisabledValidators is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasDisabledValidators() const
{
return this->sle_->isFieldPresent(sfDisabledValidators);
}
/**
* @brief Get sfValidatorToDisable (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_VL::type::value_type>
getValidatorToDisable() const
{
if (hasValidatorToDisable())
return this->sle_->at(sfValidatorToDisable);
return std::nullopt;
}
/**
* @brief Check if sfValidatorToDisable is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasValidatorToDisable() const
{
return this->sle_->isFieldPresent(sfValidatorToDisable);
}
/**
* @brief Get sfValidatorToReEnable (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_VL::type::value_type>
getValidatorToReEnable() const
{
if (hasValidatorToReEnable())
return this->sle_->at(sfValidatorToReEnable);
return std::nullopt;
}
/**
* @brief Check if sfValidatorToReEnable is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasValidatorToReEnable() const
{
return this->sle_->isFieldPresent(sfValidatorToReEnable);
}
/**
* @brief Get sfPreviousTxnID (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT256::type::value_type>
getPreviousTxnID() const
{
if (hasPreviousTxnID())
return this->sle_->at(sfPreviousTxnID);
return std::nullopt;
}
/**
* @brief Check if sfPreviousTxnID is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasPreviousTxnID() const
{
return this->sle_->isFieldPresent(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getPreviousTxnLgrSeq() const
{
if (hasPreviousTxnLgrSeq())
return this->sle_->at(sfPreviousTxnLgrSeq);
return std::nullopt;
}
/**
* @brief Check if sfPreviousTxnLgrSeq is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasPreviousTxnLgrSeq() const
{
return this->sle_->isFieldPresent(sfPreviousTxnLgrSeq);
}
};
/**
* @brief Builder for NegativeUNL ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class NegativeUNLBuilder : public LedgerEntryBuilderBase<NegativeUNLBuilder>
{
public:
/**
* @brief Construct a new NegativeUNLBuilder with required fields.
*/
NegativeUNLBuilder()
: LedgerEntryBuilderBase<NegativeUNLBuilder>(ltNEGATIVE_UNL)
{
}
/**
* @brief Construct a NegativeUNLBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
NegativeUNLBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltNEGATIVE_UNL)
{
throw std::runtime_error("Invalid ledger entry type for NegativeUNL");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfDisabledValidators (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
NegativeUNLBuilder&
setDisabledValidators(STArray const& value)
{
object_.setFieldArray(sfDisabledValidators, value);
return *this;
}
/**
* @brief Set sfValidatorToDisable (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
NegativeUNLBuilder&
setValidatorToDisable(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfValidatorToDisable] = value;
return *this;
}
/**
* @brief Set sfValidatorToReEnable (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
NegativeUNLBuilder&
setValidatorToReEnable(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfValidatorToReEnable] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
NegativeUNLBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
NegativeUNLBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Build and return the completed NegativeUNL wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
NegativeUNL
build(uint256 const& index)
{
return NegativeUNL{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

417
include/xrpl/protocol_autogen/ledger_entries/Offer.h Normal file
View File

@@ -0,0 +1,417 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class OfferBuilder;
/**
* @brief Ledger Entry: Offer
*
* Type: ltOFFER (0x006f)
* RPC Name: offer
*
* Immutable wrapper around SLE providing type-safe field access.
* Use OfferBuilder to construct new ledger entries.
*/
class Offer : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltOFFER;
/**
* @brief Construct a Offer ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit Offer(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for Offer");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfAccount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getAccount() const
{
return this->sle_->at(sfAccount);
}
/**
* @brief Get sfSequence (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getSequence() const
{
return this->sle_->at(sfSequence);
}
/**
* @brief Get sfTakerPays (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_AMOUNT::type::value_type
getTakerPays() const
{
return this->sle_->at(sfTakerPays);
}
/**
* @brief Get sfTakerGets (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_AMOUNT::type::value_type
getTakerGets() const
{
return this->sle_->at(sfTakerGets);
}
/**
* @brief Get sfBookDirectory (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getBookDirectory() const
{
return this->sle_->at(sfBookDirectory);
}
/**
* @brief Get sfBookNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getBookNode() const
{
return this->sle_->at(sfBookNode);
}
/**
* @brief Get sfOwnerNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getOwnerNode() const
{
return this->sle_->at(sfOwnerNode);
}
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
/**
* @brief Get sfExpiration (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getExpiration() const
{
if (hasExpiration())
return this->sle_->at(sfExpiration);
return std::nullopt;
}
/**
* @brief Check if sfExpiration is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasExpiration() const
{
return this->sle_->isFieldPresent(sfExpiration);
}
/**
* @brief Get sfDomainID (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT256::type::value_type>
getDomainID() const
{
if (hasDomainID())
return this->sle_->at(sfDomainID);
return std::nullopt;
}
/**
* @brief Check if sfDomainID is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasDomainID() const
{
return this->sle_->isFieldPresent(sfDomainID);
}
/**
* @brief Get sfAdditionalBooks (soeOPTIONAL)
* @note This is an untyped field (unknown).
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
std::optional<std::reference_wrapper<STArray const>>
getAdditionalBooks() const
{
if (this->sle_->isFieldPresent(sfAdditionalBooks))
return this->sle_->getFieldArray(sfAdditionalBooks);
return std::nullopt;
}
/**
* @brief Check if sfAdditionalBooks is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasAdditionalBooks() const
{
return this->sle_->isFieldPresent(sfAdditionalBooks);
}
};
/**
* @brief Builder for Offer ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class OfferBuilder : public LedgerEntryBuilderBase<OfferBuilder>
{
public:
/**
* @brief Construct a new OfferBuilder with required fields.
* @param account The sfAccount field value.
* @param sequence The sfSequence field value.
* @param takerPays The sfTakerPays field value.
* @param takerGets The sfTakerGets field value.
* @param bookDirectory The sfBookDirectory field value.
* @param bookNode The sfBookNode field value.
* @param ownerNode The sfOwnerNode field value.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
*/
OfferBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_UINT32::type::value_type> const& sequence,std::decay_t<typename SF_AMOUNT::type::value_type> const& takerPays,std::decay_t<typename SF_AMOUNT::type::value_type> const& takerGets,std::decay_t<typename SF_UINT256::type::value_type> const& bookDirectory,std::decay_t<typename SF_UINT64::type::value_type> const& bookNode,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
: LedgerEntryBuilderBase<OfferBuilder>(ltOFFER)
{
setAccount(account);
setSequence(sequence);
setTakerPays(takerPays);
setTakerGets(takerGets);
setBookDirectory(bookDirectory);
setBookNode(bookNode);
setOwnerNode(ownerNode);
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
}
/**
* @brief Construct a OfferBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
OfferBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltOFFER)
{
throw std::runtime_error("Invalid ledger entry type for Offer");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfAccount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
OfferBuilder&
setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfAccount] = value;
return *this;
}
/**
* @brief Set sfSequence (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
OfferBuilder&
setSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfSequence] = value;
return *this;
}
/**
* @brief Set sfTakerPays (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
OfferBuilder&
setTakerPays(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfTakerPays] = value;
return *this;
}
/**
* @brief Set sfTakerGets (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
OfferBuilder&
setTakerGets(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfTakerGets] = value;
return *this;
}
/**
* @brief Set sfBookDirectory (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
OfferBuilder&
setBookDirectory(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfBookDirectory] = value;
return *this;
}
/**
* @brief Set sfBookNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
OfferBuilder&
setBookNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfBookNode] = value;
return *this;
}
/**
* @brief Set sfOwnerNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
OfferBuilder&
setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfOwnerNode] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
OfferBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
OfferBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Set sfExpiration (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
OfferBuilder&
setExpiration(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfExpiration] = value;
return *this;
}
/**
* @brief Set sfDomainID (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
OfferBuilder&
setDomainID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfDomainID] = value;
return *this;
}
/**
* @brief Set sfAdditionalBooks (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
OfferBuilder&
setAdditionalBooks(STArray const& value)
{
object_.setFieldArray(sfAdditionalBooks, value);
return *this;
}
/**
* @brief Build and return the completed Offer wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
Offer
build(uint256 const& index)
{
return Offer{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

358
include/xrpl/protocol_autogen/ledger_entries/Oracle.h Normal file
View File

@@ -0,0 +1,358 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class OracleBuilder;
/**
* @brief Ledger Entry: Oracle
*
* Type: ltORACLE (0x0080)
* RPC Name: oracle
*
* Immutable wrapper around SLE providing type-safe field access.
* Use OracleBuilder to construct new ledger entries.
*/
class Oracle : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltORACLE;
/**
* @brief Construct a Oracle ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit Oracle(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for Oracle");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfOwner (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getOwner() const
{
return this->sle_->at(sfOwner);
}
/**
* @brief Get sfOracleDocumentID (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getOracleDocumentID() const
{
if (hasOracleDocumentID())
return this->sle_->at(sfOracleDocumentID);
return std::nullopt;
}
/**
* @brief Check if sfOracleDocumentID is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasOracleDocumentID() const
{
return this->sle_->isFieldPresent(sfOracleDocumentID);
}
/**
* @brief Get sfProvider (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_VL::type::value_type
getProvider() const
{
return this->sle_->at(sfProvider);
}
/**
* @brief Get sfPriceDataSeries (soeREQUIRED)
* @note This is an untyped field (unknown).
* @return The field value.
*/
[[nodiscard]]
STArray const&
getPriceDataSeries() const
{
return this->sle_->getFieldArray(sfPriceDataSeries);
}
/**
* @brief Get sfAssetClass (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_VL::type::value_type
getAssetClass() const
{
return this->sle_->at(sfAssetClass);
}
/**
* @brief Get sfLastUpdateTime (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getLastUpdateTime() const
{
return this->sle_->at(sfLastUpdateTime);
}
/**
* @brief Get sfURI (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_VL::type::value_type>
getURI() const
{
if (hasURI())
return this->sle_->at(sfURI);
return std::nullopt;
}
/**
* @brief Check if sfURI is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasURI() const
{
return this->sle_->isFieldPresent(sfURI);
}
/**
* @brief Get sfOwnerNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getOwnerNode() const
{
return this->sle_->at(sfOwnerNode);
}
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
};
/**
* @brief Builder for Oracle ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class OracleBuilder : public LedgerEntryBuilderBase<OracleBuilder>
{
public:
/**
* @brief Construct a new OracleBuilder with required fields.
* @param owner The sfOwner field value.
* @param provider The sfProvider field value.
* @param priceDataSeries The sfPriceDataSeries field value.
* @param assetClass The sfAssetClass field value.
* @param lastUpdateTime The sfLastUpdateTime field value.
* @param ownerNode The sfOwnerNode field value.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
*/
OracleBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& owner,std::decay_t<typename SF_VL::type::value_type> const& provider,STArray const& priceDataSeries,std::decay_t<typename SF_VL::type::value_type> const& assetClass,std::decay_t<typename SF_UINT32::type::value_type> const& lastUpdateTime,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
: LedgerEntryBuilderBase<OracleBuilder>(ltORACLE)
{
setOwner(owner);
setProvider(provider);
setPriceDataSeries(priceDataSeries);
setAssetClass(assetClass);
setLastUpdateTime(lastUpdateTime);
setOwnerNode(ownerNode);
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
}
/**
* @brief Construct a OracleBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
OracleBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltORACLE)
{
throw std::runtime_error("Invalid ledger entry type for Oracle");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfOwner (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
OracleBuilder&
setOwner(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfOwner] = value;
return *this;
}
/**
* @brief Set sfOracleDocumentID (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
OracleBuilder&
setOracleDocumentID(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfOracleDocumentID] = value;
return *this;
}
/**
* @brief Set sfProvider (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
OracleBuilder&
setProvider(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfProvider] = value;
return *this;
}
/**
* @brief Set sfPriceDataSeries (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
OracleBuilder&
setPriceDataSeries(STArray const& value)
{
object_.setFieldArray(sfPriceDataSeries, value);
return *this;
}
/**
* @brief Set sfAssetClass (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
OracleBuilder&
setAssetClass(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfAssetClass] = value;
return *this;
}
/**
* @brief Set sfLastUpdateTime (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
OracleBuilder&
setLastUpdateTime(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfLastUpdateTime] = value;
return *this;
}
/**
* @brief Set sfURI (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
OracleBuilder&
setURI(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfURI] = value;
return *this;
}
/**
* @brief Set sfOwnerNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
OracleBuilder&
setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfOwnerNode] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
OracleBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
OracleBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Build and return the completed Oracle wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
Oracle
build(uint256 const& index)
{
return Oracle{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

521
include/xrpl/protocol_autogen/ledger_entries/PayChannel.h Normal file
View File

@@ -0,0 +1,521 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class PayChannelBuilder;
/**
* @brief Ledger Entry: PayChannel
*
* Type: ltPAYCHAN (0x0078)
* RPC Name: payment_channel
*
* Immutable wrapper around SLE providing type-safe field access.
* Use PayChannelBuilder to construct new ledger entries.
*/
class PayChannel : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltPAYCHAN;
/**
* @brief Construct a PayChannel ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit PayChannel(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for PayChannel");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfAccount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getAccount() const
{
return this->sle_->at(sfAccount);
}
/**
* @brief Get sfDestination (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getDestination() const
{
return this->sle_->at(sfDestination);
}
/**
* @brief Get sfSequence (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getSequence() const
{
if (hasSequence())
return this->sle_->at(sfSequence);
return std::nullopt;
}
/**
* @brief Check if sfSequence is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasSequence() const
{
return this->sle_->isFieldPresent(sfSequence);
}
/**
* @brief Get sfAmount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_AMOUNT::type::value_type
getAmount() const
{
return this->sle_->at(sfAmount);
}
/**
* @brief Get sfBalance (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_AMOUNT::type::value_type
getBalance() const
{
return this->sle_->at(sfBalance);
}
/**
* @brief Get sfPublicKey (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_VL::type::value_type
getPublicKey() const
{
return this->sle_->at(sfPublicKey);
}
/**
* @brief Get sfSettleDelay (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getSettleDelay() const
{
return this->sle_->at(sfSettleDelay);
}
/**
* @brief Get sfExpiration (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getExpiration() const
{
if (hasExpiration())
return this->sle_->at(sfExpiration);
return std::nullopt;
}
/**
* @brief Check if sfExpiration is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasExpiration() const
{
return this->sle_->isFieldPresent(sfExpiration);
}
/**
* @brief Get sfCancelAfter (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getCancelAfter() const
{
if (hasCancelAfter())
return this->sle_->at(sfCancelAfter);
return std::nullopt;
}
/**
* @brief Check if sfCancelAfter is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasCancelAfter() const
{
return this->sle_->isFieldPresent(sfCancelAfter);
}
/**
* @brief Get sfSourceTag (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getSourceTag() const
{
if (hasSourceTag())
return this->sle_->at(sfSourceTag);
return std::nullopt;
}
/**
* @brief Check if sfSourceTag is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasSourceTag() const
{
return this->sle_->isFieldPresent(sfSourceTag);
}
/**
* @brief Get sfDestinationTag (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getDestinationTag() const
{
if (hasDestinationTag())
return this->sle_->at(sfDestinationTag);
return std::nullopt;
}
/**
* @brief Check if sfDestinationTag is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasDestinationTag() const
{
return this->sle_->isFieldPresent(sfDestinationTag);
}
/**
* @brief Get sfOwnerNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getOwnerNode() const
{
return this->sle_->at(sfOwnerNode);
}
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
/**
* @brief Get sfDestinationNode (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT64::type::value_type>
getDestinationNode() const
{
if (hasDestinationNode())
return this->sle_->at(sfDestinationNode);
return std::nullopt;
}
/**
* @brief Check if sfDestinationNode is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasDestinationNode() const
{
return this->sle_->isFieldPresent(sfDestinationNode);
}
};
/**
* @brief Builder for PayChannel ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class PayChannelBuilder : public LedgerEntryBuilderBase<PayChannelBuilder>
{
public:
/**
* @brief Construct a new PayChannelBuilder with required fields.
* @param account The sfAccount field value.
* @param destination The sfDestination field value.
* @param amount The sfAmount field value.
* @param balance The sfBalance field value.
* @param publicKey The sfPublicKey field value.
* @param settleDelay The sfSettleDelay field value.
* @param ownerNode The sfOwnerNode field value.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
*/
PayChannelBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_ACCOUNT::type::value_type> const& destination,std::decay_t<typename SF_AMOUNT::type::value_type> const& amount,std::decay_t<typename SF_AMOUNT::type::value_type> const& balance,std::decay_t<typename SF_VL::type::value_type> const& publicKey,std::decay_t<typename SF_UINT32::type::value_type> const& settleDelay,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
: LedgerEntryBuilderBase<PayChannelBuilder>(ltPAYCHAN)
{
setAccount(account);
setDestination(destination);
setAmount(amount);
setBalance(balance);
setPublicKey(publicKey);
setSettleDelay(settleDelay);
setOwnerNode(ownerNode);
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
}
/**
* @brief Construct a PayChannelBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
PayChannelBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltPAYCHAN)
{
throw std::runtime_error("Invalid ledger entry type for PayChannel");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfAccount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
PayChannelBuilder&
setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfAccount] = value;
return *this;
}
/**
* @brief Set sfDestination (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
PayChannelBuilder&
setDestination(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfDestination] = value;
return *this;
}
/**
* @brief Set sfSequence (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
PayChannelBuilder&
setSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfSequence] = value;
return *this;
}
/**
* @brief Set sfAmount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
PayChannelBuilder&
setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfAmount] = value;
return *this;
}
/**
* @brief Set sfBalance (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
PayChannelBuilder&
setBalance(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfBalance] = value;
return *this;
}
/**
* @brief Set sfPublicKey (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
PayChannelBuilder&
setPublicKey(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfPublicKey] = value;
return *this;
}
/**
* @brief Set sfSettleDelay (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
PayChannelBuilder&
setSettleDelay(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfSettleDelay] = value;
return *this;
}
/**
* @brief Set sfExpiration (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
PayChannelBuilder&
setExpiration(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfExpiration] = value;
return *this;
}
/**
* @brief Set sfCancelAfter (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
PayChannelBuilder&
setCancelAfter(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfCancelAfter] = value;
return *this;
}
/**
* @brief Set sfSourceTag (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
PayChannelBuilder&
setSourceTag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfSourceTag] = value;
return *this;
}
/**
* @brief Set sfDestinationTag (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
PayChannelBuilder&
setDestinationTag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfDestinationTag] = value;
return *this;
}
/**
* @brief Set sfOwnerNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
PayChannelBuilder&
setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfOwnerNode] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
PayChannelBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
PayChannelBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Set sfDestinationNode (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
PayChannelBuilder&
setDestinationNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfDestinationNode] = value;
return *this;
}
/**
* @brief Build and return the completed PayChannel wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
PayChannel
build(uint256 const& index)
{
return PayChannel{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

240
include/xrpl/protocol_autogen/ledger_entries/PermissionedDomain.h Normal file
View File

@@ -0,0 +1,240 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class PermissionedDomainBuilder;
/**
* @brief Ledger Entry: PermissionedDomain
*
* Type: ltPERMISSIONED_DOMAIN (0x0082)
* RPC Name: permissioned_domain
*
* Immutable wrapper around SLE providing type-safe field access.
* Use PermissionedDomainBuilder to construct new ledger entries.
*/
class PermissionedDomain : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltPERMISSIONED_DOMAIN;
/**
* @brief Construct a PermissionedDomain ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit PermissionedDomain(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for PermissionedDomain");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfOwner (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getOwner() const
{
return this->sle_->at(sfOwner);
}
/**
* @brief Get sfSequence (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getSequence() const
{
return this->sle_->at(sfSequence);
}
/**
* @brief Get sfAcceptedCredentials (soeREQUIRED)
* @note This is an untyped field (unknown).
* @return The field value.
*/
[[nodiscard]]
STArray const&
getAcceptedCredentials() const
{
return this->sle_->getFieldArray(sfAcceptedCredentials);
}
/**
* @brief Get sfOwnerNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getOwnerNode() const
{
return this->sle_->at(sfOwnerNode);
}
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
};
/**
* @brief Builder for PermissionedDomain ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class PermissionedDomainBuilder : public LedgerEntryBuilderBase<PermissionedDomainBuilder>
{
public:
/**
* @brief Construct a new PermissionedDomainBuilder with required fields.
* @param owner The sfOwner field value.
* @param sequence The sfSequence field value.
* @param acceptedCredentials The sfAcceptedCredentials field value.
* @param ownerNode The sfOwnerNode field value.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
*/
PermissionedDomainBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& owner,std::decay_t<typename SF_UINT32::type::value_type> const& sequence,STArray const& acceptedCredentials,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
: LedgerEntryBuilderBase<PermissionedDomainBuilder>(ltPERMISSIONED_DOMAIN)
{
setOwner(owner);
setSequence(sequence);
setAcceptedCredentials(acceptedCredentials);
setOwnerNode(ownerNode);
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
}
/**
* @brief Construct a PermissionedDomainBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
PermissionedDomainBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltPERMISSIONED_DOMAIN)
{
throw std::runtime_error("Invalid ledger entry type for PermissionedDomain");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfOwner (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
PermissionedDomainBuilder&
setOwner(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfOwner] = value;
return *this;
}
/**
* @brief Set sfSequence (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
PermissionedDomainBuilder&
setSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfSequence] = value;
return *this;
}
/**
* @brief Set sfAcceptedCredentials (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
PermissionedDomainBuilder&
setAcceptedCredentials(STArray const& value)
{
object_.setFieldArray(sfAcceptedCredentials, value);
return *this;
}
/**
* @brief Set sfOwnerNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
PermissionedDomainBuilder&
setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfOwnerNode] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
PermissionedDomainBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
PermissionedDomainBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Build and return the completed PermissionedDomain wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
PermissionedDomain
build(uint256 const& index)
{
return PermissionedDomain{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

425
include/xrpl/protocol_autogen/ledger_entries/RippleState.h Normal file
View File

@@ -0,0 +1,425 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class RippleStateBuilder;
/**
* @brief Ledger Entry: RippleState
*
* Type: ltRIPPLE_STATE (0x0072)
* RPC Name: state
*
* Immutable wrapper around SLE providing type-safe field access.
* Use RippleStateBuilder to construct new ledger entries.
*/
class RippleState : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltRIPPLE_STATE;
/**
* @brief Construct a RippleState ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit RippleState(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for RippleState");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfBalance (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_AMOUNT::type::value_type
getBalance() const
{
return this->sle_->at(sfBalance);
}
/**
* @brief Get sfLowLimit (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_AMOUNT::type::value_type
getLowLimit() const
{
return this->sle_->at(sfLowLimit);
}
/**
* @brief Get sfHighLimit (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_AMOUNT::type::value_type
getHighLimit() const
{
return this->sle_->at(sfHighLimit);
}
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
/**
* @brief Get sfLowNode (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT64::type::value_type>
getLowNode() const
{
if (hasLowNode())
return this->sle_->at(sfLowNode);
return std::nullopt;
}
/**
* @brief Check if sfLowNode is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasLowNode() const
{
return this->sle_->isFieldPresent(sfLowNode);
}
/**
* @brief Get sfLowQualityIn (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getLowQualityIn() const
{
if (hasLowQualityIn())
return this->sle_->at(sfLowQualityIn);
return std::nullopt;
}
/**
* @brief Check if sfLowQualityIn is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasLowQualityIn() const
{
return this->sle_->isFieldPresent(sfLowQualityIn);
}
/**
* @brief Get sfLowQualityOut (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getLowQualityOut() const
{
if (hasLowQualityOut())
return this->sle_->at(sfLowQualityOut);
return std::nullopt;
}
/**
* @brief Check if sfLowQualityOut is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasLowQualityOut() const
{
return this->sle_->isFieldPresent(sfLowQualityOut);
}
/**
* @brief Get sfHighNode (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT64::type::value_type>
getHighNode() const
{
if (hasHighNode())
return this->sle_->at(sfHighNode);
return std::nullopt;
}
/**
* @brief Check if sfHighNode is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasHighNode() const
{
return this->sle_->isFieldPresent(sfHighNode);
}
/**
* @brief Get sfHighQualityIn (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getHighQualityIn() const
{
if (hasHighQualityIn())
return this->sle_->at(sfHighQualityIn);
return std::nullopt;
}
/**
* @brief Check if sfHighQualityIn is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasHighQualityIn() const
{
return this->sle_->isFieldPresent(sfHighQualityIn);
}
/**
* @brief Get sfHighQualityOut (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getHighQualityOut() const
{
if (hasHighQualityOut())
return this->sle_->at(sfHighQualityOut);
return std::nullopt;
}
/**
* @brief Check if sfHighQualityOut is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasHighQualityOut() const
{
return this->sle_->isFieldPresent(sfHighQualityOut);
}
};
/**
* @brief Builder for RippleState ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class RippleStateBuilder : public LedgerEntryBuilderBase<RippleStateBuilder>
{
public:
/**
* @brief Construct a new RippleStateBuilder with required fields.
* @param balance The sfBalance field value.
* @param lowLimit The sfLowLimit field value.
* @param highLimit The sfHighLimit field value.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
*/
RippleStateBuilder(std::decay_t<typename SF_AMOUNT::type::value_type> const& balance,std::decay_t<typename SF_AMOUNT::type::value_type> const& lowLimit,std::decay_t<typename SF_AMOUNT::type::value_type> const& highLimit,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
: LedgerEntryBuilderBase<RippleStateBuilder>(ltRIPPLE_STATE)
{
setBalance(balance);
setLowLimit(lowLimit);
setHighLimit(highLimit);
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
}
/**
* @brief Construct a RippleStateBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
RippleStateBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltRIPPLE_STATE)
{
throw std::runtime_error("Invalid ledger entry type for RippleState");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfBalance (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
RippleStateBuilder&
setBalance(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfBalance] = value;
return *this;
}
/**
* @brief Set sfLowLimit (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
RippleStateBuilder&
setLowLimit(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfLowLimit] = value;
return *this;
}
/**
* @brief Set sfHighLimit (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
RippleStateBuilder&
setHighLimit(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfHighLimit] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
RippleStateBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
RippleStateBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Set sfLowNode (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
RippleStateBuilder&
setLowNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfLowNode] = value;
return *this;
}
/**
* @brief Set sfLowQualityIn (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
RippleStateBuilder&
setLowQualityIn(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfLowQualityIn] = value;
return *this;
}
/**
* @brief Set sfLowQualityOut (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
RippleStateBuilder&
setLowQualityOut(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfLowQualityOut] = value;
return *this;
}
/**
* @brief Set sfHighNode (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
RippleStateBuilder&
setHighNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfHighNode] = value;
return *this;
}
/**
* @brief Set sfHighQualityIn (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
RippleStateBuilder&
setHighQualityIn(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfHighQualityIn] = value;
return *this;
}
/**
* @brief Set sfHighQualityOut (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
RippleStateBuilder&
setHighQualityOut(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfHighQualityOut] = value;
return *this;
}
/**
* @brief Build and return the completed RippleState wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
RippleState
build(uint256 const& index)
{
return RippleState{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

275
include/xrpl/protocol_autogen/ledger_entries/SignerList.h Normal file
View File

@@ -0,0 +1,275 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class SignerListBuilder;
/**
* @brief Ledger Entry: SignerList
*
* Type: ltSIGNER_LIST (0x0053)
* RPC Name: signer_list
*
* Immutable wrapper around SLE providing type-safe field access.
* Use SignerListBuilder to construct new ledger entries.
*/
class SignerList : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltSIGNER_LIST;
/**
* @brief Construct a SignerList ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit SignerList(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for SignerList");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfOwner (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
getOwner() const
{
if (hasOwner())
return this->sle_->at(sfOwner);
return std::nullopt;
}
/**
* @brief Check if sfOwner is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasOwner() const
{
return this->sle_->isFieldPresent(sfOwner);
}
/**
* @brief Get sfOwnerNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getOwnerNode() const
{
return this->sle_->at(sfOwnerNode);
}
/**
* @brief Get sfSignerQuorum (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getSignerQuorum() const
{
return this->sle_->at(sfSignerQuorum);
}
/**
* @brief Get sfSignerEntries (soeREQUIRED)
* @note This is an untyped field (unknown).
* @return The field value.
*/
[[nodiscard]]
STArray const&
getSignerEntries() const
{
return this->sle_->getFieldArray(sfSignerEntries);
}
/**
* @brief Get sfSignerListID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getSignerListID() const
{
return this->sle_->at(sfSignerListID);
}
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
};
/**
* @brief Builder for SignerList ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class SignerListBuilder : public LedgerEntryBuilderBase<SignerListBuilder>
{
public:
/**
* @brief Construct a new SignerListBuilder with required fields.
* @param ownerNode The sfOwnerNode field value.
* @param signerQuorum The sfSignerQuorum field value.
* @param signerEntries The sfSignerEntries field value.
* @param signerListID The sfSignerListID field value.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
*/
SignerListBuilder(std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT32::type::value_type> const& signerQuorum,STArray const& signerEntries,std::decay_t<typename SF_UINT32::type::value_type> const& signerListID,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
: LedgerEntryBuilderBase<SignerListBuilder>(ltSIGNER_LIST)
{
setOwnerNode(ownerNode);
setSignerQuorum(signerQuorum);
setSignerEntries(signerEntries);
setSignerListID(signerListID);
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
}
/**
* @brief Construct a SignerListBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
SignerListBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltSIGNER_LIST)
{
throw std::runtime_error("Invalid ledger entry type for SignerList");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfOwner (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
SignerListBuilder&
setOwner(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfOwner] = value;
return *this;
}
/**
* @brief Set sfOwnerNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
SignerListBuilder&
setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfOwnerNode] = value;
return *this;
}
/**
* @brief Set sfSignerQuorum (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
SignerListBuilder&
setSignerQuorum(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfSignerQuorum] = value;
return *this;
}
/**
* @brief Set sfSignerEntries (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
SignerListBuilder&
setSignerEntries(STArray const& value)
{
object_.setFieldArray(sfSignerEntries, value);
return *this;
}
/**
* @brief Set sfSignerListID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
SignerListBuilder&
setSignerListID(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfSignerListID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
SignerListBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
SignerListBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Build and return the completed SignerList wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
SignerList
build(uint256 const& index)
{
return SignerList{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

215
include/xrpl/protocol_autogen/ledger_entries/Ticket.h Normal file
View File

@@ -0,0 +1,215 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class TicketBuilder;
/**
* @brief Ledger Entry: Ticket
*
* Type: ltTICKET (0x0054)
* RPC Name: ticket
*
* Immutable wrapper around SLE providing type-safe field access.
* Use TicketBuilder to construct new ledger entries.
*/
class Ticket : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltTICKET;
/**
* @brief Construct a Ticket ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit Ticket(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for Ticket");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfAccount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getAccount() const
{
return this->sle_->at(sfAccount);
}
/**
* @brief Get sfOwnerNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getOwnerNode() const
{
return this->sle_->at(sfOwnerNode);
}
/**
* @brief Get sfTicketSequence (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getTicketSequence() const
{
return this->sle_->at(sfTicketSequence);
}
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
};
/**
* @brief Builder for Ticket ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class TicketBuilder : public LedgerEntryBuilderBase<TicketBuilder>
{
public:
/**
* @brief Construct a new TicketBuilder with required fields.
* @param account The sfAccount field value.
* @param ownerNode The sfOwnerNode field value.
* @param ticketSequence The sfTicketSequence field value.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
*/
TicketBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT32::type::value_type> const& ticketSequence,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
: LedgerEntryBuilderBase<TicketBuilder>(ltTICKET)
{
setAccount(account);
setOwnerNode(ownerNode);
setTicketSequence(ticketSequence);
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
}
/**
* @brief Construct a TicketBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
TicketBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltTICKET)
{
throw std::runtime_error("Invalid ledger entry type for Ticket");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfAccount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
TicketBuilder&
setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfAccount] = value;
return *this;
}
/**
* @brief Set sfOwnerNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
TicketBuilder&
setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfOwnerNode] = value;
return *this;
}
/**
* @brief Set sfTicketSequence (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
TicketBuilder&
setTicketSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfTicketSequence] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
TicketBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
TicketBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Build and return the completed Ticket wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
Ticket
build(uint256 const& index)
{
return Ticket{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

521
include/xrpl/protocol_autogen/ledger_entries/Vault.h Normal file
View File

@@ -0,0 +1,521 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class VaultBuilder;
/**
* @brief Ledger Entry: Vault
*
* Type: ltVAULT (0x0084)
* RPC Name: vault
*
* Immutable wrapper around SLE providing type-safe field access.
* Use VaultBuilder to construct new ledger entries.
*/
class Vault : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltVAULT;
/**
* @brief Construct a Vault ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit Vault(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for Vault");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
/**
* @brief Get sfSequence (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getSequence() const
{
return this->sle_->at(sfSequence);
}
/**
* @brief Get sfOwnerNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getOwnerNode() const
{
return this->sle_->at(sfOwnerNode);
}
/**
* @brief Get sfOwner (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getOwner() const
{
return this->sle_->at(sfOwner);
}
/**
* @brief Get sfAccount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getAccount() const
{
return this->sle_->at(sfAccount);
}
/**
* @brief Get sfData (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_VL::type::value_type>
getData() const
{
if (hasData())
return this->sle_->at(sfData);
return std::nullopt;
}
/**
* @brief Check if sfData is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasData() const
{
return this->sle_->isFieldPresent(sfData);
}
/**
* @brief Get sfAsset (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ISSUE::type::value_type
getAsset() const
{
return this->sle_->at(sfAsset);
}
/**
* @brief Get sfAssetsTotal (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_NUMBER::type::value_type>
getAssetsTotal() const
{
if (hasAssetsTotal())
return this->sle_->at(sfAssetsTotal);
return std::nullopt;
}
/**
* @brief Check if sfAssetsTotal is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasAssetsTotal() const
{
return this->sle_->isFieldPresent(sfAssetsTotal);
}
/**
* @brief Get sfAssetsAvailable (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_NUMBER::type::value_type>
getAssetsAvailable() const
{
if (hasAssetsAvailable())
return this->sle_->at(sfAssetsAvailable);
return std::nullopt;
}
/**
* @brief Check if sfAssetsAvailable is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasAssetsAvailable() const
{
return this->sle_->isFieldPresent(sfAssetsAvailable);
}
/**
* @brief Get sfAssetsMaximum (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_NUMBER::type::value_type>
getAssetsMaximum() const
{
if (hasAssetsMaximum())
return this->sle_->at(sfAssetsMaximum);
return std::nullopt;
}
/**
* @brief Check if sfAssetsMaximum is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasAssetsMaximum() const
{
return this->sle_->isFieldPresent(sfAssetsMaximum);
}
/**
* @brief Get sfLossUnrealized (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_NUMBER::type::value_type>
getLossUnrealized() const
{
if (hasLossUnrealized())
return this->sle_->at(sfLossUnrealized);
return std::nullopt;
}
/**
* @brief Check if sfLossUnrealized is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasLossUnrealized() const
{
return this->sle_->isFieldPresent(sfLossUnrealized);
}
/**
* @brief Get sfShareMPTID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT192::type::value_type
getShareMPTID() const
{
return this->sle_->at(sfShareMPTID);
}
/**
* @brief Get sfWithdrawalPolicy (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT8::type::value_type
getWithdrawalPolicy() const
{
return this->sle_->at(sfWithdrawalPolicy);
}
/**
* @brief Get sfScale (soeDEFAULT)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT8::type::value_type>
getScale() const
{
if (hasScale())
return this->sle_->at(sfScale);
return std::nullopt;
}
/**
* @brief Check if sfScale is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasScale() const
{
return this->sle_->isFieldPresent(sfScale);
}
};
/**
* @brief Builder for Vault ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class VaultBuilder : public LedgerEntryBuilderBase<VaultBuilder>
{
public:
/**
* @brief Construct a new VaultBuilder with required fields.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
* @param sequence The sfSequence field value.
* @param ownerNode The sfOwnerNode field value.
* @param owner The sfOwner field value.
* @param account The sfAccount field value.
* @param asset The sfAsset field value.
* @param shareMPTID The sfShareMPTID field value.
* @param withdrawalPolicy The sfWithdrawalPolicy field value.
*/
VaultBuilder(std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq,std::decay_t<typename SF_UINT32::type::value_type> const& sequence,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_ACCOUNT::type::value_type> const& owner,std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_ISSUE::type::value_type> const& asset,std::decay_t<typename SF_UINT192::type::value_type> const& shareMPTID,std::decay_t<typename SF_UINT8::type::value_type> const& withdrawalPolicy)
: LedgerEntryBuilderBase<VaultBuilder>(ltVAULT)
{
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
setSequence(sequence);
setOwnerNode(ownerNode);
setOwner(owner);
setAccount(account);
setAsset(asset);
setShareMPTID(shareMPTID);
setWithdrawalPolicy(withdrawalPolicy);
}
/**
* @brief Construct a VaultBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
VaultBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltVAULT)
{
throw std::runtime_error("Invalid ledger entry type for Vault");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
VaultBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
VaultBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Set sfSequence (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
VaultBuilder&
setSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfSequence] = value;
return *this;
}
/**
* @brief Set sfOwnerNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
VaultBuilder&
setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfOwnerNode] = value;
return *this;
}
/**
* @brief Set sfOwner (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
VaultBuilder&
setOwner(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfOwner] = value;
return *this;
}
/**
* @brief Set sfAccount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
VaultBuilder&
setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfAccount] = value;
return *this;
}
/**
* @brief Set sfData (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
VaultBuilder&
setData(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfData] = value;
return *this;
}
/**
* @brief Set sfAsset (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
VaultBuilder&
setAsset(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
{
object_[sfAsset] = STIssue(sfAsset, value);
return *this;
}
/**
* @brief Set sfAssetsTotal (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
VaultBuilder&
setAssetsTotal(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
{
object_[sfAssetsTotal] = value;
return *this;
}
/**
* @brief Set sfAssetsAvailable (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
VaultBuilder&
setAssetsAvailable(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
{
object_[sfAssetsAvailable] = value;
return *this;
}
/**
* @brief Set sfAssetsMaximum (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
VaultBuilder&
setAssetsMaximum(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
{
object_[sfAssetsMaximum] = value;
return *this;
}
/**
* @brief Set sfLossUnrealized (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
VaultBuilder&
setLossUnrealized(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
{
object_[sfLossUnrealized] = value;
return *this;
}
/**
* @brief Set sfShareMPTID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
VaultBuilder&
setShareMPTID(std::decay_t<typename SF_UINT192::type::value_type> const& value)
{
object_[sfShareMPTID] = value;
return *this;
}
/**
* @brief Set sfWithdrawalPolicy (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
VaultBuilder&
setWithdrawalPolicy(std::decay_t<typename SF_UINT8::type::value_type> const& value)
{
object_[sfWithdrawalPolicy] = value;
return *this;
}
/**
* @brief Set sfScale (soeDEFAULT)
* @return Reference to this builder for method chaining.
*/
VaultBuilder&
setScale(std::decay_t<typename SF_UINT8::type::value_type> const& value)
{
object_[sfScale] = value;
return *this;
}
/**
* @brief Build and return the completed Vault wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
Vault
build(uint256 const& index)
{
return Vault{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

312
include/xrpl/protocol_autogen/ledger_entries/XChainOwnedClaimID.h Normal file
View File

@@ -0,0 +1,312 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class XChainOwnedClaimIDBuilder;
/**
* @brief Ledger Entry: XChainOwnedClaimID
*
* Type: ltXCHAIN_OWNED_CLAIM_ID (0x0071)
* RPC Name: xchain_owned_claim_id
*
* Immutable wrapper around SLE providing type-safe field access.
* Use XChainOwnedClaimIDBuilder to construct new ledger entries.
*/
class XChainOwnedClaimID : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltXCHAIN_OWNED_CLAIM_ID;
/**
* @brief Construct a XChainOwnedClaimID ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit XChainOwnedClaimID(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for XChainOwnedClaimID");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfAccount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getAccount() const
{
return this->sle_->at(sfAccount);
}
/**
* @brief Get sfXChainBridge (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_XCHAIN_BRIDGE::type::value_type
getXChainBridge() const
{
return this->sle_->at(sfXChainBridge);
}
/**
* @brief Get sfXChainClaimID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getXChainClaimID() const
{
return this->sle_->at(sfXChainClaimID);
}
/**
* @brief Get sfOtherChainSource (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getOtherChainSource() const
{
return this->sle_->at(sfOtherChainSource);
}
/**
* @brief Get sfXChainClaimAttestations (soeREQUIRED)
* @note This is an untyped field (unknown).
* @return The field value.
*/
[[nodiscard]]
STArray const&
getXChainClaimAttestations() const
{
return this->sle_->getFieldArray(sfXChainClaimAttestations);
}
/**
* @brief Get sfSignatureReward (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_AMOUNT::type::value_type
getSignatureReward() const
{
return this->sle_->at(sfSignatureReward);
}
/**
* @brief Get sfOwnerNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getOwnerNode() const
{
return this->sle_->at(sfOwnerNode);
}
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
};
/**
* @brief Builder for XChainOwnedClaimID ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class XChainOwnedClaimIDBuilder : public LedgerEntryBuilderBase<XChainOwnedClaimIDBuilder>
{
public:
/**
* @brief Construct a new XChainOwnedClaimIDBuilder with required fields.
* @param account The sfAccount field value.
* @param xChainBridge The sfXChainBridge field value.
* @param xChainClaimID The sfXChainClaimID field value.
* @param otherChainSource The sfOtherChainSource field value.
* @param xChainClaimAttestations The sfXChainClaimAttestations field value.
* @param signatureReward The sfSignatureReward field value.
* @param ownerNode The sfOwnerNode field value.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
*/
XChainOwnedClaimIDBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& xChainBridge,std::decay_t<typename SF_UINT64::type::value_type> const& xChainClaimID,std::decay_t<typename SF_ACCOUNT::type::value_type> const& otherChainSource,STArray const& xChainClaimAttestations,std::decay_t<typename SF_AMOUNT::type::value_type> const& signatureReward,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
: LedgerEntryBuilderBase<XChainOwnedClaimIDBuilder>(ltXCHAIN_OWNED_CLAIM_ID)
{
setAccount(account);
setXChainBridge(xChainBridge);
setXChainClaimID(xChainClaimID);
setOtherChainSource(otherChainSource);
setXChainClaimAttestations(xChainClaimAttestations);
setSignatureReward(signatureReward);
setOwnerNode(ownerNode);
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
}
/**
* @brief Construct a XChainOwnedClaimIDBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
XChainOwnedClaimIDBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltXCHAIN_OWNED_CLAIM_ID)
{
throw std::runtime_error("Invalid ledger entry type for XChainOwnedClaimID");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfAccount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
XChainOwnedClaimIDBuilder&
setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfAccount] = value;
return *this;
}
/**
* @brief Set sfXChainBridge (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
XChainOwnedClaimIDBuilder&
setXChainBridge(std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& value)
{
object_[sfXChainBridge] = value;
return *this;
}
/**
* @brief Set sfXChainClaimID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
XChainOwnedClaimIDBuilder&
setXChainClaimID(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfXChainClaimID] = value;
return *this;
}
/**
* @brief Set sfOtherChainSource (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
XChainOwnedClaimIDBuilder&
setOtherChainSource(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfOtherChainSource] = value;
return *this;
}
/**
* @brief Set sfXChainClaimAttestations (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
XChainOwnedClaimIDBuilder&
setXChainClaimAttestations(STArray const& value)
{
object_.setFieldArray(sfXChainClaimAttestations, value);
return *this;
}
/**
* @brief Set sfSignatureReward (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
XChainOwnedClaimIDBuilder&
setSignatureReward(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfSignatureReward] = value;
return *this;
}
/**
* @brief Set sfOwnerNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
XChainOwnedClaimIDBuilder&
setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfOwnerNode] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
XChainOwnedClaimIDBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
XChainOwnedClaimIDBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Build and return the completed XChainOwnedClaimID wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
XChainOwnedClaimID
build(uint256 const& index)
{
return XChainOwnedClaimID{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

264
include/xrpl/protocol_autogen/ledger_entries/XChainOwnedCreateAccountClaimID.h Normal file
View File

@@ -0,0 +1,264 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/LedgerEntryBase.h>
#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::ledger_entries {
class XChainOwnedCreateAccountClaimIDBuilder;
/**
* @brief Ledger Entry: XChainOwnedCreateAccountClaimID
*
* Type: ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID (0x0074)
* RPC Name: xchain_owned_create_account_claim_id
*
* Immutable wrapper around SLE providing type-safe field access.
* Use XChainOwnedCreateAccountClaimIDBuilder to construct new ledger entries.
*/
class XChainOwnedCreateAccountClaimID : public LedgerEntryBase
{
public:
static constexpr LedgerEntryType entryType = ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID;
/**
* @brief Construct a XChainOwnedCreateAccountClaimID ledger entry wrapper from an existing SLE object.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
explicit XChainOwnedCreateAccountClaimID(std::shared_ptr<SLE const> sle)
: LedgerEntryBase(std::move(sle))
{
// Verify ledger entry type
if (sle_->getType() != entryType)
{
throw std::runtime_error("Invalid ledger entry type for XChainOwnedCreateAccountClaimID");
}
}
// Ledger entry-specific field getters
/**
* @brief Get sfAccount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getAccount() const
{
return this->sle_->at(sfAccount);
}
/**
* @brief Get sfXChainBridge (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_XCHAIN_BRIDGE::type::value_type
getXChainBridge() const
{
return this->sle_->at(sfXChainBridge);
}
/**
* @brief Get sfXChainAccountCreateCount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getXChainAccountCreateCount() const
{
return this->sle_->at(sfXChainAccountCreateCount);
}
/**
* @brief Get sfXChainCreateAccountAttestations (soeREQUIRED)
* @note This is an untyped field (unknown).
* @return The field value.
*/
[[nodiscard]]
STArray const&
getXChainCreateAccountAttestations() const
{
return this->sle_->getFieldArray(sfXChainCreateAccountAttestations);
}
/**
* @brief Get sfOwnerNode (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT64::type::value_type
getOwnerNode() const
{
return this->sle_->at(sfOwnerNode);
}
/**
* @brief Get sfPreviousTxnID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getPreviousTxnID() const
{
return this->sle_->at(sfPreviousTxnID);
}
/**
* @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT32::type::value_type
getPreviousTxnLgrSeq() const
{
return this->sle_->at(sfPreviousTxnLgrSeq);
}
};
/**
* @brief Builder for XChainOwnedCreateAccountClaimID ledger entries.
*
* Provides a fluent interface for constructing ledger entries with method chaining.
* Uses Json::Value internally for flexible ledger entry construction.
* Inherits common field setters from LedgerEntryBuilderBase.
*/
class XChainOwnedCreateAccountClaimIDBuilder : public LedgerEntryBuilderBase<XChainOwnedCreateAccountClaimIDBuilder>
{
public:
/**
* @brief Construct a new XChainOwnedCreateAccountClaimIDBuilder with required fields.
* @param account The sfAccount field value.
* @param xChainBridge The sfXChainBridge field value.
* @param xChainAccountCreateCount The sfXChainAccountCreateCount field value.
* @param xChainCreateAccountAttestations The sfXChainCreateAccountAttestations field value.
* @param ownerNode The sfOwnerNode field value.
* @param previousTxnID The sfPreviousTxnID field value.
* @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
*/
XChainOwnedCreateAccountClaimIDBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& xChainBridge,std::decay_t<typename SF_UINT64::type::value_type> const& xChainAccountCreateCount,STArray const& xChainCreateAccountAttestations,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
: LedgerEntryBuilderBase<XChainOwnedCreateAccountClaimIDBuilder>(ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID)
{
setAccount(account);
setXChainBridge(xChainBridge);
setXChainAccountCreateCount(xChainAccountCreateCount);
setXChainCreateAccountAttestations(xChainCreateAccountAttestations);
setOwnerNode(ownerNode);
setPreviousTxnID(previousTxnID);
setPreviousTxnLgrSeq(previousTxnLgrSeq);
}
/**
* @brief Construct a XChainOwnedCreateAccountClaimIDBuilder from an existing SLE object.
* @param sle The existing ledger entry to copy from.
* @throws std::runtime_error if the ledger entry type doesn't match.
*/
XChainOwnedCreateAccountClaimIDBuilder(std::shared_ptr<SLE const> sle)
{
if (sle->at(sfLedgerEntryType) != ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID)
{
throw std::runtime_error("Invalid ledger entry type for XChainOwnedCreateAccountClaimID");
}
object_ = *sle;
}
/** @brief Ledger entry-specific field setters */
/**
* @brief Set sfAccount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
XChainOwnedCreateAccountClaimIDBuilder&
setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfAccount] = value;
return *this;
}
/**
* @brief Set sfXChainBridge (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
XChainOwnedCreateAccountClaimIDBuilder&
setXChainBridge(std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& value)
{
object_[sfXChainBridge] = value;
return *this;
}
/**
* @brief Set sfXChainAccountCreateCount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
XChainOwnedCreateAccountClaimIDBuilder&
setXChainAccountCreateCount(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfXChainAccountCreateCount] = value;
return *this;
}
/**
* @brief Set sfXChainCreateAccountAttestations (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
XChainOwnedCreateAccountClaimIDBuilder&
setXChainCreateAccountAttestations(STArray const& value)
{
object_.setFieldArray(sfXChainCreateAccountAttestations, value);
return *this;
}
/**
* @brief Set sfOwnerNode (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
XChainOwnedCreateAccountClaimIDBuilder&
setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
{
object_[sfOwnerNode] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
XChainOwnedCreateAccountClaimIDBuilder&
setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfPreviousTxnID] = value;
return *this;
}
/**
* @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
XChainOwnedCreateAccountClaimIDBuilder&
setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfPreviousTxnLgrSeq] = value;
return *this;
}
/**
* @brief Build and return the completed XChainOwnedCreateAccountClaimID wrapper.
* @param index The ledger entry index.
* @return The constructed ledger entry wrapper.
*/
XChainOwnedCreateAccountClaimID
build(uint256 const& index)
{
return XChainOwnedCreateAccountClaimID{std::make_shared<SLE>(std::move(object_), index)};
}
};
} // namespace xrpl::ledger_entries

262
include/xrpl/protocol_autogen/transactions/AMMBid.h Normal file
View File

@@ -0,0 +1,262 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/TransactionBase.h>
#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::transactions {
class AMMBidBuilder;
/**
* @brief Transaction: AMMBid
*
* Type: ttAMM_BID (39)
* Delegable: Delegation::delegable
* Amendment: featureAMM
* Privileges: noPriv
*
* Immutable wrapper around STTx providing type-safe field access.
* Use AMMBidBuilder to construct new transactions.
*/
class AMMBid : public TransactionBase
{
public:
static constexpr xrpl::TxType txType = ttAMM_BID;
/**
* @brief Construct a AMMBid transaction wrapper from an existing STTx object.
* @throws std::runtime_error if the transaction type doesn't match.
*/
explicit AMMBid(std::shared_ptr<STTx const> tx)
: TransactionBase(std::move(tx))
{
// Verify transaction type
if (tx_->getTxnType() != txType)
{
throw std::runtime_error("Invalid transaction type for AMMBid");
}
}
// Transaction-specific field getters
/**
* @brief Get sfAsset (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ISSUE::type::value_type
getAsset() const
{
return this->tx_->at(sfAsset);
}
/**
* @brief Get sfAsset2 (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ISSUE::type::value_type
getAsset2() const
{
return this->tx_->at(sfAsset2);
}
/**
* @brief Get sfBidMin (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_AMOUNT::type::value_type>
getBidMin() const
{
if (hasBidMin())
{
return this->tx_->at(sfBidMin);
}
return std::nullopt;
}
/**
* @brief Check if sfBidMin is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasBidMin() const
{
return this->tx_->isFieldPresent(sfBidMin);
}
/**
* @brief Get sfBidMax (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_AMOUNT::type::value_type>
getBidMax() const
{
if (hasBidMax())
{
return this->tx_->at(sfBidMax);
}
return std::nullopt;
}
/**
* @brief Check if sfBidMax is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasBidMax() const
{
return this->tx_->isFieldPresent(sfBidMax);
}
/**
* @brief Get sfAuthAccounts (soeOPTIONAL)
* @note This is an untyped field.
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
std::optional<std::reference_wrapper<STArray const>>
getAuthAccounts() const
{
if (this->tx_->isFieldPresent(sfAuthAccounts))
return this->tx_->getFieldArray(sfAuthAccounts);
return std::nullopt;
}
/**
* @brief Check if sfAuthAccounts is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasAuthAccounts() const
{
return this->tx_->isFieldPresent(sfAuthAccounts);
}
};
/**
* @brief Builder for AMMBid transactions.
*
* Provides a fluent interface for constructing transactions with method chaining.
* Uses Json::Value internally for flexible transaction construction.
* Inherits common field setters from TransactionBuilderBase.
*/
class AMMBidBuilder : public TransactionBuilderBase<AMMBidBuilder>
{
public:
/**
* @brief Construct a new AMMBidBuilder with required fields.
* @param account The account initiating the transaction.
* @param asset The sfAsset field value.
* @param asset2 The sfAsset2 field value.
* @param sequence Optional sequence number for the transaction.
* @param fee Optional fee for the transaction.
*/
AMMBidBuilder(SF_ACCOUNT::type::value_type account,
std::decay_t<typename SF_ISSUE::type::value_type> const& asset, std::decay_t<typename SF_ISSUE::type::value_type> const& asset2, std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
)
: TransactionBuilderBase<AMMBidBuilder>(ttAMM_BID, account, sequence, fee)
{
setAsset(asset);
setAsset2(asset2);
}
/**
* @brief Construct a AMMBidBuilder from an existing STTx object.
* @param tx The existing transaction to copy from.
* @throws std::runtime_error if the transaction type doesn't match.
*/
AMMBidBuilder(std::shared_ptr<STTx const> tx)
{
if (tx->getTxnType() != ttAMM_BID)
{
throw std::runtime_error("Invalid transaction type for AMMBidBuilder");
}
object_ = *tx;
}
/** @brief Transaction-specific field setters */
/**
* @brief Set sfAsset (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AMMBidBuilder&
setAsset(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
{
object_[sfAsset] = STIssue(sfAsset, value);
return *this;
}
/**
* @brief Set sfAsset2 (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AMMBidBuilder&
setAsset2(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
{
object_[sfAsset2] = STIssue(sfAsset2, value);
return *this;
}
/**
* @brief Set sfBidMin (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AMMBidBuilder&
setBidMin(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfBidMin] = value;
return *this;
}
/**
* @brief Set sfBidMax (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AMMBidBuilder&
setBidMax(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfBidMax] = value;
return *this;
}
/**
* @brief Set sfAuthAccounts (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AMMBidBuilder&
setAuthAccounts(STArray const& value)
{
object_.setFieldArray(sfAuthAccounts, value);
return *this;
}
/**
* @brief Build and return the AMMBid wrapper.
* @param publicKey The public key for signing.
* @param secretKey The secret key for signing.
* @return The constructed transaction wrapper.
*/
AMMBid
build(PublicKey const& publicKey, SecretKey const& secretKey)
{
sign(publicKey, secretKey);
return AMMBid{std::make_shared<STTx>(std::move(object_))};
}
};
} // namespace xrpl::transactions

214
include/xrpl/protocol_autogen/transactions/AMMClawback.h Normal file
View File

@@ -0,0 +1,214 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/TransactionBase.h>
#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::transactions {
class AMMClawbackBuilder;
/**
* @brief Transaction: AMMClawback
*
* Type: ttAMM_CLAWBACK (31)
* Delegable: Delegation::delegable
* Amendment: featureAMMClawback
* Privileges: mayDeleteAcct | overrideFreeze
*
* Immutable wrapper around STTx providing type-safe field access.
* Use AMMClawbackBuilder to construct new transactions.
*/
class AMMClawback : public TransactionBase
{
public:
static constexpr xrpl::TxType txType = ttAMM_CLAWBACK;
/**
* @brief Construct a AMMClawback transaction wrapper from an existing STTx object.
* @throws std::runtime_error if the transaction type doesn't match.
*/
explicit AMMClawback(std::shared_ptr<STTx const> tx)
: TransactionBase(std::move(tx))
{
// Verify transaction type
if (tx_->getTxnType() != txType)
{
throw std::runtime_error("Invalid transaction type for AMMClawback");
}
}
// Transaction-specific field getters
/**
* @brief Get sfHolder (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getHolder() const
{
return this->tx_->at(sfHolder);
}
/**
* @brief Get sfAsset (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ISSUE::type::value_type
getAsset() const
{
return this->tx_->at(sfAsset);
}
/**
* @brief Get sfAsset2 (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ISSUE::type::value_type
getAsset2() const
{
return this->tx_->at(sfAsset2);
}
/**
* @brief Get sfAmount (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_AMOUNT::type::value_type>
getAmount() const
{
if (hasAmount())
{
return this->tx_->at(sfAmount);
}
return std::nullopt;
}
/**
* @brief Check if sfAmount is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasAmount() const
{
return this->tx_->isFieldPresent(sfAmount);
}
};
/**
* @brief Builder for AMMClawback transactions.
*
* Provides a fluent interface for constructing transactions with method chaining.
* Uses Json::Value internally for flexible transaction construction.
* Inherits common field setters from TransactionBuilderBase.
*/
class AMMClawbackBuilder : public TransactionBuilderBase<AMMClawbackBuilder>
{
public:
/**
* @brief Construct a new AMMClawbackBuilder with required fields.
* @param account The account initiating the transaction.
* @param holder The sfHolder field value.
* @param asset The sfAsset field value.
* @param asset2 The sfAsset2 field value.
* @param sequence Optional sequence number for the transaction.
* @param fee Optional fee for the transaction.
*/
AMMClawbackBuilder(SF_ACCOUNT::type::value_type account,
std::decay_t<typename SF_ACCOUNT::type::value_type> const& holder, std::decay_t<typename SF_ISSUE::type::value_type> const& asset, std::decay_t<typename SF_ISSUE::type::value_type> const& asset2, std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
)
: TransactionBuilderBase<AMMClawbackBuilder>(ttAMM_CLAWBACK, account, sequence, fee)
{
setHolder(holder);
setAsset(asset);
setAsset2(asset2);
}
/**
* @brief Construct a AMMClawbackBuilder from an existing STTx object.
* @param tx The existing transaction to copy from.
* @throws std::runtime_error if the transaction type doesn't match.
*/
AMMClawbackBuilder(std::shared_ptr<STTx const> tx)
{
if (tx->getTxnType() != ttAMM_CLAWBACK)
{
throw std::runtime_error("Invalid transaction type for AMMClawbackBuilder");
}
object_ = *tx;
}
/** @brief Transaction-specific field setters */
/**
* @brief Set sfHolder (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AMMClawbackBuilder&
setHolder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfHolder] = value;
return *this;
}
/**
* @brief Set sfAsset (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AMMClawbackBuilder&
setAsset(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
{
object_[sfAsset] = STIssue(sfAsset, value);
return *this;
}
/**
* @brief Set sfAsset2 (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AMMClawbackBuilder&
setAsset2(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
{
object_[sfAsset2] = STIssue(sfAsset2, value);
return *this;
}
/**
* @brief Set sfAmount (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AMMClawbackBuilder&
setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfAmount] = value;
return *this;
}
/**
* @brief Build and return the AMMClawback wrapper.
* @param publicKey The public key for signing.
* @param secretKey The secret key for signing.
* @return The constructed transaction wrapper.
*/
AMMClawback
build(PublicKey const& publicKey, SecretKey const& secretKey)
{
sign(publicKey, secretKey);
return AMMClawback{std::make_shared<STTx>(std::move(object_))};
}
};
} // namespace xrpl::transactions

177
include/xrpl/protocol_autogen/transactions/AMMCreate.h Normal file
View File

@@ -0,0 +1,177 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/TransactionBase.h>
#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::transactions {
class AMMCreateBuilder;
/**
* @brief Transaction: AMMCreate
*
* Type: ttAMM_CREATE (35)
* Delegable: Delegation::delegable
* Amendment: featureAMM
* Privileges: createPseudoAcct
*
* Immutable wrapper around STTx providing type-safe field access.
* Use AMMCreateBuilder to construct new transactions.
*/
class AMMCreate : public TransactionBase
{
public:
static constexpr xrpl::TxType txType = ttAMM_CREATE;
/**
* @brief Construct a AMMCreate transaction wrapper from an existing STTx object.
* @throws std::runtime_error if the transaction type doesn't match.
*/
explicit AMMCreate(std::shared_ptr<STTx const> tx)
: TransactionBase(std::move(tx))
{
// Verify transaction type
if (tx_->getTxnType() != txType)
{
throw std::runtime_error("Invalid transaction type for AMMCreate");
}
}
// Transaction-specific field getters
/**
* @brief Get sfAmount (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_AMOUNT::type::value_type
getAmount() const
{
return this->tx_->at(sfAmount);
}
/**
* @brief Get sfAmount2 (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_AMOUNT::type::value_type
getAmount2() const
{
return this->tx_->at(sfAmount2);
}
/**
* @brief Get sfTradingFee (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT16::type::value_type
getTradingFee() const
{
return this->tx_->at(sfTradingFee);
}
};
/**
* @brief Builder for AMMCreate transactions.
*
* Provides a fluent interface for constructing transactions with method chaining.
* Uses Json::Value internally for flexible transaction construction.
* Inherits common field setters from TransactionBuilderBase.
*/
class AMMCreateBuilder : public TransactionBuilderBase<AMMCreateBuilder>
{
public:
/**
* @brief Construct a new AMMCreateBuilder with required fields.
* @param account The account initiating the transaction.
* @param amount The sfAmount field value.
* @param amount2 The sfAmount2 field value.
* @param tradingFee The sfTradingFee field value.
* @param sequence Optional sequence number for the transaction.
* @param fee Optional fee for the transaction.
*/
AMMCreateBuilder(SF_ACCOUNT::type::value_type account,
std::decay_t<typename SF_AMOUNT::type::value_type> const& amount, std::decay_t<typename SF_AMOUNT::type::value_type> const& amount2, std::decay_t<typename SF_UINT16::type::value_type> const& tradingFee, std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
)
: TransactionBuilderBase<AMMCreateBuilder>(ttAMM_CREATE, account, sequence, fee)
{
setAmount(amount);
setAmount2(amount2);
setTradingFee(tradingFee);
}
/**
* @brief Construct a AMMCreateBuilder from an existing STTx object.
* @param tx The existing transaction to copy from.
* @throws std::runtime_error if the transaction type doesn't match.
*/
AMMCreateBuilder(std::shared_ptr<STTx const> tx)
{
if (tx->getTxnType() != ttAMM_CREATE)
{
throw std::runtime_error("Invalid transaction type for AMMCreateBuilder");
}
object_ = *tx;
}
/** @brief Transaction-specific field setters */
/**
* @brief Set sfAmount (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AMMCreateBuilder&
setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfAmount] = value;
return *this;
}
/**
* @brief Set sfAmount2 (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AMMCreateBuilder&
setAmount2(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfAmount2] = value;
return *this;
}
/**
* @brief Set sfTradingFee (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AMMCreateBuilder&
setTradingFee(std::decay_t<typename SF_UINT16::type::value_type> const& value)
{
object_[sfTradingFee] = value;
return *this;
}
/**
* @brief Build and return the AMMCreate wrapper.
* @param publicKey The public key for signing.
* @param secretKey The secret key for signing.
* @return The constructed transaction wrapper.
*/
AMMCreate
build(PublicKey const& publicKey, SecretKey const& secretKey)
{
sign(publicKey, secretKey);
return AMMCreate{std::make_shared<STTx>(std::move(object_))};
}
};
} // namespace xrpl::transactions

153
include/xrpl/protocol_autogen/transactions/AMMDelete.h Normal file
View File

@@ -0,0 +1,153 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/TransactionBase.h>
#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::transactions {
class AMMDeleteBuilder;
/**
* @brief Transaction: AMMDelete
*
* Type: ttAMM_DELETE (40)
* Delegable: Delegation::delegable
* Amendment: featureAMM
* Privileges: mustDeleteAcct
*
* Immutable wrapper around STTx providing type-safe field access.
* Use AMMDeleteBuilder to construct new transactions.
*/
class AMMDelete : public TransactionBase
{
public:
static constexpr xrpl::TxType txType = ttAMM_DELETE;
/**
* @brief Construct a AMMDelete transaction wrapper from an existing STTx object.
* @throws std::runtime_error if the transaction type doesn't match.
*/
explicit AMMDelete(std::shared_ptr<STTx const> tx)
: TransactionBase(std::move(tx))
{
// Verify transaction type
if (tx_->getTxnType() != txType)
{
throw std::runtime_error("Invalid transaction type for AMMDelete");
}
}
// Transaction-specific field getters
/**
* @brief Get sfAsset (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ISSUE::type::value_type
getAsset() const
{
return this->tx_->at(sfAsset);
}
/**
* @brief Get sfAsset2 (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ISSUE::type::value_type
getAsset2() const
{
return this->tx_->at(sfAsset2);
}
};
/**
* @brief Builder for AMMDelete transactions.
*
* Provides a fluent interface for constructing transactions with method chaining.
* Uses Json::Value internally for flexible transaction construction.
* Inherits common field setters from TransactionBuilderBase.
*/
class AMMDeleteBuilder : public TransactionBuilderBase<AMMDeleteBuilder>
{
public:
/**
* @brief Construct a new AMMDeleteBuilder with required fields.
* @param account The account initiating the transaction.
* @param asset The sfAsset field value.
* @param asset2 The sfAsset2 field value.
* @param sequence Optional sequence number for the transaction.
* @param fee Optional fee for the transaction.
*/
AMMDeleteBuilder(SF_ACCOUNT::type::value_type account,
std::decay_t<typename SF_ISSUE::type::value_type> const& asset, std::decay_t<typename SF_ISSUE::type::value_type> const& asset2, std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
)
: TransactionBuilderBase<AMMDeleteBuilder>(ttAMM_DELETE, account, sequence, fee)
{
setAsset(asset);
setAsset2(asset2);
}
/**
* @brief Construct a AMMDeleteBuilder from an existing STTx object.
* @param tx The existing transaction to copy from.
* @throws std::runtime_error if the transaction type doesn't match.
*/
AMMDeleteBuilder(std::shared_ptr<STTx const> tx)
{
if (tx->getTxnType() != ttAMM_DELETE)
{
throw std::runtime_error("Invalid transaction type for AMMDeleteBuilder");
}
object_ = *tx;
}
/** @brief Transaction-specific field setters */
/**
* @brief Set sfAsset (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AMMDeleteBuilder&
setAsset(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
{
object_[sfAsset] = STIssue(sfAsset, value);
return *this;
}
/**
* @brief Set sfAsset2 (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AMMDeleteBuilder&
setAsset2(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
{
object_[sfAsset2] = STIssue(sfAsset2, value);
return *this;
}
/**
* @brief Build and return the AMMDelete wrapper.
* @param publicKey The public key for signing.
* @param secretKey The secret key for signing.
* @return The constructed transaction wrapper.
*/
AMMDelete
build(PublicKey const& publicKey, SecretKey const& secretKey)
{
sign(publicKey, secretKey);
return AMMDelete{std::make_shared<STTx>(std::move(object_))};
}
};
} // namespace xrpl::transactions

338
include/xrpl/protocol_autogen/transactions/AMMDeposit.h Normal file
View File

@@ -0,0 +1,338 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/TransactionBase.h>
#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::transactions {
class AMMDepositBuilder;
/**
* @brief Transaction: AMMDeposit
*
* Type: ttAMM_DEPOSIT (36)
* Delegable: Delegation::delegable
* Amendment: featureAMM
* Privileges: noPriv
*
* Immutable wrapper around STTx providing type-safe field access.
* Use AMMDepositBuilder to construct new transactions.
*/
class AMMDeposit : public TransactionBase
{
public:
static constexpr xrpl::TxType txType = ttAMM_DEPOSIT;
/**
* @brief Construct a AMMDeposit transaction wrapper from an existing STTx object.
* @throws std::runtime_error if the transaction type doesn't match.
*/
explicit AMMDeposit(std::shared_ptr<STTx const> tx)
: TransactionBase(std::move(tx))
{
// Verify transaction type
if (tx_->getTxnType() != txType)
{
throw std::runtime_error("Invalid transaction type for AMMDeposit");
}
}
// Transaction-specific field getters
/**
* @brief Get sfAsset (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ISSUE::type::value_type
getAsset() const
{
return this->tx_->at(sfAsset);
}
/**
* @brief Get sfAsset2 (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ISSUE::type::value_type
getAsset2() const
{
return this->tx_->at(sfAsset2);
}
/**
* @brief Get sfAmount (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_AMOUNT::type::value_type>
getAmount() const
{
if (hasAmount())
{
return this->tx_->at(sfAmount);
}
return std::nullopt;
}
/**
* @brief Check if sfAmount is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasAmount() const
{
return this->tx_->isFieldPresent(sfAmount);
}
/**
* @brief Get sfAmount2 (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_AMOUNT::type::value_type>
getAmount2() const
{
if (hasAmount2())
{
return this->tx_->at(sfAmount2);
}
return std::nullopt;
}
/**
* @brief Check if sfAmount2 is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasAmount2() const
{
return this->tx_->isFieldPresent(sfAmount2);
}
/**
* @brief Get sfEPrice (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_AMOUNT::type::value_type>
getEPrice() const
{
if (hasEPrice())
{
return this->tx_->at(sfEPrice);
}
return std::nullopt;
}
/**
* @brief Check if sfEPrice is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasEPrice() const
{
return this->tx_->isFieldPresent(sfEPrice);
}
/**
* @brief Get sfLPTokenOut (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_AMOUNT::type::value_type>
getLPTokenOut() const
{
if (hasLPTokenOut())
{
return this->tx_->at(sfLPTokenOut);
}
return std::nullopt;
}
/**
* @brief Check if sfLPTokenOut is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasLPTokenOut() const
{
return this->tx_->isFieldPresent(sfLPTokenOut);
}
/**
* @brief Get sfTradingFee (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT16::type::value_type>
getTradingFee() const
{
if (hasTradingFee())
{
return this->tx_->at(sfTradingFee);
}
return std::nullopt;
}
/**
* @brief Check if sfTradingFee is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasTradingFee() const
{
return this->tx_->isFieldPresent(sfTradingFee);
}
};
/**
* @brief Builder for AMMDeposit transactions.
*
* Provides a fluent interface for constructing transactions with method chaining.
* Uses Json::Value internally for flexible transaction construction.
* Inherits common field setters from TransactionBuilderBase.
*/
class AMMDepositBuilder : public TransactionBuilderBase<AMMDepositBuilder>
{
public:
/**
* @brief Construct a new AMMDepositBuilder with required fields.
* @param account The account initiating the transaction.
* @param asset The sfAsset field value.
* @param asset2 The sfAsset2 field value.
* @param sequence Optional sequence number for the transaction.
* @param fee Optional fee for the transaction.
*/
AMMDepositBuilder(SF_ACCOUNT::type::value_type account,
std::decay_t<typename SF_ISSUE::type::value_type> const& asset, std::decay_t<typename SF_ISSUE::type::value_type> const& asset2, std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
)
: TransactionBuilderBase<AMMDepositBuilder>(ttAMM_DEPOSIT, account, sequence, fee)
{
setAsset(asset);
setAsset2(asset2);
}
/**
* @brief Construct a AMMDepositBuilder from an existing STTx object.
* @param tx The existing transaction to copy from.
* @throws std::runtime_error if the transaction type doesn't match.
*/
AMMDepositBuilder(std::shared_ptr<STTx const> tx)
{
if (tx->getTxnType() != ttAMM_DEPOSIT)
{
throw std::runtime_error("Invalid transaction type for AMMDepositBuilder");
}
object_ = *tx;
}
/** @brief Transaction-specific field setters */
/**
* @brief Set sfAsset (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AMMDepositBuilder&
setAsset(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
{
object_[sfAsset] = STIssue(sfAsset, value);
return *this;
}
/**
* @brief Set sfAsset2 (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AMMDepositBuilder&
setAsset2(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
{
object_[sfAsset2] = STIssue(sfAsset2, value);
return *this;
}
/**
* @brief Set sfAmount (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AMMDepositBuilder&
setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfAmount] = value;
return *this;
}
/**
* @brief Set sfAmount2 (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AMMDepositBuilder&
setAmount2(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfAmount2] = value;
return *this;
}
/**
* @brief Set sfEPrice (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AMMDepositBuilder&
setEPrice(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfEPrice] = value;
return *this;
}
/**
* @brief Set sfLPTokenOut (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AMMDepositBuilder&
setLPTokenOut(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfLPTokenOut] = value;
return *this;
}
/**
* @brief Set sfTradingFee (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AMMDepositBuilder&
setTradingFee(std::decay_t<typename SF_UINT16::type::value_type> const& value)
{
object_[sfTradingFee] = value;
return *this;
}
/**
* @brief Build and return the AMMDeposit wrapper.
* @param publicKey The public key for signing.
* @param secretKey The secret key for signing.
* @return The constructed transaction wrapper.
*/
AMMDeposit
build(PublicKey const& publicKey, SecretKey const& secretKey)
{
sign(publicKey, secretKey);
return AMMDeposit{std::make_shared<STTx>(std::move(object_))};
}
};
} // namespace xrpl::transactions

177
include/xrpl/protocol_autogen/transactions/AMMVote.h Normal file
View File

@@ -0,0 +1,177 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/TransactionBase.h>
#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::transactions {
class AMMVoteBuilder;
/**
* @brief Transaction: AMMVote
*
* Type: ttAMM_VOTE (38)
* Delegable: Delegation::delegable
* Amendment: featureAMM
* Privileges: noPriv
*
* Immutable wrapper around STTx providing type-safe field access.
* Use AMMVoteBuilder to construct new transactions.
*/
class AMMVote : public TransactionBase
{
public:
static constexpr xrpl::TxType txType = ttAMM_VOTE;
/**
* @brief Construct a AMMVote transaction wrapper from an existing STTx object.
* @throws std::runtime_error if the transaction type doesn't match.
*/
explicit AMMVote(std::shared_ptr<STTx const> tx)
: TransactionBase(std::move(tx))
{
// Verify transaction type
if (tx_->getTxnType() != txType)
{
throw std::runtime_error("Invalid transaction type for AMMVote");
}
}
// Transaction-specific field getters
/**
* @brief Get sfAsset (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ISSUE::type::value_type
getAsset() const
{
return this->tx_->at(sfAsset);
}
/**
* @brief Get sfAsset2 (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ISSUE::type::value_type
getAsset2() const
{
return this->tx_->at(sfAsset2);
}
/**
* @brief Get sfTradingFee (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT16::type::value_type
getTradingFee() const
{
return this->tx_->at(sfTradingFee);
}
};
/**
* @brief Builder for AMMVote transactions.
*
* Provides a fluent interface for constructing transactions with method chaining.
* Uses Json::Value internally for flexible transaction construction.
* Inherits common field setters from TransactionBuilderBase.
*/
class AMMVoteBuilder : public TransactionBuilderBase<AMMVoteBuilder>
{
public:
/**
* @brief Construct a new AMMVoteBuilder with required fields.
* @param account The account initiating the transaction.
* @param asset The sfAsset field value.
* @param asset2 The sfAsset2 field value.
* @param tradingFee The sfTradingFee field value.
* @param sequence Optional sequence number for the transaction.
* @param fee Optional fee for the transaction.
*/
AMMVoteBuilder(SF_ACCOUNT::type::value_type account,
std::decay_t<typename SF_ISSUE::type::value_type> const& asset, std::decay_t<typename SF_ISSUE::type::value_type> const& asset2, std::decay_t<typename SF_UINT16::type::value_type> const& tradingFee, std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
)
: TransactionBuilderBase<AMMVoteBuilder>(ttAMM_VOTE, account, sequence, fee)
{
setAsset(asset);
setAsset2(asset2);
setTradingFee(tradingFee);
}
/**
* @brief Construct a AMMVoteBuilder from an existing STTx object.
* @param tx The existing transaction to copy from.
* @throws std::runtime_error if the transaction type doesn't match.
*/
AMMVoteBuilder(std::shared_ptr<STTx const> tx)
{
if (tx->getTxnType() != ttAMM_VOTE)
{
throw std::runtime_error("Invalid transaction type for AMMVoteBuilder");
}
object_ = *tx;
}
/** @brief Transaction-specific field setters */
/**
* @brief Set sfAsset (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AMMVoteBuilder&
setAsset(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
{
object_[sfAsset] = STIssue(sfAsset, value);
return *this;
}
/**
* @brief Set sfAsset2 (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AMMVoteBuilder&
setAsset2(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
{
object_[sfAsset2] = STIssue(sfAsset2, value);
return *this;
}
/**
* @brief Set sfTradingFee (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AMMVoteBuilder&
setTradingFee(std::decay_t<typename SF_UINT16::type::value_type> const& value)
{
object_[sfTradingFee] = value;
return *this;
}
/**
* @brief Build and return the AMMVote wrapper.
* @param publicKey The public key for signing.
* @param secretKey The secret key for signing.
* @return The constructed transaction wrapper.
*/
AMMVote
build(PublicKey const& publicKey, SecretKey const& secretKey)
{
sign(publicKey, secretKey);
return AMMVote{std::make_shared<STTx>(std::move(object_))};
}
};
} // namespace xrpl::transactions

301
include/xrpl/protocol_autogen/transactions/AMMWithdraw.h Normal file
View File

@@ -0,0 +1,301 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/TransactionBase.h>
#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::transactions {
class AMMWithdrawBuilder;
/**
* @brief Transaction: AMMWithdraw
*
* Type: ttAMM_WITHDRAW (37)
* Delegable: Delegation::delegable
* Amendment: featureAMM
* Privileges: mayDeleteAcct
*
* Immutable wrapper around STTx providing type-safe field access.
* Use AMMWithdrawBuilder to construct new transactions.
*/
class AMMWithdraw : public TransactionBase
{
public:
static constexpr xrpl::TxType txType = ttAMM_WITHDRAW;
/**
* @brief Construct a AMMWithdraw transaction wrapper from an existing STTx object.
* @throws std::runtime_error if the transaction type doesn't match.
*/
explicit AMMWithdraw(std::shared_ptr<STTx const> tx)
: TransactionBase(std::move(tx))
{
// Verify transaction type
if (tx_->getTxnType() != txType)
{
throw std::runtime_error("Invalid transaction type for AMMWithdraw");
}
}
// Transaction-specific field getters
/**
* @brief Get sfAsset (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ISSUE::type::value_type
getAsset() const
{
return this->tx_->at(sfAsset);
}
/**
* @brief Get sfAsset2 (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ISSUE::type::value_type
getAsset2() const
{
return this->tx_->at(sfAsset2);
}
/**
* @brief Get sfAmount (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_AMOUNT::type::value_type>
getAmount() const
{
if (hasAmount())
{
return this->tx_->at(sfAmount);
}
return std::nullopt;
}
/**
* @brief Check if sfAmount is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasAmount() const
{
return this->tx_->isFieldPresent(sfAmount);
}
/**
* @brief Get sfAmount2 (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_AMOUNT::type::value_type>
getAmount2() const
{
if (hasAmount2())
{
return this->tx_->at(sfAmount2);
}
return std::nullopt;
}
/**
* @brief Check if sfAmount2 is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasAmount2() const
{
return this->tx_->isFieldPresent(sfAmount2);
}
/**
* @brief Get sfEPrice (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_AMOUNT::type::value_type>
getEPrice() const
{
if (hasEPrice())
{
return this->tx_->at(sfEPrice);
}
return std::nullopt;
}
/**
* @brief Check if sfEPrice is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasEPrice() const
{
return this->tx_->isFieldPresent(sfEPrice);
}
/**
* @brief Get sfLPTokenIn (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_AMOUNT::type::value_type>
getLPTokenIn() const
{
if (hasLPTokenIn())
{
return this->tx_->at(sfLPTokenIn);
}
return std::nullopt;
}
/**
* @brief Check if sfLPTokenIn is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasLPTokenIn() const
{
return this->tx_->isFieldPresent(sfLPTokenIn);
}
};
/**
* @brief Builder for AMMWithdraw transactions.
*
* Provides a fluent interface for constructing transactions with method chaining.
* Uses Json::Value internally for flexible transaction construction.
* Inherits common field setters from TransactionBuilderBase.
*/
class AMMWithdrawBuilder : public TransactionBuilderBase<AMMWithdrawBuilder>
{
public:
/**
* @brief Construct a new AMMWithdrawBuilder with required fields.
* @param account The account initiating the transaction.
* @param asset The sfAsset field value.
* @param asset2 The sfAsset2 field value.
* @param sequence Optional sequence number for the transaction.
* @param fee Optional fee for the transaction.
*/
AMMWithdrawBuilder(SF_ACCOUNT::type::value_type account,
std::decay_t<typename SF_ISSUE::type::value_type> const& asset, std::decay_t<typename SF_ISSUE::type::value_type> const& asset2, std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
)
: TransactionBuilderBase<AMMWithdrawBuilder>(ttAMM_WITHDRAW, account, sequence, fee)
{
setAsset(asset);
setAsset2(asset2);
}
/**
* @brief Construct a AMMWithdrawBuilder from an existing STTx object.
* @param tx The existing transaction to copy from.
* @throws std::runtime_error if the transaction type doesn't match.
*/
AMMWithdrawBuilder(std::shared_ptr<STTx const> tx)
{
if (tx->getTxnType() != ttAMM_WITHDRAW)
{
throw std::runtime_error("Invalid transaction type for AMMWithdrawBuilder");
}
object_ = *tx;
}
/** @brief Transaction-specific field setters */
/**
* @brief Set sfAsset (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AMMWithdrawBuilder&
setAsset(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
{
object_[sfAsset] = STIssue(sfAsset, value);
return *this;
}
/**
* @brief Set sfAsset2 (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AMMWithdrawBuilder&
setAsset2(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
{
object_[sfAsset2] = STIssue(sfAsset2, value);
return *this;
}
/**
* @brief Set sfAmount (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AMMWithdrawBuilder&
setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfAmount] = value;
return *this;
}
/**
* @brief Set sfAmount2 (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AMMWithdrawBuilder&
setAmount2(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfAmount2] = value;
return *this;
}
/**
* @brief Set sfEPrice (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AMMWithdrawBuilder&
setEPrice(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfEPrice] = value;
return *this;
}
/**
* @brief Set sfLPTokenIn (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AMMWithdrawBuilder&
setLPTokenIn(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfLPTokenIn] = value;
return *this;
}
/**
* @brief Build and return the AMMWithdraw wrapper.
* @param publicKey The public key for signing.
* @param secretKey The secret key for signing.
* @return The constructed transaction wrapper.
*/
AMMWithdraw
build(PublicKey const& publicKey, SecretKey const& secretKey)
{
sign(publicKey, secretKey);
return AMMWithdraw{std::make_shared<STTx>(std::move(object_))};
}
};
} // namespace xrpl::transactions

203
include/xrpl/protocol_autogen/transactions/AccountDelete.h Normal file
View File

@@ -0,0 +1,203 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/TransactionBase.h>
#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::transactions {
class AccountDeleteBuilder;
/**
* @brief Transaction: AccountDelete
*
* Type: ttACCOUNT_DELETE (21)
* Delegable: Delegation::notDelegable
* Amendment: uint256{}
* Privileges: mustDeleteAcct
*
* Immutable wrapper around STTx providing type-safe field access.
* Use AccountDeleteBuilder to construct new transactions.
*/
class AccountDelete : public TransactionBase
{
public:
static constexpr xrpl::TxType txType = ttACCOUNT_DELETE;
/**
* @brief Construct a AccountDelete transaction wrapper from an existing STTx object.
* @throws std::runtime_error if the transaction type doesn't match.
*/
explicit AccountDelete(std::shared_ptr<STTx const> tx)
: TransactionBase(std::move(tx))
{
// Verify transaction type
if (tx_->getTxnType() != txType)
{
throw std::runtime_error("Invalid transaction type for AccountDelete");
}
}
// Transaction-specific field getters
/**
* @brief Get sfDestination (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getDestination() const
{
return this->tx_->at(sfDestination);
}
/**
* @brief Get sfDestinationTag (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getDestinationTag() const
{
if (hasDestinationTag())
{
return this->tx_->at(sfDestinationTag);
}
return std::nullopt;
}
/**
* @brief Check if sfDestinationTag is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasDestinationTag() const
{
return this->tx_->isFieldPresent(sfDestinationTag);
}
/**
* @brief Get sfCredentialIDs (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_VECTOR256::type::value_type>
getCredentialIDs() const
{
if (hasCredentialIDs())
{
return this->tx_->at(sfCredentialIDs);
}
return std::nullopt;
}
/**
* @brief Check if sfCredentialIDs is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasCredentialIDs() const
{
return this->tx_->isFieldPresent(sfCredentialIDs);
}
};
/**
* @brief Builder for AccountDelete transactions.
*
* Provides a fluent interface for constructing transactions with method chaining.
* Uses Json::Value internally for flexible transaction construction.
* Inherits common field setters from TransactionBuilderBase.
*/
class AccountDeleteBuilder : public TransactionBuilderBase<AccountDeleteBuilder>
{
public:
/**
* @brief Construct a new AccountDeleteBuilder with required fields.
* @param account The account initiating the transaction.
* @param destination The sfDestination field value.
* @param sequence Optional sequence number for the transaction.
* @param fee Optional fee for the transaction.
*/
AccountDeleteBuilder(SF_ACCOUNT::type::value_type account,
std::decay_t<typename SF_ACCOUNT::type::value_type> const& destination, std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
)
: TransactionBuilderBase<AccountDeleteBuilder>(ttACCOUNT_DELETE, account, sequence, fee)
{
setDestination(destination);
}
/**
* @brief Construct a AccountDeleteBuilder from an existing STTx object.
* @param tx The existing transaction to copy from.
* @throws std::runtime_error if the transaction type doesn't match.
*/
AccountDeleteBuilder(std::shared_ptr<STTx const> tx)
{
if (tx->getTxnType() != ttACCOUNT_DELETE)
{
throw std::runtime_error("Invalid transaction type for AccountDeleteBuilder");
}
object_ = *tx;
}
/** @brief Transaction-specific field setters */
/**
* @brief Set sfDestination (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
AccountDeleteBuilder&
setDestination(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfDestination] = value;
return *this;
}
/**
* @brief Set sfDestinationTag (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountDeleteBuilder&
setDestinationTag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfDestinationTag] = value;
return *this;
}
/**
* @brief Set sfCredentialIDs (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountDeleteBuilder&
setCredentialIDs(std::decay_t<typename SF_VECTOR256::type::value_type> const& value)
{
object_[sfCredentialIDs] = value;
return *this;
}
/**
* @brief Build and return the AccountDelete wrapper.
* @param publicKey The public key for signing.
* @param secretKey The secret key for signing.
* @return The constructed transaction wrapper.
*/
AccountDelete
build(PublicKey const& publicKey, SecretKey const& secretKey)
{
sign(publicKey, secretKey);
return AccountDelete{std::make_shared<STTx>(std::move(object_))};
}
};
} // namespace xrpl::transactions

475
include/xrpl/protocol_autogen/transactions/AccountSet.h Normal file
View File

@@ -0,0 +1,475 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/TransactionBase.h>
#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::transactions {
class AccountSetBuilder;
/**
* @brief Transaction: AccountSet
*
* Type: ttACCOUNT_SET (3)
* Delegable: Delegation::notDelegable
* Amendment: uint256{}
* Privileges: noPriv
*
* Immutable wrapper around STTx providing type-safe field access.
* Use AccountSetBuilder to construct new transactions.
*/
class AccountSet : public TransactionBase
{
public:
static constexpr xrpl::TxType txType = ttACCOUNT_SET;
/**
* @brief Construct a AccountSet transaction wrapper from an existing STTx object.
* @throws std::runtime_error if the transaction type doesn't match.
*/
explicit AccountSet(std::shared_ptr<STTx const> tx)
: TransactionBase(std::move(tx))
{
// Verify transaction type
if (tx_->getTxnType() != txType)
{
throw std::runtime_error("Invalid transaction type for AccountSet");
}
}
// Transaction-specific field getters
/**
* @brief Get sfEmailHash (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT128::type::value_type>
getEmailHash() const
{
if (hasEmailHash())
{
return this->tx_->at(sfEmailHash);
}
return std::nullopt;
}
/**
* @brief Check if sfEmailHash is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasEmailHash() const
{
return this->tx_->isFieldPresent(sfEmailHash);
}
/**
* @brief Get sfWalletLocator (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT256::type::value_type>
getWalletLocator() const
{
if (hasWalletLocator())
{
return this->tx_->at(sfWalletLocator);
}
return std::nullopt;
}
/**
* @brief Check if sfWalletLocator is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasWalletLocator() const
{
return this->tx_->isFieldPresent(sfWalletLocator);
}
/**
* @brief Get sfWalletSize (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getWalletSize() const
{
if (hasWalletSize())
{
return this->tx_->at(sfWalletSize);
}
return std::nullopt;
}
/**
* @brief Check if sfWalletSize is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasWalletSize() const
{
return this->tx_->isFieldPresent(sfWalletSize);
}
/**
* @brief Get sfMessageKey (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_VL::type::value_type>
getMessageKey() const
{
if (hasMessageKey())
{
return this->tx_->at(sfMessageKey);
}
return std::nullopt;
}
/**
* @brief Check if sfMessageKey is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasMessageKey() const
{
return this->tx_->isFieldPresent(sfMessageKey);
}
/**
* @brief Get sfDomain (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_VL::type::value_type>
getDomain() const
{
if (hasDomain())
{
return this->tx_->at(sfDomain);
}
return std::nullopt;
}
/**
* @brief Check if sfDomain is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasDomain() const
{
return this->tx_->isFieldPresent(sfDomain);
}
/**
* @brief Get sfTransferRate (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getTransferRate() const
{
if (hasTransferRate())
{
return this->tx_->at(sfTransferRate);
}
return std::nullopt;
}
/**
* @brief Check if sfTransferRate is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasTransferRate() const
{
return this->tx_->isFieldPresent(sfTransferRate);
}
/**
* @brief Get sfSetFlag (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getSetFlag() const
{
if (hasSetFlag())
{
return this->tx_->at(sfSetFlag);
}
return std::nullopt;
}
/**
* @brief Check if sfSetFlag is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasSetFlag() const
{
return this->tx_->isFieldPresent(sfSetFlag);
}
/**
* @brief Get sfClearFlag (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getClearFlag() const
{
if (hasClearFlag())
{
return this->tx_->at(sfClearFlag);
}
return std::nullopt;
}
/**
* @brief Check if sfClearFlag is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasClearFlag() const
{
return this->tx_->isFieldPresent(sfClearFlag);
}
/**
* @brief Get sfTickSize (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT8::type::value_type>
getTickSize() const
{
if (hasTickSize())
{
return this->tx_->at(sfTickSize);
}
return std::nullopt;
}
/**
* @brief Check if sfTickSize is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasTickSize() const
{
return this->tx_->isFieldPresent(sfTickSize);
}
/**
* @brief Get sfNFTokenMinter (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
getNFTokenMinter() const
{
if (hasNFTokenMinter())
{
return this->tx_->at(sfNFTokenMinter);
}
return std::nullopt;
}
/**
* @brief Check if sfNFTokenMinter is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasNFTokenMinter() const
{
return this->tx_->isFieldPresent(sfNFTokenMinter);
}
};
/**
* @brief Builder for AccountSet transactions.
*
* Provides a fluent interface for constructing transactions with method chaining.
* Uses Json::Value internally for flexible transaction construction.
* Inherits common field setters from TransactionBuilderBase.
*/
class AccountSetBuilder : public TransactionBuilderBase<AccountSetBuilder>
{
public:
/**
* @brief Construct a new AccountSetBuilder with required fields.
* @param account The account initiating the transaction.
* @param sequence Optional sequence number for the transaction.
* @param fee Optional fee for the transaction.
*/
AccountSetBuilder(SF_ACCOUNT::type::value_type account,
std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
)
: TransactionBuilderBase<AccountSetBuilder>(ttACCOUNT_SET, account, sequence, fee)
{
}
/**
* @brief Construct a AccountSetBuilder from an existing STTx object.
* @param tx The existing transaction to copy from.
* @throws std::runtime_error if the transaction type doesn't match.
*/
AccountSetBuilder(std::shared_ptr<STTx const> tx)
{
if (tx->getTxnType() != ttACCOUNT_SET)
{
throw std::runtime_error("Invalid transaction type for AccountSetBuilder");
}
object_ = *tx;
}
/** @brief Transaction-specific field setters */
/**
* @brief Set sfEmailHash (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountSetBuilder&
setEmailHash(std::decay_t<typename SF_UINT128::type::value_type> const& value)
{
object_[sfEmailHash] = value;
return *this;
}
/**
* @brief Set sfWalletLocator (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountSetBuilder&
setWalletLocator(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfWalletLocator] = value;
return *this;
}
/**
* @brief Set sfWalletSize (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountSetBuilder&
setWalletSize(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfWalletSize] = value;
return *this;
}
/**
* @brief Set sfMessageKey (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountSetBuilder&
setMessageKey(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfMessageKey] = value;
return *this;
}
/**
* @brief Set sfDomain (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountSetBuilder&
setDomain(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfDomain] = value;
return *this;
}
/**
* @brief Set sfTransferRate (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountSetBuilder&
setTransferRate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfTransferRate] = value;
return *this;
}
/**
* @brief Set sfSetFlag (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountSetBuilder&
setSetFlag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfSetFlag] = value;
return *this;
}
/**
* @brief Set sfClearFlag (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountSetBuilder&
setClearFlag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfClearFlag] = value;
return *this;
}
/**
* @brief Set sfTickSize (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountSetBuilder&
setTickSize(std::decay_t<typename SF_UINT8::type::value_type> const& value)
{
object_[sfTickSize] = value;
return *this;
}
/**
* @brief Set sfNFTokenMinter (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
AccountSetBuilder&
setNFTokenMinter(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfNFTokenMinter] = value;
return *this;
}
/**
* @brief Build and return the AccountSet wrapper.
* @param publicKey The public key for signing.
* @param secretKey The secret key for signing.
* @return The constructed transaction wrapper.
*/
AccountSet
build(PublicKey const& publicKey, SecretKey const& secretKey)
{
sign(publicKey, secretKey);
return AccountSet{std::make_shared<STTx>(std::move(object_))};
}
};
} // namespace xrpl::transactions

164
include/xrpl/protocol_autogen/transactions/Batch.h Normal file
View File

@@ -0,0 +1,164 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/TransactionBase.h>
#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::transactions {
class BatchBuilder;
/**
* @brief Transaction: Batch
*
* Type: ttBATCH (71)
* Delegable: Delegation::notDelegable
* Amendment: featureBatch
* Privileges: noPriv
*
* Immutable wrapper around STTx providing type-safe field access.
* Use BatchBuilder to construct new transactions.
*/
class Batch : public TransactionBase
{
public:
static constexpr xrpl::TxType txType = ttBATCH;
/**
* @brief Construct a Batch transaction wrapper from an existing STTx object.
* @throws std::runtime_error if the transaction type doesn't match.
*/
explicit Batch(std::shared_ptr<STTx const> tx)
: TransactionBase(std::move(tx))
{
// Verify transaction type
if (tx_->getTxnType() != txType)
{
throw std::runtime_error("Invalid transaction type for Batch");
}
}
// Transaction-specific field getters
/**
* @brief Get sfRawTransactions (soeREQUIRED)
* @note This is an untyped field.
* @return The field value.
*/
[[nodiscard]]
STArray const&
getRawTransactions() const
{
return this->tx_->getFieldArray(sfRawTransactions);
}
/**
* @brief Get sfBatchSigners (soeOPTIONAL)
* @note This is an untyped field.
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
std::optional<std::reference_wrapper<STArray const>>
getBatchSigners() const
{
if (this->tx_->isFieldPresent(sfBatchSigners))
return this->tx_->getFieldArray(sfBatchSigners);
return std::nullopt;
}
/**
* @brief Check if sfBatchSigners is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasBatchSigners() const
{
return this->tx_->isFieldPresent(sfBatchSigners);
}
};
/**
* @brief Builder for Batch transactions.
*
* Provides a fluent interface for constructing transactions with method chaining.
* Uses Json::Value internally for flexible transaction construction.
* Inherits common field setters from TransactionBuilderBase.
*/
class BatchBuilder : public TransactionBuilderBase<BatchBuilder>
{
public:
/**
* @brief Construct a new BatchBuilder with required fields.
* @param account The account initiating the transaction.
* @param rawTransactions The sfRawTransactions field value.
* @param sequence Optional sequence number for the transaction.
* @param fee Optional fee for the transaction.
*/
BatchBuilder(SF_ACCOUNT::type::value_type account,
STArray const& rawTransactions, std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
)
: TransactionBuilderBase<BatchBuilder>(ttBATCH, account, sequence, fee)
{
setRawTransactions(rawTransactions);
}
/**
* @brief Construct a BatchBuilder from an existing STTx object.
* @param tx The existing transaction to copy from.
* @throws std::runtime_error if the transaction type doesn't match.
*/
BatchBuilder(std::shared_ptr<STTx const> tx)
{
if (tx->getTxnType() != ttBATCH)
{
throw std::runtime_error("Invalid transaction type for BatchBuilder");
}
object_ = *tx;
}
/** @brief Transaction-specific field setters */
/**
* @brief Set sfRawTransactions (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
BatchBuilder&
setRawTransactions(STArray const& value)
{
object_.setFieldArray(sfRawTransactions, value);
return *this;
}
/**
* @brief Set sfBatchSigners (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
BatchBuilder&
setBatchSigners(STArray const& value)
{
object_.setFieldArray(sfBatchSigners, value);
return *this;
}
/**
* @brief Build and return the Batch wrapper.
* @param publicKey The public key for signing.
* @param secretKey The secret key for signing.
* @return The constructed transaction wrapper.
*/
Batch
build(PublicKey const& publicKey, SecretKey const& secretKey)
{
sign(publicKey, secretKey);
return Batch{std::make_shared<STTx>(std::move(object_))};
}
};
} // namespace xrpl::transactions

129
include/xrpl/protocol_autogen/transactions/CheckCancel.h Normal file
View File

@@ -0,0 +1,129 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/TransactionBase.h>
#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::transactions {
class CheckCancelBuilder;
/**
* @brief Transaction: CheckCancel
*
* Type: ttCHECK_CANCEL (18)
* Delegable: Delegation::delegable
* Amendment: uint256{}
* Privileges: noPriv
*
* Immutable wrapper around STTx providing type-safe field access.
* Use CheckCancelBuilder to construct new transactions.
*/
class CheckCancel : public TransactionBase
{
public:
static constexpr xrpl::TxType txType = ttCHECK_CANCEL;
/**
* @brief Construct a CheckCancel transaction wrapper from an existing STTx object.
* @throws std::runtime_error if the transaction type doesn't match.
*/
explicit CheckCancel(std::shared_ptr<STTx const> tx)
: TransactionBase(std::move(tx))
{
// Verify transaction type
if (tx_->getTxnType() != txType)
{
throw std::runtime_error("Invalid transaction type for CheckCancel");
}
}
// Transaction-specific field getters
/**
* @brief Get sfCheckID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getCheckID() const
{
return this->tx_->at(sfCheckID);
}
};
/**
* @brief Builder for CheckCancel transactions.
*
* Provides a fluent interface for constructing transactions with method chaining.
* Uses Json::Value internally for flexible transaction construction.
* Inherits common field setters from TransactionBuilderBase.
*/
class CheckCancelBuilder : public TransactionBuilderBase<CheckCancelBuilder>
{
public:
/**
* @brief Construct a new CheckCancelBuilder with required fields.
* @param account The account initiating the transaction.
* @param checkID The sfCheckID field value.
* @param sequence Optional sequence number for the transaction.
* @param fee Optional fee for the transaction.
*/
CheckCancelBuilder(SF_ACCOUNT::type::value_type account,
std::decay_t<typename SF_UINT256::type::value_type> const& checkID, std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
)
: TransactionBuilderBase<CheckCancelBuilder>(ttCHECK_CANCEL, account, sequence, fee)
{
setCheckID(checkID);
}
/**
* @brief Construct a CheckCancelBuilder from an existing STTx object.
* @param tx The existing transaction to copy from.
* @throws std::runtime_error if the transaction type doesn't match.
*/
CheckCancelBuilder(std::shared_ptr<STTx const> tx)
{
if (tx->getTxnType() != ttCHECK_CANCEL)
{
throw std::runtime_error("Invalid transaction type for CheckCancelBuilder");
}
object_ = *tx;
}
/** @brief Transaction-specific field setters */
/**
* @brief Set sfCheckID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
CheckCancelBuilder&
setCheckID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfCheckID] = value;
return *this;
}
/**
* @brief Build and return the CheckCancel wrapper.
* @param publicKey The public key for signing.
* @param secretKey The secret key for signing.
* @return The constructed transaction wrapper.
*/
CheckCancel
build(PublicKey const& publicKey, SecretKey const& secretKey)
{
sign(publicKey, secretKey);
return CheckCancel{std::make_shared<STTx>(std::move(object_))};
}
};
} // namespace xrpl::transactions

203
include/xrpl/protocol_autogen/transactions/CheckCash.h Normal file
View File

@@ -0,0 +1,203 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/TransactionBase.h>
#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::transactions {
class CheckCashBuilder;
/**
* @brief Transaction: CheckCash
*
* Type: ttCHECK_CASH (17)
* Delegable: Delegation::delegable
* Amendment: uint256{}
* Privileges: noPriv
*
* Immutable wrapper around STTx providing type-safe field access.
* Use CheckCashBuilder to construct new transactions.
*/
class CheckCash : public TransactionBase
{
public:
static constexpr xrpl::TxType txType = ttCHECK_CASH;
/**
* @brief Construct a CheckCash transaction wrapper from an existing STTx object.
* @throws std::runtime_error if the transaction type doesn't match.
*/
explicit CheckCash(std::shared_ptr<STTx const> tx)
: TransactionBase(std::move(tx))
{
// Verify transaction type
if (tx_->getTxnType() != txType)
{
throw std::runtime_error("Invalid transaction type for CheckCash");
}
}
// Transaction-specific field getters
/**
* @brief Get sfCheckID (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_UINT256::type::value_type
getCheckID() const
{
return this->tx_->at(sfCheckID);
}
/**
* @brief Get sfAmount (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_AMOUNT::type::value_type>
getAmount() const
{
if (hasAmount())
{
return this->tx_->at(sfAmount);
}
return std::nullopt;
}
/**
* @brief Check if sfAmount is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasAmount() const
{
return this->tx_->isFieldPresent(sfAmount);
}
/**
* @brief Get sfDeliverMin (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_AMOUNT::type::value_type>
getDeliverMin() const
{
if (hasDeliverMin())
{
return this->tx_->at(sfDeliverMin);
}
return std::nullopt;
}
/**
* @brief Check if sfDeliverMin is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasDeliverMin() const
{
return this->tx_->isFieldPresent(sfDeliverMin);
}
};
/**
* @brief Builder for CheckCash transactions.
*
* Provides a fluent interface for constructing transactions with method chaining.
* Uses Json::Value internally for flexible transaction construction.
* Inherits common field setters from TransactionBuilderBase.
*/
class CheckCashBuilder : public TransactionBuilderBase<CheckCashBuilder>
{
public:
/**
* @brief Construct a new CheckCashBuilder with required fields.
* @param account The account initiating the transaction.
* @param checkID The sfCheckID field value.
* @param sequence Optional sequence number for the transaction.
* @param fee Optional fee for the transaction.
*/
CheckCashBuilder(SF_ACCOUNT::type::value_type account,
std::decay_t<typename SF_UINT256::type::value_type> const& checkID, std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
)
: TransactionBuilderBase<CheckCashBuilder>(ttCHECK_CASH, account, sequence, fee)
{
setCheckID(checkID);
}
/**
* @brief Construct a CheckCashBuilder from an existing STTx object.
* @param tx The existing transaction to copy from.
* @throws std::runtime_error if the transaction type doesn't match.
*/
CheckCashBuilder(std::shared_ptr<STTx const> tx)
{
if (tx->getTxnType() != ttCHECK_CASH)
{
throw std::runtime_error("Invalid transaction type for CheckCashBuilder");
}
object_ = *tx;
}
/** @brief Transaction-specific field setters */
/**
* @brief Set sfCheckID (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
CheckCashBuilder&
setCheckID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfCheckID] = value;
return *this;
}
/**
* @brief Set sfAmount (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
CheckCashBuilder&
setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfAmount] = value;
return *this;
}
/**
* @brief Set sfDeliverMin (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
CheckCashBuilder&
setDeliverMin(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfDeliverMin] = value;
return *this;
}
/**
* @brief Build and return the CheckCash wrapper.
* @param publicKey The public key for signing.
* @param secretKey The secret key for signing.
* @return The constructed transaction wrapper.
*/
CheckCash
build(PublicKey const& publicKey, SecretKey const& secretKey)
{
sign(publicKey, secretKey);
return CheckCash{std::make_shared<STTx>(std::move(object_))};
}
};
} // namespace xrpl::transactions

264
include/xrpl/protocol_autogen/transactions/CheckCreate.h Normal file
View File

@@ -0,0 +1,264 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/TransactionBase.h>
#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::transactions {
class CheckCreateBuilder;
/**
* @brief Transaction: CheckCreate
*
* Type: ttCHECK_CREATE (16)
* Delegable: Delegation::delegable
* Amendment: uint256{}
* Privileges: noPriv
*
* Immutable wrapper around STTx providing type-safe field access.
* Use CheckCreateBuilder to construct new transactions.
*/
class CheckCreate : public TransactionBase
{
public:
static constexpr xrpl::TxType txType = ttCHECK_CREATE;
/**
* @brief Construct a CheckCreate transaction wrapper from an existing STTx object.
* @throws std::runtime_error if the transaction type doesn't match.
*/
explicit CheckCreate(std::shared_ptr<STTx const> tx)
: TransactionBase(std::move(tx))
{
// Verify transaction type
if (tx_->getTxnType() != txType)
{
throw std::runtime_error("Invalid transaction type for CheckCreate");
}
}
// Transaction-specific field getters
/**
* @brief Get sfDestination (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getDestination() const
{
return this->tx_->at(sfDestination);
}
/**
* @brief Get sfSendMax (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_AMOUNT::type::value_type
getSendMax() const
{
return this->tx_->at(sfSendMax);
}
/**
* @brief Get sfExpiration (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getExpiration() const
{
if (hasExpiration())
{
return this->tx_->at(sfExpiration);
}
return std::nullopt;
}
/**
* @brief Check if sfExpiration is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasExpiration() const
{
return this->tx_->isFieldPresent(sfExpiration);
}
/**
* @brief Get sfDestinationTag (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getDestinationTag() const
{
if (hasDestinationTag())
{
return this->tx_->at(sfDestinationTag);
}
return std::nullopt;
}
/**
* @brief Check if sfDestinationTag is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasDestinationTag() const
{
return this->tx_->isFieldPresent(sfDestinationTag);
}
/**
* @brief Get sfInvoiceID (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT256::type::value_type>
getInvoiceID() const
{
if (hasInvoiceID())
{
return this->tx_->at(sfInvoiceID);
}
return std::nullopt;
}
/**
* @brief Check if sfInvoiceID is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasInvoiceID() const
{
return this->tx_->isFieldPresent(sfInvoiceID);
}
};
/**
* @brief Builder for CheckCreate transactions.
*
* Provides a fluent interface for constructing transactions with method chaining.
* Uses Json::Value internally for flexible transaction construction.
* Inherits common field setters from TransactionBuilderBase.
*/
class CheckCreateBuilder : public TransactionBuilderBase<CheckCreateBuilder>
{
public:
/**
* @brief Construct a new CheckCreateBuilder with required fields.
* @param account The account initiating the transaction.
* @param destination The sfDestination field value.
* @param sendMax The sfSendMax field value.
* @param sequence Optional sequence number for the transaction.
* @param fee Optional fee for the transaction.
*/
CheckCreateBuilder(SF_ACCOUNT::type::value_type account,
std::decay_t<typename SF_ACCOUNT::type::value_type> const& destination, std::decay_t<typename SF_AMOUNT::type::value_type> const& sendMax, std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
)
: TransactionBuilderBase<CheckCreateBuilder>(ttCHECK_CREATE, account, sequence, fee)
{
setDestination(destination);
setSendMax(sendMax);
}
/**
* @brief Construct a CheckCreateBuilder from an existing STTx object.
* @param tx The existing transaction to copy from.
* @throws std::runtime_error if the transaction type doesn't match.
*/
CheckCreateBuilder(std::shared_ptr<STTx const> tx)
{
if (tx->getTxnType() != ttCHECK_CREATE)
{
throw std::runtime_error("Invalid transaction type for CheckCreateBuilder");
}
object_ = *tx;
}
/** @brief Transaction-specific field setters */
/**
* @brief Set sfDestination (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
CheckCreateBuilder&
setDestination(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfDestination] = value;
return *this;
}
/**
* @brief Set sfSendMax (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
CheckCreateBuilder&
setSendMax(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfSendMax] = value;
return *this;
}
/**
* @brief Set sfExpiration (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
CheckCreateBuilder&
setExpiration(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfExpiration] = value;
return *this;
}
/**
* @brief Set sfDestinationTag (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
CheckCreateBuilder&
setDestinationTag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfDestinationTag] = value;
return *this;
}
/**
* @brief Set sfInvoiceID (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
CheckCreateBuilder&
setInvoiceID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
{
object_[sfInvoiceID] = value;
return *this;
}
/**
* @brief Build and return the CheckCreate wrapper.
* @param publicKey The public key for signing.
* @param secretKey The secret key for signing.
* @return The constructed transaction wrapper.
*/
CheckCreate
build(PublicKey const& publicKey, SecretKey const& secretKey)
{
sign(publicKey, secretKey);
return CheckCreate{std::make_shared<STTx>(std::move(object_))};
}
};
} // namespace xrpl::transactions

168
include/xrpl/protocol_autogen/transactions/Clawback.h Normal file
View File

@@ -0,0 +1,168 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/TransactionBase.h>
#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::transactions {
class ClawbackBuilder;
/**
* @brief Transaction: Clawback
*
* Type: ttCLAWBACK (30)
* Delegable: Delegation::delegable
* Amendment: featureClawback
* Privileges: noPriv
*
* Immutable wrapper around STTx providing type-safe field access.
* Use ClawbackBuilder to construct new transactions.
*/
class Clawback : public TransactionBase
{
public:
static constexpr xrpl::TxType txType = ttCLAWBACK;
/**
* @brief Construct a Clawback transaction wrapper from an existing STTx object.
* @throws std::runtime_error if the transaction type doesn't match.
*/
explicit Clawback(std::shared_ptr<STTx const> tx)
: TransactionBase(std::move(tx))
{
// Verify transaction type
if (tx_->getTxnType() != txType)
{
throw std::runtime_error("Invalid transaction type for Clawback");
}
}
// Transaction-specific field getters
/**
* @brief Get sfAmount (soeREQUIRED)
* @note This field supports MPT (Multi-Purpose Token) amounts.
* @return The field value.
*/
[[nodiscard]]
SF_AMOUNT::type::value_type
getAmount() const
{
return this->tx_->at(sfAmount);
}
/**
* @brief Get sfHolder (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
getHolder() const
{
if (hasHolder())
{
return this->tx_->at(sfHolder);
}
return std::nullopt;
}
/**
* @brief Check if sfHolder is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasHolder() const
{
return this->tx_->isFieldPresent(sfHolder);
}
};
/**
* @brief Builder for Clawback transactions.
*
* Provides a fluent interface for constructing transactions with method chaining.
* Uses Json::Value internally for flexible transaction construction.
* Inherits common field setters from TransactionBuilderBase.
*/
class ClawbackBuilder : public TransactionBuilderBase<ClawbackBuilder>
{
public:
/**
* @brief Construct a new ClawbackBuilder with required fields.
* @param account The account initiating the transaction.
* @param amount The sfAmount field value.
* @param sequence Optional sequence number for the transaction.
* @param fee Optional fee for the transaction.
*/
ClawbackBuilder(SF_ACCOUNT::type::value_type account,
std::decay_t<typename SF_AMOUNT::type::value_type> const& amount, std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
)
: TransactionBuilderBase<ClawbackBuilder>(ttCLAWBACK, account, sequence, fee)
{
setAmount(amount);
}
/**
* @brief Construct a ClawbackBuilder from an existing STTx object.
* @param tx The existing transaction to copy from.
* @throws std::runtime_error if the transaction type doesn't match.
*/
ClawbackBuilder(std::shared_ptr<STTx const> tx)
{
if (tx->getTxnType() != ttCLAWBACK)
{
throw std::runtime_error("Invalid transaction type for ClawbackBuilder");
}
object_ = *tx;
}
/** @brief Transaction-specific field setters */
/**
* @brief Set sfAmount (soeREQUIRED)
* @note This field supports MPT (Multi-Purpose Token) amounts.
* @return Reference to this builder for method chaining.
*/
ClawbackBuilder&
setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
{
object_[sfAmount] = value;
return *this;
}
/**
* @brief Set sfHolder (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
ClawbackBuilder&
setHolder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfHolder] = value;
return *this;
}
/**
* @brief Build and return the Clawback wrapper.
* @param publicKey The public key for signing.
* @param secretKey The secret key for signing.
* @return The constructed transaction wrapper.
*/
Clawback
build(PublicKey const& publicKey, SecretKey const& secretKey)
{
sign(publicKey, secretKey);
return Clawback{std::make_shared<STTx>(std::move(object_))};
}
};
} // namespace xrpl::transactions

153
include/xrpl/protocol_autogen/transactions/CredentialAccept.h Normal file
View File

@@ -0,0 +1,153 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/TransactionBase.h>
#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::transactions {
class CredentialAcceptBuilder;
/**
* @brief Transaction: CredentialAccept
*
* Type: ttCREDENTIAL_ACCEPT (59)
* Delegable: Delegation::delegable
* Amendment: featureCredentials
* Privileges: noPriv
*
* Immutable wrapper around STTx providing type-safe field access.
* Use CredentialAcceptBuilder to construct new transactions.
*/
class CredentialAccept : public TransactionBase
{
public:
static constexpr xrpl::TxType txType = ttCREDENTIAL_ACCEPT;
/**
* @brief Construct a CredentialAccept transaction wrapper from an existing STTx object.
* @throws std::runtime_error if the transaction type doesn't match.
*/
explicit CredentialAccept(std::shared_ptr<STTx const> tx)
: TransactionBase(std::move(tx))
{
// Verify transaction type
if (tx_->getTxnType() != txType)
{
throw std::runtime_error("Invalid transaction type for CredentialAccept");
}
}
// Transaction-specific field getters
/**
* @brief Get sfIssuer (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getIssuer() const
{
return this->tx_->at(sfIssuer);
}
/**
* @brief Get sfCredentialType (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_VL::type::value_type
getCredentialType() const
{
return this->tx_->at(sfCredentialType);
}
};
/**
* @brief Builder for CredentialAccept transactions.
*
* Provides a fluent interface for constructing transactions with method chaining.
* Uses Json::Value internally for flexible transaction construction.
* Inherits common field setters from TransactionBuilderBase.
*/
class CredentialAcceptBuilder : public TransactionBuilderBase<CredentialAcceptBuilder>
{
public:
/**
* @brief Construct a new CredentialAcceptBuilder with required fields.
* @param account The account initiating the transaction.
* @param issuer The sfIssuer field value.
* @param credentialType The sfCredentialType field value.
* @param sequence Optional sequence number for the transaction.
* @param fee Optional fee for the transaction.
*/
CredentialAcceptBuilder(SF_ACCOUNT::type::value_type account,
std::decay_t<typename SF_ACCOUNT::type::value_type> const& issuer, std::decay_t<typename SF_VL::type::value_type> const& credentialType, std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
)
: TransactionBuilderBase<CredentialAcceptBuilder>(ttCREDENTIAL_ACCEPT, account, sequence, fee)
{
setIssuer(issuer);
setCredentialType(credentialType);
}
/**
* @brief Construct a CredentialAcceptBuilder from an existing STTx object.
* @param tx The existing transaction to copy from.
* @throws std::runtime_error if the transaction type doesn't match.
*/
CredentialAcceptBuilder(std::shared_ptr<STTx const> tx)
{
if (tx->getTxnType() != ttCREDENTIAL_ACCEPT)
{
throw std::runtime_error("Invalid transaction type for CredentialAcceptBuilder");
}
object_ = *tx;
}
/** @brief Transaction-specific field setters */
/**
* @brief Set sfIssuer (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
CredentialAcceptBuilder&
setIssuer(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfIssuer] = value;
return *this;
}
/**
* @brief Set sfCredentialType (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
CredentialAcceptBuilder&
setCredentialType(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfCredentialType] = value;
return *this;
}
/**
* @brief Build and return the CredentialAccept wrapper.
* @param publicKey The public key for signing.
* @param secretKey The secret key for signing.
* @return The constructed transaction wrapper.
*/
CredentialAccept
build(PublicKey const& publicKey, SecretKey const& secretKey)
{
sign(publicKey, secretKey);
return CredentialAccept{std::make_shared<STTx>(std::move(object_))};
}
};
} // namespace xrpl::transactions

227
include/xrpl/protocol_autogen/transactions/CredentialCreate.h Normal file
View File

@@ -0,0 +1,227 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/TransactionBase.h>
#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::transactions {
class CredentialCreateBuilder;
/**
* @brief Transaction: CredentialCreate
*
* Type: ttCREDENTIAL_CREATE (58)
* Delegable: Delegation::delegable
* Amendment: featureCredentials
* Privileges: noPriv
*
* Immutable wrapper around STTx providing type-safe field access.
* Use CredentialCreateBuilder to construct new transactions.
*/
class CredentialCreate : public TransactionBase
{
public:
static constexpr xrpl::TxType txType = ttCREDENTIAL_CREATE;
/**
* @brief Construct a CredentialCreate transaction wrapper from an existing STTx object.
* @throws std::runtime_error if the transaction type doesn't match.
*/
explicit CredentialCreate(std::shared_ptr<STTx const> tx)
: TransactionBase(std::move(tx))
{
// Verify transaction type
if (tx_->getTxnType() != txType)
{
throw std::runtime_error("Invalid transaction type for CredentialCreate");
}
}
// Transaction-specific field getters
/**
* @brief Get sfSubject (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getSubject() const
{
return this->tx_->at(sfSubject);
}
/**
* @brief Get sfCredentialType (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_VL::type::value_type
getCredentialType() const
{
return this->tx_->at(sfCredentialType);
}
/**
* @brief Get sfExpiration (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_UINT32::type::value_type>
getExpiration() const
{
if (hasExpiration())
{
return this->tx_->at(sfExpiration);
}
return std::nullopt;
}
/**
* @brief Check if sfExpiration is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasExpiration() const
{
return this->tx_->isFieldPresent(sfExpiration);
}
/**
* @brief Get sfURI (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_VL::type::value_type>
getURI() const
{
if (hasURI())
{
return this->tx_->at(sfURI);
}
return std::nullopt;
}
/**
* @brief Check if sfURI is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasURI() const
{
return this->tx_->isFieldPresent(sfURI);
}
};
/**
* @brief Builder for CredentialCreate transactions.
*
* Provides a fluent interface for constructing transactions with method chaining.
* Uses Json::Value internally for flexible transaction construction.
* Inherits common field setters from TransactionBuilderBase.
*/
class CredentialCreateBuilder : public TransactionBuilderBase<CredentialCreateBuilder>
{
public:
/**
* @brief Construct a new CredentialCreateBuilder with required fields.
* @param account The account initiating the transaction.
* @param subject The sfSubject field value.
* @param credentialType The sfCredentialType field value.
* @param sequence Optional sequence number for the transaction.
* @param fee Optional fee for the transaction.
*/
CredentialCreateBuilder(SF_ACCOUNT::type::value_type account,
std::decay_t<typename SF_ACCOUNT::type::value_type> const& subject, std::decay_t<typename SF_VL::type::value_type> const& credentialType, std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
)
: TransactionBuilderBase<CredentialCreateBuilder>(ttCREDENTIAL_CREATE, account, sequence, fee)
{
setSubject(subject);
setCredentialType(credentialType);
}
/**
* @brief Construct a CredentialCreateBuilder from an existing STTx object.
* @param tx The existing transaction to copy from.
* @throws std::runtime_error if the transaction type doesn't match.
*/
CredentialCreateBuilder(std::shared_ptr<STTx const> tx)
{
if (tx->getTxnType() != ttCREDENTIAL_CREATE)
{
throw std::runtime_error("Invalid transaction type for CredentialCreateBuilder");
}
object_ = *tx;
}
/** @brief Transaction-specific field setters */
/**
* @brief Set sfSubject (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
CredentialCreateBuilder&
setSubject(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfSubject] = value;
return *this;
}
/**
* @brief Set sfCredentialType (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
CredentialCreateBuilder&
setCredentialType(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfCredentialType] = value;
return *this;
}
/**
* @brief Set sfExpiration (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
CredentialCreateBuilder&
setExpiration(std::decay_t<typename SF_UINT32::type::value_type> const& value)
{
object_[sfExpiration] = value;
return *this;
}
/**
* @brief Set sfURI (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
CredentialCreateBuilder&
setURI(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfURI] = value;
return *this;
}
/**
* @brief Build and return the CredentialCreate wrapper.
* @param publicKey The public key for signing.
* @param secretKey The secret key for signing.
* @return The constructed transaction wrapper.
*/
CredentialCreate
build(PublicKey const& publicKey, SecretKey const& secretKey)
{
sign(publicKey, secretKey);
return CredentialCreate{std::make_shared<STTx>(std::move(object_))};
}
};
} // namespace xrpl::transactions

203
include/xrpl/protocol_autogen/transactions/CredentialDelete.h Normal file
View File

@@ -0,0 +1,203 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/TransactionBase.h>
#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::transactions {
class CredentialDeleteBuilder;
/**
* @brief Transaction: CredentialDelete
*
* Type: ttCREDENTIAL_DELETE (60)
* Delegable: Delegation::delegable
* Amendment: featureCredentials
* Privileges: noPriv
*
* Immutable wrapper around STTx providing type-safe field access.
* Use CredentialDeleteBuilder to construct new transactions.
*/
class CredentialDelete : public TransactionBase
{
public:
static constexpr xrpl::TxType txType = ttCREDENTIAL_DELETE;
/**
* @brief Construct a CredentialDelete transaction wrapper from an existing STTx object.
* @throws std::runtime_error if the transaction type doesn't match.
*/
explicit CredentialDelete(std::shared_ptr<STTx const> tx)
: TransactionBase(std::move(tx))
{
// Verify transaction type
if (tx_->getTxnType() != txType)
{
throw std::runtime_error("Invalid transaction type for CredentialDelete");
}
}
// Transaction-specific field getters
/**
* @brief Get sfSubject (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
getSubject() const
{
if (hasSubject())
{
return this->tx_->at(sfSubject);
}
return std::nullopt;
}
/**
* @brief Check if sfSubject is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasSubject() const
{
return this->tx_->isFieldPresent(sfSubject);
}
/**
* @brief Get sfIssuer (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
getIssuer() const
{
if (hasIssuer())
{
return this->tx_->at(sfIssuer);
}
return std::nullopt;
}
/**
* @brief Check if sfIssuer is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasIssuer() const
{
return this->tx_->isFieldPresent(sfIssuer);
}
/**
* @brief Get sfCredentialType (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_VL::type::value_type
getCredentialType() const
{
return this->tx_->at(sfCredentialType);
}
};
/**
* @brief Builder for CredentialDelete transactions.
*
* Provides a fluent interface for constructing transactions with method chaining.
* Uses Json::Value internally for flexible transaction construction.
* Inherits common field setters from TransactionBuilderBase.
*/
class CredentialDeleteBuilder : public TransactionBuilderBase<CredentialDeleteBuilder>
{
public:
/**
* @brief Construct a new CredentialDeleteBuilder with required fields.
* @param account The account initiating the transaction.
* @param credentialType The sfCredentialType field value.
* @param sequence Optional sequence number for the transaction.
* @param fee Optional fee for the transaction.
*/
CredentialDeleteBuilder(SF_ACCOUNT::type::value_type account,
std::decay_t<typename SF_VL::type::value_type> const& credentialType, std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
)
: TransactionBuilderBase<CredentialDeleteBuilder>(ttCREDENTIAL_DELETE, account, sequence, fee)
{
setCredentialType(credentialType);
}
/**
* @brief Construct a CredentialDeleteBuilder from an existing STTx object.
* @param tx The existing transaction to copy from.
* @throws std::runtime_error if the transaction type doesn't match.
*/
CredentialDeleteBuilder(std::shared_ptr<STTx const> tx)
{
if (tx->getTxnType() != ttCREDENTIAL_DELETE)
{
throw std::runtime_error("Invalid transaction type for CredentialDeleteBuilder");
}
object_ = *tx;
}
/** @brief Transaction-specific field setters */
/**
* @brief Set sfSubject (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
CredentialDeleteBuilder&
setSubject(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfSubject] = value;
return *this;
}
/**
* @brief Set sfIssuer (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
CredentialDeleteBuilder&
setIssuer(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfIssuer] = value;
return *this;
}
/**
* @brief Set sfCredentialType (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
CredentialDeleteBuilder&
setCredentialType(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfCredentialType] = value;
return *this;
}
/**
* @brief Build and return the CredentialDelete wrapper.
* @param publicKey The public key for signing.
* @param secretKey The secret key for signing.
* @return The constructed transaction wrapper.
*/
CredentialDelete
build(PublicKey const& publicKey, SecretKey const& secretKey)
{
sign(publicKey, secretKey);
return CredentialDelete{std::make_shared<STTx>(std::move(object_))};
}
};
} // namespace xrpl::transactions

105
include/xrpl/protocol_autogen/transactions/DIDDelete.h Normal file
View File

@@ -0,0 +1,105 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/TransactionBase.h>
#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::transactions {
class DIDDeleteBuilder;
/**
* @brief Transaction: DIDDelete
*
* Type: ttDID_DELETE (50)
* Delegable: Delegation::delegable
* Amendment: featureDID
* Privileges: noPriv
*
* Immutable wrapper around STTx providing type-safe field access.
* Use DIDDeleteBuilder to construct new transactions.
*/
class DIDDelete : public TransactionBase
{
public:
static constexpr xrpl::TxType txType = ttDID_DELETE;
/**
* @brief Construct a DIDDelete transaction wrapper from an existing STTx object.
* @throws std::runtime_error if the transaction type doesn't match.
*/
explicit DIDDelete(std::shared_ptr<STTx const> tx)
: TransactionBase(std::move(tx))
{
// Verify transaction type
if (tx_->getTxnType() != txType)
{
throw std::runtime_error("Invalid transaction type for DIDDelete");
}
}
// Transaction-specific field getters
};
/**
* @brief Builder for DIDDelete transactions.
*
* Provides a fluent interface for constructing transactions with method chaining.
* Uses Json::Value internally for flexible transaction construction.
* Inherits common field setters from TransactionBuilderBase.
*/
class DIDDeleteBuilder : public TransactionBuilderBase<DIDDeleteBuilder>
{
public:
/**
* @brief Construct a new DIDDeleteBuilder with required fields.
* @param account The account initiating the transaction.
* @param sequence Optional sequence number for the transaction.
* @param fee Optional fee for the transaction.
*/
DIDDeleteBuilder(SF_ACCOUNT::type::value_type account,
std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
)
: TransactionBuilderBase<DIDDeleteBuilder>(ttDID_DELETE, account, sequence, fee)
{
}
/**
* @brief Construct a DIDDeleteBuilder from an existing STTx object.
* @param tx The existing transaction to copy from.
* @throws std::runtime_error if the transaction type doesn't match.
*/
DIDDeleteBuilder(std::shared_ptr<STTx const> tx)
{
if (tx->getTxnType() != ttDID_DELETE)
{
throw std::runtime_error("Invalid transaction type for DIDDeleteBuilder");
}
object_ = *tx;
}
/** @brief Transaction-specific field setters */
/**
* @brief Build and return the DIDDelete wrapper.
* @param publicKey The public key for signing.
* @param secretKey The secret key for signing.
* @return The constructed transaction wrapper.
*/
DIDDelete
build(PublicKey const& publicKey, SecretKey const& secretKey)
{
sign(publicKey, secretKey);
return DIDDelete{std::make_shared<STTx>(std::move(object_))};
}
};
} // namespace xrpl::transactions

216
include/xrpl/protocol_autogen/transactions/DIDSet.h Normal file
View File

@@ -0,0 +1,216 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/TransactionBase.h>
#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::transactions {
class DIDSetBuilder;
/**
* @brief Transaction: DIDSet
*
* Type: ttDID_SET (49)
* Delegable: Delegation::delegable
* Amendment: featureDID
* Privileges: noPriv
*
* Immutable wrapper around STTx providing type-safe field access.
* Use DIDSetBuilder to construct new transactions.
*/
class DIDSet : public TransactionBase
{
public:
static constexpr xrpl::TxType txType = ttDID_SET;
/**
* @brief Construct a DIDSet transaction wrapper from an existing STTx object.
* @throws std::runtime_error if the transaction type doesn't match.
*/
explicit DIDSet(std::shared_ptr<STTx const> tx)
: TransactionBase(std::move(tx))
{
// Verify transaction type
if (tx_->getTxnType() != txType)
{
throw std::runtime_error("Invalid transaction type for DIDSet");
}
}
// Transaction-specific field getters
/**
* @brief Get sfDIDDocument (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_VL::type::value_type>
getDIDDocument() const
{
if (hasDIDDocument())
{
return this->tx_->at(sfDIDDocument);
}
return std::nullopt;
}
/**
* @brief Check if sfDIDDocument is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasDIDDocument() const
{
return this->tx_->isFieldPresent(sfDIDDocument);
}
/**
* @brief Get sfURI (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_VL::type::value_type>
getURI() const
{
if (hasURI())
{
return this->tx_->at(sfURI);
}
return std::nullopt;
}
/**
* @brief Check if sfURI is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasURI() const
{
return this->tx_->isFieldPresent(sfURI);
}
/**
* @brief Get sfData (soeOPTIONAL)
* @return The field value, or std::nullopt if not present.
*/
[[nodiscard]]
protocol_autogen::Optional<SF_VL::type::value_type>
getData() const
{
if (hasData())
{
return this->tx_->at(sfData);
}
return std::nullopt;
}
/**
* @brief Check if sfData is present.
* @return True if the field is present, false otherwise.
*/
[[nodiscard]]
bool
hasData() const
{
return this->tx_->isFieldPresent(sfData);
}
};
/**
* @brief Builder for DIDSet transactions.
*
* Provides a fluent interface for constructing transactions with method chaining.
* Uses Json::Value internally for flexible transaction construction.
* Inherits common field setters from TransactionBuilderBase.
*/
class DIDSetBuilder : public TransactionBuilderBase<DIDSetBuilder>
{
public:
/**
* @brief Construct a new DIDSetBuilder with required fields.
* @param account The account initiating the transaction.
* @param sequence Optional sequence number for the transaction.
* @param fee Optional fee for the transaction.
*/
DIDSetBuilder(SF_ACCOUNT::type::value_type account,
std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
)
: TransactionBuilderBase<DIDSetBuilder>(ttDID_SET, account, sequence, fee)
{
}
/**
* @brief Construct a DIDSetBuilder from an existing STTx object.
* @param tx The existing transaction to copy from.
* @throws std::runtime_error if the transaction type doesn't match.
*/
DIDSetBuilder(std::shared_ptr<STTx const> tx)
{
if (tx->getTxnType() != ttDID_SET)
{
throw std::runtime_error("Invalid transaction type for DIDSetBuilder");
}
object_ = *tx;
}
/** @brief Transaction-specific field setters */
/**
* @brief Set sfDIDDocument (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
DIDSetBuilder&
setDIDDocument(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfDIDDocument] = value;
return *this;
}
/**
* @brief Set sfURI (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
DIDSetBuilder&
setURI(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfURI] = value;
return *this;
}
/**
* @brief Set sfData (soeOPTIONAL)
* @return Reference to this builder for method chaining.
*/
DIDSetBuilder&
setData(std::decay_t<typename SF_VL::type::value_type> const& value)
{
object_[sfData] = value;
return *this;
}
/**
* @brief Build and return the DIDSet wrapper.
* @param publicKey The public key for signing.
* @param secretKey The secret key for signing.
* @return The constructed transaction wrapper.
*/
DIDSet
build(PublicKey const& publicKey, SecretKey const& secretKey)
{
sign(publicKey, secretKey);
return DIDSet{std::make_shared<STTx>(std::move(object_))};
}
};
} // namespace xrpl::transactions

153
include/xrpl/protocol_autogen/transactions/DelegateSet.h Normal file
View File

@@ -0,0 +1,153 @@
// This file is auto-generated. Do not edit.
#pragma once
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/STParsedJSON.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/protocol_autogen/TransactionBase.h>
#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
#include <xrpl/json/json_value.h>
#include <stdexcept>
#include <optional>
namespace xrpl::transactions {
class DelegateSetBuilder;
/**
* @brief Transaction: DelegateSet
*
* Type: ttDELEGATE_SET (64)
* Delegable: Delegation::notDelegable
* Amendment: featurePermissionDelegationV1_1
* Privileges: noPriv
*
* Immutable wrapper around STTx providing type-safe field access.
* Use DelegateSetBuilder to construct new transactions.
*/
class DelegateSet : public TransactionBase
{
public:
static constexpr xrpl::TxType txType = ttDELEGATE_SET;
/**
* @brief Construct a DelegateSet transaction wrapper from an existing STTx object.
* @throws std::runtime_error if the transaction type doesn't match.
*/
explicit DelegateSet(std::shared_ptr<STTx const> tx)
: TransactionBase(std::move(tx))
{
// Verify transaction type
if (tx_->getTxnType() != txType)
{
throw std::runtime_error("Invalid transaction type for DelegateSet");
}
}
// Transaction-specific field getters
/**
* @brief Get sfAuthorize (soeREQUIRED)
* @return The field value.
*/
[[nodiscard]]
SF_ACCOUNT::type::value_type
getAuthorize() const
{
return this->tx_->at(sfAuthorize);
}
/**
* @brief Get sfPermissions (soeREQUIRED)
* @note This is an untyped field.
* @return The field value.
*/
[[nodiscard]]
STArray const&
getPermissions() const
{
return this->tx_->getFieldArray(sfPermissions);
}
};
/**
* @brief Builder for DelegateSet transactions.
*
* Provides a fluent interface for constructing transactions with method chaining.
* Uses Json::Value internally for flexible transaction construction.
* Inherits common field setters from TransactionBuilderBase.
*/
class DelegateSetBuilder : public TransactionBuilderBase<DelegateSetBuilder>
{
public:
/**
* @brief Construct a new DelegateSetBuilder with required fields.
* @param account The account initiating the transaction.
* @param authorize The sfAuthorize field value.
* @param permissions The sfPermissions field value.
* @param sequence Optional sequence number for the transaction.
* @param fee Optional fee for the transaction.
*/
DelegateSetBuilder(SF_ACCOUNT::type::value_type account,
std::decay_t<typename SF_ACCOUNT::type::value_type> const& authorize, STArray const& permissions, std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
)
: TransactionBuilderBase<DelegateSetBuilder>(ttDELEGATE_SET, account, sequence, fee)
{
setAuthorize(authorize);
setPermissions(permissions);
}
/**
* @brief Construct a DelegateSetBuilder from an existing STTx object.
* @param tx The existing transaction to copy from.
* @throws std::runtime_error if the transaction type doesn't match.
*/
DelegateSetBuilder(std::shared_ptr<STTx const> tx)
{
if (tx->getTxnType() != ttDELEGATE_SET)
{
throw std::runtime_error("Invalid transaction type for DelegateSetBuilder");
}
object_ = *tx;
}
/** @brief Transaction-specific field setters */
/**
* @brief Set sfAuthorize (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
DelegateSetBuilder&
setAuthorize(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
{
object_[sfAuthorize] = value;
return *this;
}
/**
* @brief Set sfPermissions (soeREQUIRED)
* @return Reference to this builder for method chaining.
*/
DelegateSetBuilder&
setPermissions(STArray const& value)
{
object_.setFieldArray(sfPermissions, value);
return *this;
}
/**
* @brief Build and return the DelegateSet wrapper.
* @param publicKey The public key for signing.
* @param secretKey The secret key for signing.
* @return The constructed transaction wrapper.
*/
DelegateSet
build(PublicKey const& publicKey, SecretKey const& secretKey)
{
sign(publicKey, secretKey);
return DelegateSet{std::make_shared<STTx>(std::move(object_))};
}
};
} // namespace xrpl::transactions

Some files were not shown because too many files have changed in this diff Show More