diff --git a/BuildInfo_8cpp_source.html b/BuildInfo_8cpp_source.html index fcfddaf214..3425224e2c 100644 --- a/BuildInfo_8cpp_source.html +++ b/BuildInfo_8cpp_source.html @@ -104,7 +104,7 @@ $(function() {
33 // and follow the format described at http://semver.org/
34 //------------------------------------------------------------------------------
35 // clang-format off
-
36 char const* const versionString = "1.10.0-b2"
+
36 char const* const versionString = "1.10.0-rc1"
37 // clang-format on
38 
39 #if defined(DEBUG) || defined(SANITIZER)
diff --git a/Expected_8h_source.html b/Expected_8h_source.html index 0781d414e7..a9d6792fad 100644 --- a/Expected_8h_source.html +++ b/Expected_8h_source.html @@ -92,262 +92,264 @@ $(function() {
21 #define RIPPLE_BASICS_EXPECTED_H_INCLUDED
22 
23 #include <ripple/basics/contract.h>
-
24 #include <boost/outcome.hpp>
-
25 #include <stdexcept>
-
26 #include <type_traits>
-
27 
-
28 namespace ripple {
-
29 
-
37 // Exception thrown by an invalid access to Expected.
-
38 struct bad_expected_access : public std::runtime_error
-
39 {
-
40  bad_expected_access() : runtime_error("bad expected access")
-
41  {
-
42  }
-
43 };
-
44 
-
45 namespace detail {
-
46 
-
47 // Custom policy for Expected. Always throw on an invalid access.
-
48 struct throw_policy : public boost::outcome_v2::policy::base
-
49 {
-
50  template <class Impl>
-
51  static constexpr void
-
52  wide_value_check(Impl&& self)
-
53  {
-
54  if (!base::_has_value(std::forward<Impl>(self)))
-
55  Throw<bad_expected_access>();
-
56  }
-
57 
-
58  template <class Impl>
-
59  static constexpr void
-
60  wide_error_check(Impl&& self)
-
61  {
-
62  if (!base::_has_error(std::forward<Impl>(self)))
-
63  Throw<bad_expected_access>();
-
64  }
-
65 
-
66  template <class Impl>
-
67  static constexpr void
-
68  wide_exception_check(Impl&& self)
-
69  {
-
70  if (!base::_has_exception(std::forward<Impl>(self)))
-
71  Throw<bad_expected_access>();
-
72  }
-
73 };
-
74 
-
75 } // namespace detail
-
76 
-
77 // Definition of Unexpected, which is used to construct the unexpected
-
78 // return type of an Expected.
-
79 template <class E>
-
80 class Unexpected
-
81 {
-
82 public:
-
83  static_assert(!std::is_same<E, void>::value, "E must not be void");
-
84 
-
85  Unexpected() = delete;
-
86 
-
87  constexpr explicit Unexpected(E const& e) : val_(e)
-
88  {
-
89  }
-
90 
-
91  constexpr explicit Unexpected(E&& e) : val_(std::move(e))
-
92  {
-
93  }
-
94 
-
95  constexpr const E&
-
96  value() const&
-
97  {
-
98  return val_;
-
99  }
-
100 
-
101  constexpr E&
-
102  value() &
-
103  {
-
104  return val_;
-
105  }
-
106 
-
107  constexpr E&&
-
108  value() &&
-
109  {
-
110  return std::move(val_);
-
111  }
-
112 
-
113  constexpr const E&&
-
114  value() const&&
-
115  {
-
116  return std::move(val_);
-
117  }
-
118 
-
119 private:
-
120  E val_;
-
121 };
-
122 
-
123 // Unexpected deduction guide that converts array to const*.
-
124 template <typename E, std::size_t N>
-
125 Unexpected(E (&)[N]) -> Unexpected<E const*>;
-
126 
-
127 // Definition of Expected. All of the machinery comes from boost::result.
-
128 template <class T, class E>
-
129 class [[nodiscard]] Expected
-
130  : private boost::outcome_v2::result<T, E, detail::throw_policy>
-
131 {
-
132  using Base = boost::outcome_v2::result<T, E, detail::throw_policy>;
-
133 
-
134 public:
-
135  template <
-
136  typename U,
-
137  typename = std::enable_if_t<std::is_convertible_v<U, T>>>
-
138  constexpr Expected(U r) : Base(T{std::forward<U>(r)})
-
139  {
-
140  }
-
141 
-
142  template <
-
143  typename U,
-
144  typename = std::enable_if_t<std::is_convertible_v<U, E>>>
-
145  constexpr Expected(Unexpected<U> e) : Base(E{std::forward<U>(e.value())})
-
146  {
-
147  }
-
148 
-
149  constexpr bool has_value() const
-
150  {
-
151  return Base::has_value();
-
152  }
-
153 
-
154  constexpr T const& value() const
-
155  {
-
156  return Base::value();
-
157  }
-
158 
-
159  constexpr T& value()
-
160  {
-
161  return Base::value();
-
162  }
-
163 
-
164  constexpr E const& error() const
-
165  {
-
166  return Base::error();
-
167  }
-
168 
-
169  constexpr E& error()
-
170  {
-
171  return Base::error();
-
172  }
-
173 
-
174  constexpr explicit operator bool() const
-
175  {
-
176  return has_value();
-
177  }
-
178 
-
179  // Add operator* and operator-> so the Expected API looks a bit more like
-
180  // what std::expected is likely to look like. See:
-
181  // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p0323r10.html
-
182  [[nodiscard]] constexpr T& operator*()
-
183  {
-
184  return this->value();
-
185  }
-
186 
-
187  [[nodiscard]] constexpr T const& operator*() const
-
188  {
-
189  return this->value();
-
190  }
-
191 
-
192  [[nodiscard]] constexpr T* operator->()
-
193  {
-
194  return &this->value();
-
195  }
-
196 
-
197  [[nodiscard]] constexpr T const* operator->() const
-
198  {
-
199  return &this->value();
-
200  }
-
201 };
-
202 
-
203 // Specialization of Expected<void, E>. Allows returning either success
-
204 // (without a value) or the reason for the failure.
-
205 template <class E>
-
206 class [[nodiscard]] Expected<void, E>
-
207  : private boost::outcome_v2::result<void, E, detail::throw_policy>
-
208 {
-
209  using Base = boost::outcome_v2::result<void, E, detail::throw_policy>;
-
210 
-
211 public:
-
212  // The default constructor makes a successful Expected<void, E>.
-
213  // This aligns with std::expected behavior proposed in P0323R10.
-
214  constexpr Expected() : Base(boost::outcome_v2::success())
-
215  {
-
216  }
-
217 
-
218  template <
-
219  typename U,
-
220  typename = std::enable_if_t<std::is_convertible_v<U, E>>>
-
221  constexpr Expected(Unexpected<U> e) : Base(E{std::forward<U>(e.value())})
-
222  {
-
223  }
-
224 
-
225  constexpr E const& error() const
-
226  {
-
227  return Base::error();
-
228  }
-
229 
-
230  constexpr E& error()
-
231  {
-
232  return Base::error();
-
233  }
-
234 
-
235  constexpr explicit operator bool() const
-
236  {
-
237  return Base::has_value();
-
238  }
-
239 };
-
240 
-
241 } // namespace ripple
+
24 
+
25 #include <boost/outcome.hpp>
+
26 
+
27 #include <concepts>
+
28 #include <stdexcept>
+
29 #include <type_traits>
+
30 
+
31 namespace ripple {
+
32 
+
40 // Exception thrown by an invalid access to Expected.
+
41 struct bad_expected_access : public std::runtime_error
+
42 {
+
43  bad_expected_access() : runtime_error("bad expected access")
+
44  {
+
45  }
+
46 };
+
47 
+
48 namespace detail {
+
49 
+
50 // Custom policy for Expected. Always throw on an invalid access.
+
51 struct throw_policy : public boost::outcome_v2::policy::base
+
52 {
+
53  template <class Impl>
+
54  static constexpr void
+
55  wide_value_check(Impl&& self)
+
56  {
+
57  if (!base::_has_value(std::forward<Impl>(self)))
+
58  Throw<bad_expected_access>();
+
59  }
+
60 
+
61  template <class Impl>
+
62  static constexpr void
+
63  wide_error_check(Impl&& self)
+
64  {
+
65  if (!base::_has_error(std::forward<Impl>(self)))
+
66  Throw<bad_expected_access>();
+
67  }
+
68 
+
69  template <class Impl>
+
70  static constexpr void
+
71  wide_exception_check(Impl&& self)
+
72  {
+
73  if (!base::_has_exception(std::forward<Impl>(self)))
+
74  Throw<bad_expected_access>();
+
75  }
+
76 };
+
77 
+
78 } // namespace detail
+
79 
+
80 // Definition of Unexpected, which is used to construct the unexpected
+
81 // return type of an Expected.
+
82 template <class E>
+
83 class Unexpected
+
84 {
+
85 public:
+
86  static_assert(!std::is_same<E, void>::value, "E must not be void");
+
87 
+
88  Unexpected() = delete;
+
89 
+
90  constexpr explicit Unexpected(E const& e) : val_(e)
+
91  {
+
92  }
+
93 
+
94  constexpr explicit Unexpected(E&& e) : val_(std::move(e))
+
95  {
+
96  }
+
97 
+
98  constexpr const E&
+
99  value() const&
+
100  {
+
101  return val_;
+
102  }
+
103 
+
104  constexpr E&
+
105  value() &
+
106  {
+
107  return val_;
+
108  }
+
109 
+
110  constexpr E&&
+
111  value() &&
+
112  {
+
113  return std::move(val_);
+
114  }
+
115 
+
116  constexpr const E&&
+
117  value() const&&
+
118  {
+
119  return std::move(val_);
+
120  }
+
121 
+
122 private:
+
123  E val_;
+
124 };
+
125 
+
126 // Unexpected deduction guide that converts array to const*.
+
127 template <typename E, std::size_t N>
+
128 Unexpected(E (&)[N]) -> Unexpected<E const*>;
+
129 
+
130 // Definition of Expected. All of the machinery comes from boost::result.
+
131 template <class T, class E>
+
132 class [[nodiscard]] Expected
+
133  : private boost::outcome_v2::result<T, E, detail::throw_policy>
+
134 {
+
135  using Base = boost::outcome_v2::result<T, E, detail::throw_policy>;
+
136 
+
137 public:
+
138  template <typename U>
+
139  requires std::convertible_to<U, T> constexpr Expected(U && r)
+
140  : Base(T{std::forward<U>(r)})
+
141  {
+
142  }
+
143 
+
144  template <typename U>
+
145  requires std::convertible_to<U, E> &&
+
146  (!std::is_reference_v<U>)constexpr Expected(Unexpected<U> e)
+
147  : Base(E{std::move(e.value())})
+
148  {
+
149  }
+
150 
+
151  constexpr bool has_value() const
+
152  {
+
153  return Base::has_value();
+
154  }
+
155 
+
156  constexpr T const& value() const
+
157  {
+
158  return Base::value();
+
159  }
+
160 
+
161  constexpr T& value()
+
162  {
+
163  return Base::value();
+
164  }
+
165 
+
166  constexpr E const& error() const
+
167  {
+
168  return Base::error();
+
169  }
+
170 
+
171  constexpr E& error()
+
172  {
+
173  return Base::error();
+
174  }
+
175 
+
176  constexpr explicit operator bool() const
+
177  {
+
178  return has_value();
+
179  }
+
180 
+
181  // Add operator* and operator-> so the Expected API looks a bit more like
+
182  // what std::expected is likely to look like. See:
+
183  // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p0323r10.html
+
184  [[nodiscard]] constexpr T& operator*()
+
185  {
+
186  return this->value();
+
187  }
+
188 
+
189  [[nodiscard]] constexpr T const& operator*() const
+
190  {
+
191  return this->value();
+
192  }
+
193 
+
194  [[nodiscard]] constexpr T* operator->()
+
195  {
+
196  return &this->value();
+
197  }
+
198 
+
199  [[nodiscard]] constexpr T const* operator->() const
+
200  {
+
201  return &this->value();
+
202  }
+
203 };
+
204 
+
205 // Specialization of Expected<void, E>. Allows returning either success
+
206 // (without a value) or the reason for the failure.
+
207 template <class E>
+
208 class [[nodiscard]] Expected<void, E>
+
209  : private boost::outcome_v2::result<void, E, detail::throw_policy>
+
210 {
+
211  using Base = boost::outcome_v2::result<void, E, detail::throw_policy>;
+
212 
+
213 public:
+
214  // The default constructor makes a successful Expected<void, E>.
+
215  // This aligns with std::expected behavior proposed in P0323R10.
+
216  constexpr Expected() : Base(boost::outcome_v2::success())
+
217  {
+
218  }
+
219 
+
220  template <typename U>
+
221  requires std::convertible_to<U, E> &&
+
222  (!std::is_reference_v<U>)constexpr Expected(Unexpected<U> e)
+
223  : Base(E{std::move(e.value())})
+
224  {
+
225  }
+
226 
+
227  constexpr E const& error() const
+
228  {
+
229  return Base::error();
+
230  }
+
231 
+
232  constexpr E& error()
+
233  {
+
234  return Base::error();
+
235  }
+
236 
+
237  constexpr explicit operator bool() const
+
238  {
+
239  return Base::has_value();
+
240  }
+
241 };
242 
-
243 #endif // RIPPLE_BASICS_EXPECTED_H_INCLUDED
+
243 } // namespace ripple
+
244 
+
245 #endif // RIPPLE_BASICS_EXPECTED_H_INCLUDED
-
ripple::bad_expected_access::bad_expected_access
bad_expected_access()
Definition: Expected.h:40
+
ripple::bad_expected_access::bad_expected_access
bad_expected_access()
Definition: Expected.h:43
std::is_same
-
ripple::Expected::error
constexpr E & error()
Definition: Expected.h:169
-
ripple::Expected::value
constexpr T const & value() const
Definition: Expected.h:154
-
ripple::bad_expected_access
Expected is an approximation of std::expected (hoped for in C++23)
Definition: Expected.h:38
-
ripple::Expected::error
constexpr E const & error() const
Definition: Expected.h:164
-
ripple::Unexpected::Unexpected
constexpr Unexpected(E const &e)
Definition: Expected.h:87
+
ripple::Expected::error
constexpr E & error()
Definition: Expected.h:171
+
ripple::Expected::value
constexpr T const & value() const
Definition: Expected.h:156
+
ripple::bad_expected_access
Expected is an approximation of std::expected (hoped for in C++23)
Definition: Expected.h:41
+
ripple::Expected::error
constexpr E const & error() const
Definition: Expected.h:166
+
ripple::Expected::Expected
requires constexpr std::convertible_to< U, T > Expected(U &&r)
Definition: Expected.h:139
+
ripple::Unexpected::Unexpected
constexpr Unexpected(E const &e)
Definition: Expected.h:90
ripple::Unexpected
Unexpected(E(&)[N]) -> Unexpected< E const * >
-
ripple::Expected::value
constexpr T & value()
Definition: Expected.h:159
-
ripple::Expected::Expected
constexpr Expected(U r)
Definition: Expected.h:138
+
ripple::Expected::value
constexpr T & value()
Definition: Expected.h:161
boost
Definition: IPAddress.h:103
-
ripple::Expected::has_value
constexpr bool has_value() const
Definition: Expected.h:149
-
ripple::Unexpected::value
constexpr const E && value() const &&
Definition: Expected.h:114
-
ripple::detail::throw_policy
Definition: Expected.h:48
-
ripple::Expected< void, E >::error
constexpr E & error()
Definition: Expected.h:230
+
ripple::Expected::has_value
constexpr bool has_value() const
Definition: Expected.h:151
+
ripple::Unexpected::value
constexpr const E && value() const &&
Definition: Expected.h:117
+
ripple::detail::throw_policy
Definition: Expected.h:51
+
concepts
+
ripple::Expected< void, E >::error
constexpr E & error()
Definition: Expected.h:232
stdexcept
-
ripple::Expected::Expected
constexpr Expected(Unexpected< U > e)
Definition: Expected.h:145
-
ripple::Expected< void, E >::Expected
constexpr Expected(Unexpected< U > e)
Definition: Expected.h:221
-
ripple::Unexpected::value
constexpr const E & value() const &
Definition: Expected.h:96
-
ripple::Unexpected::value
constexpr E & value() &
Definition: Expected.h:102
-
ripple::Expected::Base
boost::outcome_v2::result< T, E, detail::throw_policy > Base
Definition: Expected.h:132
-
ripple::Expected
Definition: Expected.h:129
-
ripple::Expected< void, E >::Expected
constexpr Expected()
Definition: Expected.h:214
-
ripple::detail::throw_policy::wide_value_check
static constexpr void wide_value_check(Impl &&self)
Definition: Expected.h:52
-
std::enable_if_t
-
ripple::Expected::operator->
constexpr T * operator->()
Definition: Expected.h:192
+
ripple::Expected::Expected
requires std::convertible_to< U, E > &&!std constexpr ::is_reference_v< U > Expected(Unexpected< U > e)
Definition: Expected.h:146
+
ripple::Unexpected::value
constexpr const E & value() const &
Definition: Expected.h:99
+
ripple::Unexpected::value
constexpr E & value() &
Definition: Expected.h:105
+
ripple::Expected::Base
boost::outcome_v2::result< T, E, detail::throw_policy > Base
Definition: Expected.h:135
+
ripple::Expected
Definition: Expected.h:132
+
ripple::Expected< void, E >::Expected
constexpr Expected()
Definition: Expected.h:216
+
ripple::detail::throw_policy::wide_value_check
static constexpr void wide_value_check(Impl &&self)
Definition: Expected.h:55
+
ripple::Expected::operator->
constexpr T * operator->()
Definition: Expected.h:194
std::runtime_error
STL class.
-
ripple::detail::throw_policy::wide_error_check
static constexpr void wide_error_check(Impl &&self)
Definition: Expected.h:60
-
ripple::Expected::operator*
constexpr T const & operator*() const
Definition: Expected.h:187
+
ripple::detail::throw_policy::wide_error_check
static constexpr void wide_error_check(Impl &&self)
Definition: Expected.h:63
+
ripple::Expected::operator*
constexpr T const & operator*() const
Definition: Expected.h:189
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
-
ripple::Unexpected::Unexpected
constexpr Unexpected(E &&e)
Definition: Expected.h:91
-
ripple::Expected< void, E >::Base
boost::outcome_v2::result< void, E, detail::throw_policy > Base
Definition: Expected.h:209
+
ripple::Unexpected::Unexpected
constexpr Unexpected(E &&e)
Definition: Expected.h:94
+
ripple::Expected< void, E >::Expected
requires std::convertible_to< U, E > &&!std constexpr ::is_reference_v< U > Expected(Unexpected< U > e)
Definition: Expected.h:222
+
ripple::Expected< void, E >::Base
boost::outcome_v2::result< void, E, detail::throw_policy > Base
Definition: Expected.h:211
std
STL namespace.
-
ripple::Unexpected::value
constexpr E && value() &&
Definition: Expected.h:108
-
ripple::Expected< void, E >::error
constexpr E const & error() const
Definition: Expected.h:225
-
ripple::Unexpected
Definition: Expected.h:80
-
ripple::Expected::operator*
constexpr T & operator*()
Definition: Expected.h:182
+
ripple::Unexpected::value
constexpr E && value() &&
Definition: Expected.h:111
+
ripple::Expected< void, E >::error
constexpr E const & error() const
Definition: Expected.h:227
+
ripple::Unexpected
Definition: Expected.h:83
+
ripple::Expected::operator*
constexpr T & operator*()
Definition: Expected.h:184
ripple::Unexpected::Unexpected
Unexpected()=delete
-
ripple::Expected::operator->
constexpr T const * operator->() const
Definition: Expected.h:197
+
ripple::Expected::operator->
constexpr T const * operator->() const
Definition: Expected.h:199
type_traits
-
ripple::detail::throw_policy::wide_exception_check
static constexpr void wide_exception_check(Impl &&self)
Definition: Expected.h:68
-
ripple::Unexpected::val_
E val_
Definition: Expected.h:120
+
ripple::detail::throw_policy::wide_exception_check
static constexpr void wide_exception_check(Impl &&self)
Definition: Expected.h:71
+
ripple::Unexpected::val_
E val_
Definition: Expected.h:123
Generated by   diff --git a/Expected__test_8cpp_source.html b/Expected__test_8cpp_source.html index 3257193221..b0499f1401 100644 --- a/Expected__test_8cpp_source.html +++ b/Expected__test_8cpp_source.html @@ -286,7 +286,7 @@ $(function() {
ripple::telLOCAL_ERROR
@ telLOCAL_ERROR
Definition: TER.h:51
ripple::Unexpected
Unexpected(E(&)[N]) -> Unexpected< E const * >
ripple::test::Expected_test::run
void run() override
Definition: Expected_test.cpp:32
- + diff --git a/NFTokenAcceptOffer_8cpp_source.html b/NFTokenAcceptOffer_8cpp_source.html index 76be6505b2..16d8c777bb 100644 --- a/NFTokenAcceptOffer_8cpp_source.html +++ b/NFTokenAcceptOffer_8cpp_source.html @@ -138,322 +138,325 @@ $(function() {
67  -> std::pair<std::shared_ptr<const SLE>, TER> {
68  if (id)
69  {
-
70  auto offerSLE = ctx.view.read(keylet::nftoffer(*id));
-
71 
-
72  if (!offerSLE)
-
73  return {nullptr, tecOBJECT_NOT_FOUND};
+
70  if (id->isZero())
+
71  return {nullptr, tecOBJECT_NOT_FOUND};
+
72 
+
73  auto offerSLE = ctx.view.read(keylet::nftoffer(*id));
74 
-
75  if (hasExpired(ctx.view, (*offerSLE)[~sfExpiration]))
-
76  return {nullptr, tecEXPIRED};
+
75  if (!offerSLE)
+
76  return {nullptr, tecOBJECT_NOT_FOUND};
77 
-
78  // The initial implementation had a bug that allowed a negative
-
79  // amount. The fixNFTokenNegOffer amendment fixes that.
-
80  if ((*offerSLE)[sfAmount].negative() &&
-
81  ctx.view.rules().enabled(fixNFTokenNegOffer))
-
82  return {nullptr, temBAD_OFFER};
-
83 
-
84  return {std::move(offerSLE), tesSUCCESS};
-
85  }
-
86  return {nullptr, tesSUCCESS};
-
87  };
-
88 
-
89  auto const [bo, err1] = checkOffer(ctx.tx[~sfNFTokenBuyOffer]);
-
90  if (!isTesSuccess(err1))
-
91  return err1;
-
92  auto const [so, err2] = checkOffer(ctx.tx[~sfNFTokenSellOffer]);
-
93  if (!isTesSuccess(err2))
-
94  return err2;
-
95 
-
96  if (bo && so)
-
97  {
-
98  // Brokered mode:
-
99  // The two offers being brokered must be for the same token:
-
100  if ((*bo)[sfNFTokenID] != (*so)[sfNFTokenID])
-
101  return tecNFTOKEN_BUY_SELL_MISMATCH;
-
102 
-
103  // The two offers being brokered must be for the same asset:
-
104  if ((*bo)[sfAmount].issue() != (*so)[sfAmount].issue())
-
105  return tecNFTOKEN_BUY_SELL_MISMATCH;
-
106 
-
107  // Ensure that the buyer is willing to pay at least as much as the
-
108  // seller is requesting:
-
109  if ((*so)[sfAmount] > (*bo)[sfAmount])
-
110  return tecINSUFFICIENT_PAYMENT;
-
111 
-
112  // If the buyer specified a destination, that destination must be
-
113  // the seller or the broker.
-
114  if (auto const dest = bo->at(~sfDestination))
-
115  {
-
116  if (*dest != so->at(sfOwner) && *dest != ctx.tx[sfAccount])
-
117  return tecNFTOKEN_BUY_SELL_MISMATCH;
-
118  }
-
119 
-
120  // If the seller specified a destination, that destination must be
-
121  // the buyer or the broker.
-
122  if (auto const dest = so->at(~sfDestination))
-
123  {
-
124  if (*dest != bo->at(sfOwner) && *dest != ctx.tx[sfAccount])
-
125  return tecNFTOKEN_BUY_SELL_MISMATCH;
-
126  }
-
127 
-
128  // The broker can specify an amount that represents their cut; if they
-
129  // have, ensure that the seller will get at least as much as they want
-
130  // to get *after* this fee is accounted for (but before the issuer's
-
131  // cut, if any).
-
132  if (auto const brokerFee = ctx.tx[~sfNFTokenBrokerFee])
-
133  {
-
134  if (brokerFee->issue() != (*bo)[sfAmount].issue())
-
135  return tecNFTOKEN_BUY_SELL_MISMATCH;
-
136 
-
137  if (brokerFee >= (*bo)[sfAmount])
-
138  return tecINSUFFICIENT_PAYMENT;
+
78  if (hasExpired(ctx.view, (*offerSLE)[~sfExpiration]))
+
79  return {nullptr, tecEXPIRED};
+
80 
+
81  // The initial implementation had a bug that allowed a negative
+
82  // amount. The fixNFTokenNegOffer amendment fixes that.
+
83  if ((*offerSLE)[sfAmount].negative() &&
+
84  ctx.view.rules().enabled(fixNFTokenNegOffer))
+
85  return {nullptr, temBAD_OFFER};
+
86 
+
87  return {std::move(offerSLE), tesSUCCESS};
+
88  }
+
89  return {nullptr, tesSUCCESS};
+
90  };
+
91 
+
92  auto const [bo, err1] = checkOffer(ctx.tx[~sfNFTokenBuyOffer]);
+
93  if (!isTesSuccess(err1))
+
94  return err1;
+
95  auto const [so, err2] = checkOffer(ctx.tx[~sfNFTokenSellOffer]);
+
96  if (!isTesSuccess(err2))
+
97  return err2;
+
98 
+
99  if (bo && so)
+
100  {
+
101  // Brokered mode:
+
102  // The two offers being brokered must be for the same token:
+
103  if ((*bo)[sfNFTokenID] != (*so)[sfNFTokenID])
+
104  return tecNFTOKEN_BUY_SELL_MISMATCH;
+
105 
+
106  // The two offers being brokered must be for the same asset:
+
107  if ((*bo)[sfAmount].issue() != (*so)[sfAmount].issue())
+
108  return tecNFTOKEN_BUY_SELL_MISMATCH;
+
109 
+
110  // Ensure that the buyer is willing to pay at least as much as the
+
111  // seller is requesting:
+
112  if ((*so)[sfAmount] > (*bo)[sfAmount])
+
113  return tecINSUFFICIENT_PAYMENT;
+
114 
+
115  // If the buyer specified a destination, that destination must be
+
116  // the seller or the broker.
+
117  if (auto const dest = bo->at(~sfDestination))
+
118  {
+
119  if (*dest != so->at(sfOwner) && *dest != ctx.tx[sfAccount])
+
120  return tecNFTOKEN_BUY_SELL_MISMATCH;
+
121  }
+
122 
+
123  // If the seller specified a destination, that destination must be
+
124  // the buyer or the broker.
+
125  if (auto const dest = so->at(~sfDestination))
+
126  {
+
127  if (*dest != bo->at(sfOwner) && *dest != ctx.tx[sfAccount])
+
128  return tecNFTOKEN_BUY_SELL_MISMATCH;
+
129  }
+
130 
+
131  // The broker can specify an amount that represents their cut; if they
+
132  // have, ensure that the seller will get at least as much as they want
+
133  // to get *after* this fee is accounted for (but before the issuer's
+
134  // cut, if any).
+
135  if (auto const brokerFee = ctx.tx[~sfNFTokenBrokerFee])
+
136  {
+
137  if (brokerFee->issue() != (*bo)[sfAmount].issue())
+
138  return tecNFTOKEN_BUY_SELL_MISMATCH;
139 
-
140  if ((*so)[sfAmount] > (*bo)[sfAmount] - *brokerFee)
+
140  if (brokerFee >= (*bo)[sfAmount])
141  return tecINSUFFICIENT_PAYMENT;
-
142  }
-
143  }
-
144 
-
145  if (bo)
-
146  {
-
147  if (((*bo)[sfFlags] & lsfSellNFToken) == lsfSellNFToken)
-
148  return tecNFTOKEN_OFFER_TYPE_MISMATCH;
-
149 
-
150  // An account can't accept an offer it placed:
-
151  if ((*bo)[sfOwner] == ctx.tx[sfAccount])
-
152  return tecCANT_ACCEPT_OWN_NFTOKEN_OFFER;
-
153 
-
154  // If not in bridged mode, the account must own the token:
-
155  if (!so &&
-
156  !nft::findToken(ctx.view, ctx.tx[sfAccount], (*bo)[sfNFTokenID]))
-
157  return tecNO_PERMISSION;
-
158 
-
159  // If not in bridged mode...
-
160  if (!so)
-
161  {
-
162  // If the offer has a Destination field, the acceptor must be the
-
163  // Destination.
-
164  if (auto const dest = bo->at(~sfDestination);
-
165  dest.has_value() && *dest != ctx.tx[sfAccount])
-
166  return tecNO_PERMISSION;
-
167  }
-
168  // The account offering to buy must have funds:
-
169  auto const needed = bo->at(sfAmount);
-
170 
-
171  if (accountHolds(
-
172  ctx.view,
-
173  (*bo)[sfOwner],
-
174  needed.getCurrency(),
-
175  needed.getIssuer(),
-
176  fhZERO_IF_FROZEN,
-
177  ctx.j) < needed)
-
178  return tecINSUFFICIENT_FUNDS;
-
179  }
-
180 
-
181  if (so)
-
182  {
-
183  if (((*so)[sfFlags] & lsfSellNFToken) != lsfSellNFToken)
-
184  return tecNFTOKEN_OFFER_TYPE_MISMATCH;
-
185 
-
186  // An account can't accept an offer it placed:
-
187  if ((*so)[sfOwner] == ctx.tx[sfAccount])
-
188  return tecCANT_ACCEPT_OWN_NFTOKEN_OFFER;
-
189 
-
190  // The seller must own the token.
-
191  if (!nft::findToken(ctx.view, (*so)[sfOwner], (*so)[sfNFTokenID]))
-
192  return tecNO_PERMISSION;
-
193 
-
194  // If not in bridged mode...
-
195  if (!bo)
-
196  {
-
197  // If the offer has a Destination field, the acceptor must be the
-
198  // Destination.
-
199  if (auto const dest = so->at(~sfDestination);
-
200  dest.has_value() && *dest != ctx.tx[sfAccount])
-
201  return tecNO_PERMISSION;
-
202  }
-
203 
-
204  // The account offering to buy must have funds:
-
205  auto const needed = so->at(sfAmount);
+
142 
+
143  if ((*so)[sfAmount] > (*bo)[sfAmount] - *brokerFee)
+
144  return tecINSUFFICIENT_PAYMENT;
+
145  }
+
146  }
+
147 
+
148  if (bo)
+
149  {
+
150  if (((*bo)[sfFlags] & lsfSellNFToken) == lsfSellNFToken)
+
151  return tecNFTOKEN_OFFER_TYPE_MISMATCH;
+
152 
+
153  // An account can't accept an offer it placed:
+
154  if ((*bo)[sfOwner] == ctx.tx[sfAccount])
+
155  return tecCANT_ACCEPT_OWN_NFTOKEN_OFFER;
+
156 
+
157  // If not in bridged mode, the account must own the token:
+
158  if (!so &&
+
159  !nft::findToken(ctx.view, ctx.tx[sfAccount], (*bo)[sfNFTokenID]))
+
160  return tecNO_PERMISSION;
+
161 
+
162  // If not in bridged mode...
+
163  if (!so)
+
164  {
+
165  // If the offer has a Destination field, the acceptor must be the
+
166  // Destination.
+
167  if (auto const dest = bo->at(~sfDestination);
+
168  dest.has_value() && *dest != ctx.tx[sfAccount])
+
169  return tecNO_PERMISSION;
+
170  }
+
171  // The account offering to buy must have funds:
+
172  auto const needed = bo->at(sfAmount);
+
173 
+
174  if (accountHolds(
+
175  ctx.view,
+
176  (*bo)[sfOwner],
+
177  needed.getCurrency(),
+
178  needed.getIssuer(),
+
179  fhZERO_IF_FROZEN,
+
180  ctx.j) < needed)
+
181  return tecINSUFFICIENT_FUNDS;
+
182  }
+
183 
+
184  if (so)
+
185  {
+
186  if (((*so)[sfFlags] & lsfSellNFToken) != lsfSellNFToken)
+
187  return tecNFTOKEN_OFFER_TYPE_MISMATCH;
+
188 
+
189  // An account can't accept an offer it placed:
+
190  if ((*so)[sfOwner] == ctx.tx[sfAccount])
+
191  return tecCANT_ACCEPT_OWN_NFTOKEN_OFFER;
+
192 
+
193  // The seller must own the token.
+
194  if (!nft::findToken(ctx.view, (*so)[sfOwner], (*so)[sfNFTokenID]))
+
195  return tecNO_PERMISSION;
+
196 
+
197  // If not in bridged mode...
+
198  if (!bo)
+
199  {
+
200  // If the offer has a Destination field, the acceptor must be the
+
201  // Destination.
+
202  if (auto const dest = so->at(~sfDestination);
+
203  dest.has_value() && *dest != ctx.tx[sfAccount])
+
204  return tecNO_PERMISSION;
+
205  }
206 
-
207  if (accountHolds(
-
208  ctx.view,
-
209  ctx.tx[sfAccount],
-
210  needed.getCurrency(),
-
211  needed.getIssuer(),
-
212  fhZERO_IF_FROZEN,
-
213  ctx.j) < needed)
-
214  return tecINSUFFICIENT_FUNDS;
-
215  }
-
216 
-
217  return tesSUCCESS;
-
218 }
+
207  // The account offering to buy must have funds:
+
208  auto const needed = so->at(sfAmount);
+
209 
+
210  if (accountHolds(
+
211  ctx.view,
+
212  ctx.tx[sfAccount],
+
213  needed.getCurrency(),
+
214  needed.getIssuer(),
+
215  fhZERO_IF_FROZEN,
+
216  ctx.j) < needed)
+
217  return tecINSUFFICIENT_FUNDS;
+
218  }
219 
-
220 TER
-
221 NFTokenAcceptOffer::pay(
-
222  AccountID const& from,
-
223  AccountID const& to,
-
224  STAmount const& amount)
-
225 {
-
226  // This should never happen, but it's easy and quick to check.
-
227  if (amount < beast::zero)
-
228  return tecINTERNAL;
-
229 
-
230  return accountSend(view(), from, to, amount, j_);
-
231 }
+
220  return tesSUCCESS;
+
221 }
+
222 
+
223 TER
+
224 NFTokenAcceptOffer::pay(
+
225  AccountID const& from,
+
226  AccountID const& to,
+
227  STAmount const& amount)
+
228 {
+
229  // This should never happen, but it's easy and quick to check.
+
230  if (amount < beast::zero)
+
231  return tecINTERNAL;
232 
-
233 TER
-
234 NFTokenAcceptOffer::acceptOffer(std::shared_ptr<SLE> const& offer)
-
235 {
-
236  bool const isSell = offer->isFlag(lsfSellNFToken);
-
237  AccountID const owner = (*offer)[sfOwner];
-
238  AccountID const& seller = isSell ? owner : account_;
-
239  AccountID const& buyer = isSell ? account_ : owner;
-
240 
-
241  auto const nftokenID = (*offer)[sfNFTokenID];
-
242 
-
243  if (auto amount = offer->getFieldAmount(sfAmount); amount != beast::zero)
-
244  {
-
245  // Calculate the issuer's cut from this sale, if any:
-
246  if (auto const fee = nft::getTransferFee(nftokenID); fee != 0)
-
247  {
-
248  auto const cut = multiply(amount, nft::transferFeeAsRate(fee));
-
249 
-
250  if (auto const issuer = nft::getIssuer(nftokenID);
-
251  cut != beast::zero && seller != issuer && buyer != issuer)
-
252  {
-
253  if (auto const r = pay(buyer, issuer, cut); !isTesSuccess(r))
-
254  return r;
-
255  amount -= cut;
-
256  }
-
257  }
-
258 
-
259  // Send the remaining funds to the seller of the NFT
-
260  if (auto const r = pay(buyer, seller, amount); !isTesSuccess(r))
-
261  return r;
-
262  }
-
263 
-
264  // Now transfer the NFT:
-
265  auto tokenAndPage = nft::findTokenAndPage(view(), seller, nftokenID);
+
233  return accountSend(view(), from, to, amount, j_);
+
234 }
+
235 
+
236 TER
+
237 NFTokenAcceptOffer::acceptOffer(std::shared_ptr<SLE> const& offer)
+
238 {
+
239  bool const isSell = offer->isFlag(lsfSellNFToken);
+
240  AccountID const owner = (*offer)[sfOwner];
+
241  AccountID const& seller = isSell ? owner : account_;
+
242  AccountID const& buyer = isSell ? account_ : owner;
+
243 
+
244  auto const nftokenID = (*offer)[sfNFTokenID];
+
245 
+
246  if (auto amount = offer->getFieldAmount(sfAmount); amount != beast::zero)
+
247  {
+
248  // Calculate the issuer's cut from this sale, if any:
+
249  if (auto const fee = nft::getTransferFee(nftokenID); fee != 0)
+
250  {
+
251  auto const cut = multiply(amount, nft::transferFeeAsRate(fee));
+
252 
+
253  if (auto const issuer = nft::getIssuer(nftokenID);
+
254  cut != beast::zero && seller != issuer && buyer != issuer)
+
255  {
+
256  if (auto const r = pay(buyer, issuer, cut); !isTesSuccess(r))
+
257  return r;
+
258  amount -= cut;
+
259  }
+
260  }
+
261 
+
262  // Send the remaining funds to the seller of the NFT
+
263  if (auto const r = pay(buyer, seller, amount); !isTesSuccess(r))
+
264  return r;
+
265  }
266 
-
267  if (!tokenAndPage)
-
268  return tecINTERNAL;
+
267  // Now transfer the NFT:
+
268  auto tokenAndPage = nft::findTokenAndPage(view(), seller, nftokenID);
269 
-
270  if (auto const ret = nft::removeToken(
-
271  view(), seller, nftokenID, std::move(tokenAndPage->page));
-
272  !isTesSuccess(ret))
-
273  return ret;
-
274 
-
275  return nft::insertToken(view(), buyer, std::move(tokenAndPage->token));
-
276 }
+
270  if (!tokenAndPage)
+
271  return tecINTERNAL;
+
272 
+
273  if (auto const ret = nft::removeToken(
+
274  view(), seller, nftokenID, std::move(tokenAndPage->page));
+
275  !isTesSuccess(ret))
+
276  return ret;
277 
-
278 TER
-
279 NFTokenAcceptOffer::doApply()
-
280 {
-
281  auto const loadToken = [this](std::optional<uint256> const& id) {
-
282  std::shared_ptr<SLE> sle;
-
283  if (id)
-
284  sle = view().peek(keylet::nftoffer(*id));
-
285  return sle;
-
286  };
-
287 
-
288  auto bo = loadToken(ctx_.tx[~sfNFTokenBuyOffer]);
-
289  auto so = loadToken(ctx_.tx[~sfNFTokenSellOffer]);
+
278  return nft::insertToken(view(), buyer, std::move(tokenAndPage->token));
+
279 }
+
280 
+
281 TER
+
282 NFTokenAcceptOffer::doApply()
+
283 {
+
284  auto const loadToken = [this](std::optional<uint256> const& id) {
+
285  std::shared_ptr<SLE> sle;
+
286  if (id)
+
287  sle = view().peek(keylet::nftoffer(*id));
+
288  return sle;
+
289  };
290 
-
291  if (bo && !nft::deleteTokenOffer(view(), bo))
-
292  {
-
293  JLOG(j_.fatal()) << "Unable to delete buy offer '"
-
294  << to_string(bo->key()) << "': ignoring";
-
295  return tecINTERNAL;
-
296  }
-
297 
-
298  if (so && !nft::deleteTokenOffer(view(), so))
-
299  {
-
300  JLOG(j_.fatal()) << "Unable to delete sell offer '"
-
301  << to_string(so->key()) << "': ignoring";
-
302  return tecINTERNAL;
-
303  }
-
304 
-
305  // Bridging two different offers
-
306  if (bo && so)
-
307  {
-
308  AccountID const buyer = (*bo)[sfOwner];
-
309  AccountID const seller = (*so)[sfOwner];
-
310 
-
311  auto const nftokenID = (*so)[sfNFTokenID];
-
312 
-
313  // The amount is what the buyer of the NFT pays:
-
314  STAmount amount = (*bo)[sfAmount];
+
291  auto bo = loadToken(ctx_.tx[~sfNFTokenBuyOffer]);
+
292  auto so = loadToken(ctx_.tx[~sfNFTokenSellOffer]);
+
293 
+
294  if (bo && !nft::deleteTokenOffer(view(), bo))
+
295  {
+
296  JLOG(j_.fatal()) << "Unable to delete buy offer '"
+
297  << to_string(bo->key()) << "': ignoring";
+
298  return tecINTERNAL;
+
299  }
+
300 
+
301  if (so && !nft::deleteTokenOffer(view(), so))
+
302  {
+
303  JLOG(j_.fatal()) << "Unable to delete sell offer '"
+
304  << to_string(so->key()) << "': ignoring";
+
305  return tecINTERNAL;
+
306  }
+
307 
+
308  // Bridging two different offers
+
309  if (bo && so)
+
310  {
+
311  AccountID const buyer = (*bo)[sfOwner];
+
312  AccountID const seller = (*so)[sfOwner];
+
313 
+
314  auto const nftokenID = (*so)[sfNFTokenID];
315 
-
316  // Three different folks may be paid. The order of operations is
-
317  // important.
-
318  //
-
319  // o The broker is paid the cut they requested.
-
320  // o The issuer's cut is calculated from what remains after the
-
321  // broker is paid. The issuer can take up to 50% of the remainder.
-
322  // o Finally, the seller gets whatever is left.
-
323  //
-
324  // It is important that the issuer's cut be calculated after the
-
325  // broker's portion is already removed. Calculating the issuer's
-
326  // cut before the broker's cut is removed can result in more money
-
327  // being paid out than the seller authorized. That would be bad!
-
328 
-
329  // Send the broker the amount they requested.
-
330  if (auto const cut = ctx_.tx[~sfNFTokenBrokerFee];
-
331  cut && cut.value() != beast::zero)
-
332  {
-
333  if (auto const r = pay(buyer, account_, cut.value());
-
334  !isTesSuccess(r))
-
335  return r;
-
336 
-
337  amount -= cut.value();
-
338  }
+
316  // The amount is what the buyer of the NFT pays:
+
317  STAmount amount = (*bo)[sfAmount];
+
318 
+
319  // Three different folks may be paid. The order of operations is
+
320  // important.
+
321  //
+
322  // o The broker is paid the cut they requested.
+
323  // o The issuer's cut is calculated from what remains after the
+
324  // broker is paid. The issuer can take up to 50% of the remainder.
+
325  // o Finally, the seller gets whatever is left.
+
326  //
+
327  // It is important that the issuer's cut be calculated after the
+
328  // broker's portion is already removed. Calculating the issuer's
+
329  // cut before the broker's cut is removed can result in more money
+
330  // being paid out than the seller authorized. That would be bad!
+
331 
+
332  // Send the broker the amount they requested.
+
333  if (auto const cut = ctx_.tx[~sfNFTokenBrokerFee];
+
334  cut && cut.value() != beast::zero)
+
335  {
+
336  if (auto const r = pay(buyer, account_, cut.value());
+
337  !isTesSuccess(r))
+
338  return r;
339 
-
340  // Calculate the issuer's cut, if any.
-
341  if (auto const fee = nft::getTransferFee(nftokenID);
-
342  amount != beast::zero && fee != 0)
-
343  {
-
344  auto cut = multiply(amount, nft::transferFeeAsRate(fee));
-
345 
-
346  if (auto const issuer = nft::getIssuer(nftokenID);
-
347  seller != issuer && buyer != issuer)
-
348  {
-
349  if (auto const r = pay(buyer, issuer, cut); !isTesSuccess(r))
-
350  return r;
-
351 
-
352  amount -= cut;
-
353  }
-
354  }
-
355 
-
356  // And send whatever remains to the seller.
-
357  if (amount > beast::zero)
-
358  {
-
359  if (auto const r = pay(buyer, seller, amount); !isTesSuccess(r))
-
360  return r;
-
361  }
-
362 
-
363  auto tokenAndPage = nft::findTokenAndPage(view(), seller, nftokenID);
-
364 
-
365  if (!tokenAndPage)
-
366  return tecINTERNAL;
+
340  amount -= cut.value();
+
341  }
+
342 
+
343  // Calculate the issuer's cut, if any.
+
344  if (auto const fee = nft::getTransferFee(nftokenID);
+
345  amount != beast::zero && fee != 0)
+
346  {
+
347  auto cut = multiply(amount, nft::transferFeeAsRate(fee));
+
348 
+
349  if (auto const issuer = nft::getIssuer(nftokenID);
+
350  seller != issuer && buyer != issuer)
+
351  {
+
352  if (auto const r = pay(buyer, issuer, cut); !isTesSuccess(r))
+
353  return r;
+
354 
+
355  amount -= cut;
+
356  }
+
357  }
+
358 
+
359  // And send whatever remains to the seller.
+
360  if (amount > beast::zero)
+
361  {
+
362  if (auto const r = pay(buyer, seller, amount); !isTesSuccess(r))
+
363  return r;
+
364  }
+
365 
+
366  auto tokenAndPage = nft::findTokenAndPage(view(), seller, nftokenID);
367 
-
368  if (auto const ret = nft::removeToken(
-
369  view(), seller, nftokenID, std::move(tokenAndPage->page));
-
370  !isTesSuccess(ret))
-
371  return ret;
-
372 
-
373  return nft::insertToken(view(), buyer, std::move(tokenAndPage->token));
-
374  }
+
368  if (!tokenAndPage)
+
369  return tecINTERNAL;
+
370 
+
371  if (auto const ret = nft::removeToken(
+
372  view(), seller, nftokenID, std::move(tokenAndPage->page));
+
373  !isTesSuccess(ret))
+
374  return ret;
375 
-
376  if (bo)
-
377  return acceptOffer(bo);
+
376  return nft::insertToken(view(), buyer, std::move(tokenAndPage->token));
+
377  }
378 
-
379  if (so)
-
380  return acceptOffer(so);
+
379  if (bo)
+
380  return acceptOffer(bo);
381 
-
382  return tecINTERNAL;
-
383 }
+
382  if (so)
+
383  return acceptOffer(so);
384 
-
385 } // namespace ripple
+
385  return tecINTERNAL;
+
386 }
+
387 
+
388 } // namespace ripple
beast::Journal::fatal
Stream fatal() const
Definition: Journal.h:339
ripple::tecOBJECT_NOT_FOUND
@ tecOBJECT_NOT_FOUND
Definition: TER.h:290
@@ -473,7 +476,7 @@ $(function() {
ripple::Transactor::j_
const beast::Journal j_
Definition: Transactor.h:89
ripple::nft::findTokenAndPage
std::optional< TokenAndPage > findTokenAndPage(ApplyView &view, AccountID const &owner, uint256 const &nftokenID)
Definition: NFTokenUtils.cpp:502
ripple::isTesSuccess
bool isTesSuccess(TER x)
Definition: TER.h:594
-
ripple::NFTokenAcceptOffer::pay
TER pay(AccountID const &from, AccountID const &to, STAmount const &amount)
Definition: NFTokenAcceptOffer.cpp:221
+
ripple::NFTokenAcceptOffer::pay
TER pay(AccountID const &from, AccountID const &to, STAmount const &amount)
Definition: NFTokenAcceptOffer.cpp:224
ripple::tecINSUFFICIENT_FUNDS
@ tecINSUFFICIENT_FUNDS
Definition: TER.h:289
ripple::sfOwner
const SF_ACCOUNT sfOwner
@@ -499,13 +502,13 @@ $(function() {
ripple::tecINTERNAL
@ tecINTERNAL
Definition: TER.h:274
ripple::STObject::getFlags
std::uint32_t getFlags() const
Definition: STObject.cpp:481
-
ripple::NFTokenAcceptOffer::acceptOffer
TER acceptOffer(std::shared_ptr< SLE > const &offer)
Definition: NFTokenAcceptOffer.cpp:234
+
ripple::NFTokenAcceptOffer::acceptOffer
TER acceptOffer(std::shared_ptr< SLE > const &offer)
Definition: NFTokenAcceptOffer.cpp:237
ripple::ReadView::read
virtual std::shared_ptr< SLE const > read(Keylet const &k) const =0
Return the state item associated with a key.
ripple::multiply
STAmount multiply(STAmount const &amount, Rate const &rate)
Definition: Rate2.cpp:47
ripple::PreclaimContext
State information when determining if a tx is likely to claim a fee.
Definition: Transactor.h:52
ripple::sfNFTokenBuyOffer
const SF_UINT256 sfNFTokenBuyOffer
- +
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
ripple::featureNonFungibleTokensV1
const uint256 featureNonFungibleTokensV1
ripple::tecNFTOKEN_BUY_SELL_MISMATCH
@ tecNFTOKEN_BUY_SELL_MISMATCH
Definition: TER.h:286
diff --git a/NFTokenAcceptOffer_8h_source.html b/NFTokenAcceptOffer_8h_source.html index 0204f9c7ca..ce96d98aa5 100644 --- a/NFTokenAcceptOffer_8h_source.html +++ b/NFTokenAcceptOffer_8h_source.html @@ -132,7 +132,7 @@ $(function() {
std::shared_ptr
STL class.
-
ripple::NFTokenAcceptOffer::pay
TER pay(AccountID const &from, AccountID const &to, STAmount const &amount)
Definition: NFTokenAcceptOffer.cpp:221
+
ripple::NFTokenAcceptOffer::pay
TER pay(AccountID const &from, AccountID const &to, STAmount const &amount)
Definition: NFTokenAcceptOffer.cpp:224
ripple::NFTokenAcceptOffer::NFTokenAcceptOffer
NFTokenAcceptOffer(ApplyContext &ctx)
Definition: NFTokenAcceptOffer.h:44
ripple::NFTokenAcceptOffer::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: NFTokenAcceptOffer.cpp:31
ripple::NFTokenAcceptOffer::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: NFTokenAcceptOffer.cpp:64
@@ -142,9 +142,9 @@ $(function() {
ripple::ApplyContext
State information when applying a tx.
Definition: ApplyContext.h:35
-
ripple::NFTokenAcceptOffer::acceptOffer
TER acceptOffer(std::shared_ptr< SLE > const &offer)
Definition: NFTokenAcceptOffer.cpp:234
+
ripple::NFTokenAcceptOffer::acceptOffer
TER acceptOffer(std::shared_ptr< SLE > const &offer)
Definition: NFTokenAcceptOffer.cpp:237
ripple::PreclaimContext
State information when determining if a tx is likely to claim a fee.
Definition: Transactor.h:52
- +
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
ripple::PreflightContext
State information when preflighting a tx.
Definition: Transactor.h:31
diff --git a/NFTokenMint_8cpp_source.html b/NFTokenMint_8cpp_source.html index 386e7bfb5e..cd996607b3 100644 --- a/NFTokenMint_8cpp_source.html +++ b/NFTokenMint_8cpp_source.html @@ -323,7 +323,7 @@ $(function() {
ripple::base_uint
Integers of any length that is a multiple of 32-bits.
Definition: base_uint.h:81
ripple::NFTokenMint::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: NFTokenMint.cpp:35
ripple::temINVALID_FLAG
@ temINVALID_FLAG
Definition: TER.h:106
- +
ripple::SOTemplate
Defines the fields and their attributes within a STObject.
Definition: SOTemplate.h:82
ripple::keylet::account
Keylet account(AccountID const &id) noexcept
AccountID root.
Definition: Indexes.cpp:133
ripple::sfNFTokenMinter
const SF_ACCOUNT sfNFTokenMinter
diff --git a/NFToken__test_8cpp_source.html b/NFToken__test_8cpp_source.html index 8b8882a4a0..82b76e9e2e 100644 --- a/NFToken__test_8cpp_source.html +++ b/NFToken__test_8cpp_source.html @@ -1201,3822 +1201,3834 @@ $(function() {
1130  //----------------------------------------------------------------------
1131  // preclaim
1132 
-
1133  // The buy offer must be present in the ledger.
-
1134  uint256 const missingOfferIndex = keylet::nftoffer(alice, 1).key;
-
1135  env(token::acceptBuyOffer(buyer, missingOfferIndex),
-
1136  ter(tecOBJECT_NOT_FOUND));
-
1137  env.close();
-
1138  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
1139 
-
1140  // The buy offer must not have expired.
-
1141  env(token::acceptBuyOffer(buyer, aliceExpOfferIndex), ter(tecEXPIRED));
-
1142  env.close();
-
1143  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
1144 
-
1145  // The sell offer must be present in the ledger.
-
1146  env(token::acceptSellOffer(buyer, missingOfferIndex),
-
1147  ter(tecOBJECT_NOT_FOUND));
+
1133  // The buy offer must be non-zero.
+
1134  env(token::acceptBuyOffer(buyer, beast::zero),
+
1135  ter(tecOBJECT_NOT_FOUND));
+
1136  env.close();
+
1137  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
1138 
+
1139  // The buy offer must be present in the ledger.
+
1140  uint256 const missingOfferIndex = keylet::nftoffer(alice, 1).key;
+
1141  env(token::acceptBuyOffer(buyer, missingOfferIndex),
+
1142  ter(tecOBJECT_NOT_FOUND));
+
1143  env.close();
+
1144  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
1145 
+
1146  // The buy offer must not have expired.
+
1147  env(token::acceptBuyOffer(buyer, aliceExpOfferIndex), ter(tecEXPIRED));
1148  env.close();
1149  BEAST_EXPECT(ownerCount(env, buyer) == 0);
1150 
-
1151  // The sell offer must not have expired.
-
1152  env(token::acceptSellOffer(buyer, aliceExpOfferIndex), ter(tecEXPIRED));
-
1153  env.close();
-
1154  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
1155 
-
1156  //----------------------------------------------------------------------
-
1157  // preclaim brokered
-
1158 
-
1159  // alice and buyer need trustlines before buyer can to create an
-
1160  // offer for gwAUD.
-
1161  env(trust(alice, gwAUD(1000)));
-
1162  env(trust(buyer, gwAUD(1000)));
-
1163  env.close();
-
1164  env(pay(gw, buyer, gwAUD(30)));
+
1151  // The sell offer must be non-zero.
+
1152  env(token::acceptSellOffer(buyer, beast::zero),
+
1153  ter(tecOBJECT_NOT_FOUND));
+
1154  env.close();
+
1155  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
1156 
+
1157  // The sell offer must be present in the ledger.
+
1158  env(token::acceptSellOffer(buyer, missingOfferIndex),
+
1159  ter(tecOBJECT_NOT_FOUND));
+
1160  env.close();
+
1161  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
1162 
+
1163  // The sell offer must not have expired.
+
1164  env(token::acceptSellOffer(buyer, aliceExpOfferIndex), ter(tecEXPIRED));
1165  env.close();
-
1166  BEAST_EXPECT(ownerCount(env, alice) == 7);
-
1167  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
1168 
-
1169  // We're about to exercise offer brokering, so we need
-
1170  // corresponding buy and sell offers.
-
1171  {
-
1172  // buyer creates a buy offer for one of alice's nfts.
-
1173  uint256 const buyerOfferIndex =
-
1174  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
1175  env(token::createOffer(buyer, nftAlice0ID, gwAUD(29)),
-
1176  token::owner(alice));
-
1177  env.close();
-
1178  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
1179 
-
1180  // gw attempts to broker offers that are not for the same token.
-
1181  env(token::brokerOffers(gw, buyerOfferIndex, xrpOnlyOfferIndex),
-
1182  ter(tecNFTOKEN_BUY_SELL_MISMATCH));
-
1183  env.close();
-
1184  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
1185 
-
1186  // gw attempts to broker offers that are not for the same currency.
-
1187  env(token::brokerOffers(gw, buyerOfferIndex, plainOfferIndex),
-
1188  ter(tecNFTOKEN_BUY_SELL_MISMATCH));
+
1166  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
1167 
+
1168  //----------------------------------------------------------------------
+
1169  // preclaim brokered
+
1170 
+
1171  // alice and buyer need trustlines before buyer can to create an
+
1172  // offer for gwAUD.
+
1173  env(trust(alice, gwAUD(1000)));
+
1174  env(trust(buyer, gwAUD(1000)));
+
1175  env.close();
+
1176  env(pay(gw, buyer, gwAUD(30)));
+
1177  env.close();
+
1178  BEAST_EXPECT(ownerCount(env, alice) == 7);
+
1179  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
1180 
+
1181  // We're about to exercise offer brokering, so we need
+
1182  // corresponding buy and sell offers.
+
1183  {
+
1184  // buyer creates a buy offer for one of alice's nfts.
+
1185  uint256 const buyerOfferIndex =
+
1186  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
1187  env(token::createOffer(buyer, nftAlice0ID, gwAUD(29)),
+
1188  token::owner(alice));
1189  env.close();
1190  BEAST_EXPECT(ownerCount(env, buyer) == 2);
1191 
-
1192  // In a brokered offer, the buyer must offer greater than or
-
1193  // equal to the selling price.
-
1194  env(token::brokerOffers(gw, buyerOfferIndex, audOfferIndex),
-
1195  ter(tecINSUFFICIENT_PAYMENT));
-
1196  env.close();
-
1197  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
1198 
-
1199  // Remove buyer's offer.
-
1200  env(token::cancelOffer(buyer, {buyerOfferIndex}));
+
1192  // gw attempts to broker offers that are not for the same token.
+
1193  env(token::brokerOffers(gw, buyerOfferIndex, xrpOnlyOfferIndex),
+
1194  ter(tecNFTOKEN_BUY_SELL_MISMATCH));
+
1195  env.close();
+
1196  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
1197 
+
1198  // gw attempts to broker offers that are not for the same currency.
+
1199  env(token::brokerOffers(gw, buyerOfferIndex, plainOfferIndex),
+
1200  ter(tecNFTOKEN_BUY_SELL_MISMATCH));
1201  env.close();
-
1202  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
1203  }
-
1204  {
-
1205  // buyer creates a buy offer for one of alice's nfts.
-
1206  uint256 const buyerOfferIndex =
-
1207  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
1208  env(token::createOffer(buyer, nftAlice0ID, gwAUD(31)),
-
1209  token::owner(alice));
-
1210  env.close();
-
1211  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
1212 
-
1213  // Broker sets their fee in a denomination other than the one
-
1214  // used by the offers
-
1215  env(token::brokerOffers(gw, buyerOfferIndex, audOfferIndex),
-
1216  token::brokerFee(XRP(40)),
-
1217  ter(tecNFTOKEN_BUY_SELL_MISMATCH));
-
1218  env.close();
-
1219  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
1220 
-
1221  // Broker fee way too big.
-
1222  env(token::brokerOffers(gw, buyerOfferIndex, audOfferIndex),
-
1223  token::brokerFee(gwAUD(31)),
-
1224  ter(tecINSUFFICIENT_PAYMENT));
-
1225  env.close();
-
1226  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
1227 
-
1228  // Broker fee is smaller, but still too big once the offer
-
1229  // seller's minimum is taken into account.
-
1230  env(token::brokerOffers(gw, buyerOfferIndex, audOfferIndex),
-
1231  token::brokerFee(gwAUD(1.5)),
-
1232  ter(tecINSUFFICIENT_PAYMENT));
-
1233  env.close();
-
1234  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
1235 
-
1236  // Remove buyer's offer.
-
1237  env(token::cancelOffer(buyer, {buyerOfferIndex}));
-
1238  env.close();
-
1239  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
1240  }
-
1241  //----------------------------------------------------------------------
-
1242  // preclaim buy
-
1243  {
-
1244  // buyer creates a buy offer for one of alice's nfts.
-
1245  uint256 const buyerOfferIndex =
-
1246  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
1247  env(token::createOffer(buyer, nftAlice0ID, gwAUD(30)),
-
1248  token::owner(alice));
-
1249  env.close();
-
1250  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
1251 
-
1252  // Don't accept a buy offer if the sell flag is set.
-
1253  env(token::acceptBuyOffer(buyer, plainOfferIndex),
-
1254  ter(tecNFTOKEN_OFFER_TYPE_MISMATCH));
-
1255  env.close();
-
1256  BEAST_EXPECT(ownerCount(env, alice) == 7);
-
1257 
-
1258  // An account can't accept its own offer.
-
1259  env(token::acceptBuyOffer(buyer, buyerOfferIndex),
-
1260  ter(tecCANT_ACCEPT_OWN_NFTOKEN_OFFER));
+
1202  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
1203 
+
1204  // In a brokered offer, the buyer must offer greater than or
+
1205  // equal to the selling price.
+
1206  env(token::brokerOffers(gw, buyerOfferIndex, audOfferIndex),
+
1207  ter(tecINSUFFICIENT_PAYMENT));
+
1208  env.close();
+
1209  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
1210 
+
1211  // Remove buyer's offer.
+
1212  env(token::cancelOffer(buyer, {buyerOfferIndex}));
+
1213  env.close();
+
1214  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
1215  }
+
1216  {
+
1217  // buyer creates a buy offer for one of alice's nfts.
+
1218  uint256 const buyerOfferIndex =
+
1219  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
1220  env(token::createOffer(buyer, nftAlice0ID, gwAUD(31)),
+
1221  token::owner(alice));
+
1222  env.close();
+
1223  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
1224 
+
1225  // Broker sets their fee in a denomination other than the one
+
1226  // used by the offers
+
1227  env(token::brokerOffers(gw, buyerOfferIndex, audOfferIndex),
+
1228  token::brokerFee(XRP(40)),
+
1229  ter(tecNFTOKEN_BUY_SELL_MISMATCH));
+
1230  env.close();
+
1231  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
1232 
+
1233  // Broker fee way too big.
+
1234  env(token::brokerOffers(gw, buyerOfferIndex, audOfferIndex),
+
1235  token::brokerFee(gwAUD(31)),
+
1236  ter(tecINSUFFICIENT_PAYMENT));
+
1237  env.close();
+
1238  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
1239 
+
1240  // Broker fee is smaller, but still too big once the offer
+
1241  // seller's minimum is taken into account.
+
1242  env(token::brokerOffers(gw, buyerOfferIndex, audOfferIndex),
+
1243  token::brokerFee(gwAUD(1.5)),
+
1244  ter(tecINSUFFICIENT_PAYMENT));
+
1245  env.close();
+
1246  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
1247 
+
1248  // Remove buyer's offer.
+
1249  env(token::cancelOffer(buyer, {buyerOfferIndex}));
+
1250  env.close();
+
1251  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
1252  }
+
1253  //----------------------------------------------------------------------
+
1254  // preclaim buy
+
1255  {
+
1256  // buyer creates a buy offer for one of alice's nfts.
+
1257  uint256 const buyerOfferIndex =
+
1258  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
1259  env(token::createOffer(buyer, nftAlice0ID, gwAUD(30)),
+
1260  token::owner(alice));
1261  env.close();
1262  BEAST_EXPECT(ownerCount(env, buyer) == 2);
1263 
-
1264  // An offer acceptor must have enough funds to pay for the offer.
-
1265  env(pay(buyer, gw, gwAUD(30)));
-
1266  env.close();
-
1267  BEAST_EXPECT(env.balance(buyer, gwAUD) == gwAUD(0));
-
1268  env(token::acceptBuyOffer(alice, buyerOfferIndex),
-
1269  ter(tecINSUFFICIENT_FUNDS));
-
1270  env.close();
-
1271  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
1272 
-
1273  // alice gives her NFT to gw, so alice no longer owns nftAlice0.
-
1274  {
-
1275  uint256 const offerIndex =
-
1276  keylet::nftoffer(alice, env.seq(alice)).key;
-
1277  env(token::createOffer(alice, nftAlice0ID, XRP(0)),
-
1278  txflags(tfSellNFToken));
-
1279  env.close();
-
1280  env(token::acceptSellOffer(gw, offerIndex));
-
1281  env.close();
-
1282  BEAST_EXPECT(ownerCount(env, alice) == 7);
-
1283  }
-
1284  env(pay(gw, buyer, gwAUD(30)));
-
1285  env.close();
-
1286 
-
1287  // alice can't accept a buy offer for an NFT she no longer owns.
-
1288  env(token::acceptBuyOffer(alice, buyerOfferIndex),
-
1289  ter(tecNO_PERMISSION));
-
1290  env.close();
-
1291  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
1292 
-
1293  // Remove buyer's offer.
-
1294  env(token::cancelOffer(buyer, {buyerOfferIndex}));
-
1295  env.close();
-
1296  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
1297  }
-
1298  //----------------------------------------------------------------------
-
1299  // preclaim sell
-
1300  {
-
1301  // buyer creates a buy offer for one of alice's nfts.
-
1302  uint256 const buyerOfferIndex =
-
1303  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
1304  env(token::createOffer(buyer, nftXrpOnlyID, XRP(30)),
-
1305  token::owner(alice));
-
1306  env.close();
-
1307  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
1308 
-
1309  // Don't accept a sell offer without the sell flag set.
-
1310  env(token::acceptSellOffer(alice, buyerOfferIndex),
-
1311  ter(tecNFTOKEN_OFFER_TYPE_MISMATCH));
-
1312  env.close();
-
1313  BEAST_EXPECT(ownerCount(env, alice) == 7);
-
1314 
-
1315  // An account can't accept its own offer.
-
1316  env(token::acceptSellOffer(alice, plainOfferIndex),
-
1317  ter(tecCANT_ACCEPT_OWN_NFTOKEN_OFFER));
+
1264  // Don't accept a buy offer if the sell flag is set.
+
1265  env(token::acceptBuyOffer(buyer, plainOfferIndex),
+
1266  ter(tecNFTOKEN_OFFER_TYPE_MISMATCH));
+
1267  env.close();
+
1268  BEAST_EXPECT(ownerCount(env, alice) == 7);
+
1269 
+
1270  // An account can't accept its own offer.
+
1271  env(token::acceptBuyOffer(buyer, buyerOfferIndex),
+
1272  ter(tecCANT_ACCEPT_OWN_NFTOKEN_OFFER));
+
1273  env.close();
+
1274  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
1275 
+
1276  // An offer acceptor must have enough funds to pay for the offer.
+
1277  env(pay(buyer, gw, gwAUD(30)));
+
1278  env.close();
+
1279  BEAST_EXPECT(env.balance(buyer, gwAUD) == gwAUD(0));
+
1280  env(token::acceptBuyOffer(alice, buyerOfferIndex),
+
1281  ter(tecINSUFFICIENT_FUNDS));
+
1282  env.close();
+
1283  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
1284 
+
1285  // alice gives her NFT to gw, so alice no longer owns nftAlice0.
+
1286  {
+
1287  uint256 const offerIndex =
+
1288  keylet::nftoffer(alice, env.seq(alice)).key;
+
1289  env(token::createOffer(alice, nftAlice0ID, XRP(0)),
+
1290  txflags(tfSellNFToken));
+
1291  env.close();
+
1292  env(token::acceptSellOffer(gw, offerIndex));
+
1293  env.close();
+
1294  BEAST_EXPECT(ownerCount(env, alice) == 7);
+
1295  }
+
1296  env(pay(gw, buyer, gwAUD(30)));
+
1297  env.close();
+
1298 
+
1299  // alice can't accept a buy offer for an NFT she no longer owns.
+
1300  env(token::acceptBuyOffer(alice, buyerOfferIndex),
+
1301  ter(tecNO_PERMISSION));
+
1302  env.close();
+
1303  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
1304 
+
1305  // Remove buyer's offer.
+
1306  env(token::cancelOffer(buyer, {buyerOfferIndex}));
+
1307  env.close();
+
1308  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
1309  }
+
1310  //----------------------------------------------------------------------
+
1311  // preclaim sell
+
1312  {
+
1313  // buyer creates a buy offer for one of alice's nfts.
+
1314  uint256 const buyerOfferIndex =
+
1315  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
1316  env(token::createOffer(buyer, nftXrpOnlyID, XRP(30)),
+
1317  token::owner(alice));
1318  env.close();
1319  BEAST_EXPECT(ownerCount(env, buyer) == 2);
1320 
-
1321  // The seller must currently be in possession of the token they
-
1322  // are selling. alice gave nftAlice0ID to gw.
-
1323  env(token::acceptSellOffer(buyer, plainOfferIndex),
-
1324  ter(tecNO_PERMISSION));
-
1325  env.close();
-
1326  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
1327 
-
1328  // gw gives nftAlice0ID back to alice. That allows us to check
-
1329  // buyer attempting to accept one of alice's offers with
-
1330  // insufficient funds.
-
1331  {
-
1332  uint256 const offerIndex =
-
1333  keylet::nftoffer(gw, env.seq(gw)).key;
-
1334  env(token::createOffer(gw, nftAlice0ID, XRP(0)),
-
1335  txflags(tfSellNFToken));
-
1336  env.close();
-
1337  env(token::acceptSellOffer(alice, offerIndex));
-
1338  env.close();
-
1339  BEAST_EXPECT(ownerCount(env, alice) == 7);
-
1340  }
-
1341  env(pay(buyer, gw, gwAUD(30)));
-
1342  env.close();
-
1343  BEAST_EXPECT(env.balance(buyer, gwAUD) == gwAUD(0));
-
1344  env(token::acceptSellOffer(buyer, audOfferIndex),
-
1345  ter(tecINSUFFICIENT_FUNDS));
-
1346  env.close();
-
1347  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
1348  }
-
1349 
-
1350  //----------------------------------------------------------------------
-
1351  // doApply
-
1352  //
-
1353  // As far as I can see none of the failure modes are accessible as
-
1354  // long as the preflight and preclaim conditions are met.
-
1355  }
-
1356 
-
1357  void
-
1358  testMintFlagBurnable(FeatureBitset features)
-
1359  {
-
1360  // Exercise NFTs with flagBurnable set and not set.
-
1361  testcase("Mint flagBurnable");
-
1362 
-
1363  using namespace test::jtx;
-
1364 
-
1365  Env env{*this, features};
-
1366  Account const alice{"alice"};
-
1367  Account const buyer{"buyer"};
-
1368  Account const minter1{"minter1"};
-
1369  Account const minter2{"minter2"};
-
1370 
-
1371  env.fund(XRP(1000), alice, buyer, minter1, minter2);
-
1372  env.close();
-
1373  BEAST_EXPECT(ownerCount(env, alice) == 0);
+
1321  // Don't accept a sell offer without the sell flag set.
+
1322  env(token::acceptSellOffer(alice, buyerOfferIndex),
+
1323  ter(tecNFTOKEN_OFFER_TYPE_MISMATCH));
+
1324  env.close();
+
1325  BEAST_EXPECT(ownerCount(env, alice) == 7);
+
1326 
+
1327  // An account can't accept its own offer.
+
1328  env(token::acceptSellOffer(alice, plainOfferIndex),
+
1329  ter(tecCANT_ACCEPT_OWN_NFTOKEN_OFFER));
+
1330  env.close();
+
1331  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
1332 
+
1333  // The seller must currently be in possession of the token they
+
1334  // are selling. alice gave nftAlice0ID to gw.
+
1335  env(token::acceptSellOffer(buyer, plainOfferIndex),
+
1336  ter(tecNO_PERMISSION));
+
1337  env.close();
+
1338  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
1339 
+
1340  // gw gives nftAlice0ID back to alice. That allows us to check
+
1341  // buyer attempting to accept one of alice's offers with
+
1342  // insufficient funds.
+
1343  {
+
1344  uint256 const offerIndex =
+
1345  keylet::nftoffer(gw, env.seq(gw)).key;
+
1346  env(token::createOffer(gw, nftAlice0ID, XRP(0)),
+
1347  txflags(tfSellNFToken));
+
1348  env.close();
+
1349  env(token::acceptSellOffer(alice, offerIndex));
+
1350  env.close();
+
1351  BEAST_EXPECT(ownerCount(env, alice) == 7);
+
1352  }
+
1353  env(pay(buyer, gw, gwAUD(30)));
+
1354  env.close();
+
1355  BEAST_EXPECT(env.balance(buyer, gwAUD) == gwAUD(0));
+
1356  env(token::acceptSellOffer(buyer, audOfferIndex),
+
1357  ter(tecINSUFFICIENT_FUNDS));
+
1358  env.close();
+
1359  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
1360  }
+
1361 
+
1362  //----------------------------------------------------------------------
+
1363  // doApply
+
1364  //
+
1365  // As far as I can see none of the failure modes are accessible as
+
1366  // long as the preflight and preclaim conditions are met.
+
1367  }
+
1368 
+
1369  void
+
1370  testMintFlagBurnable(FeatureBitset features)
+
1371  {
+
1372  // Exercise NFTs with flagBurnable set and not set.
+
1373  testcase("Mint flagBurnable");
1374 
-
1375  // alice selects minter as her minter.
-
1376  env(token::setMinter(alice, minter1));
-
1377  env.close();
-
1378 
-
1379  // A lambda that...
-
1380  // 1. creates an alice nft
-
1381  // 2. minted by minter and
-
1382  // 3. transfers that nft to buyer.
-
1383  auto nftToBuyer = [&env, &alice, &minter1, &buyer](
-
1384  std::uint32_t flags) {
-
1385  uint256 const nftID{token::getNextID(env, alice, 0u, flags)};
-
1386  env(token::mint(minter1, 0u), token::issuer(alice), txflags(flags));
-
1387  env.close();
-
1388 
-
1389  uint256 const offerIndex =
-
1390  keylet::nftoffer(minter1, env.seq(minter1)).key;
-
1391  env(token::createOffer(minter1, nftID, XRP(0)),
-
1392  txflags(tfSellNFToken));
-
1393  env.close();
-
1394 
-
1395  env(token::acceptSellOffer(buyer, offerIndex));
-
1396  env.close();
-
1397 
-
1398  return nftID;
-
1399  };
+
1375  using namespace test::jtx;
+
1376 
+
1377  Env env{*this, features};
+
1378  Account const alice{"alice"};
+
1379  Account const buyer{"buyer"};
+
1380  Account const minter1{"minter1"};
+
1381  Account const minter2{"minter2"};
+
1382 
+
1383  env.fund(XRP(1000), alice, buyer, minter1, minter2);
+
1384  env.close();
+
1385  BEAST_EXPECT(ownerCount(env, alice) == 0);
+
1386 
+
1387  // alice selects minter as her minter.
+
1388  env(token::setMinter(alice, minter1));
+
1389  env.close();
+
1390 
+
1391  // A lambda that...
+
1392  // 1. creates an alice nft
+
1393  // 2. minted by minter and
+
1394  // 3. transfers that nft to buyer.
+
1395  auto nftToBuyer = [&env, &alice, &minter1, &buyer](
+
1396  std::uint32_t flags) {
+
1397  uint256 const nftID{token::getNextID(env, alice, 0u, flags)};
+
1398  env(token::mint(minter1, 0u), token::issuer(alice), txflags(flags));
+
1399  env.close();
1400 
-
1401  // An NFT without flagBurnable can only be burned by its owner.
-
1402  {
-
1403  uint256 const noBurnID = nftToBuyer(0);
-
1404  env(token::burn(alice, noBurnID),
-
1405  token::owner(buyer),
-
1406  ter(tecNO_PERMISSION));
-
1407  env.close();
-
1408  env(token::burn(minter1, noBurnID),
-
1409  token::owner(buyer),
-
1410  ter(tecNO_PERMISSION));
-
1411  env.close();
-
1412  env(token::burn(minter2, noBurnID),
-
1413  token::owner(buyer),
-
1414  ter(tecNO_PERMISSION));
-
1415  env.close();
-
1416 
-
1417  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
1418  env(token::burn(buyer, noBurnID), token::owner(buyer));
+
1401  uint256 const offerIndex =
+
1402  keylet::nftoffer(minter1, env.seq(minter1)).key;
+
1403  env(token::createOffer(minter1, nftID, XRP(0)),
+
1404  txflags(tfSellNFToken));
+
1405  env.close();
+
1406 
+
1407  env(token::acceptSellOffer(buyer, offerIndex));
+
1408  env.close();
+
1409 
+
1410  return nftID;
+
1411  };
+
1412 
+
1413  // An NFT without flagBurnable can only be burned by its owner.
+
1414  {
+
1415  uint256 const noBurnID = nftToBuyer(0);
+
1416  env(token::burn(alice, noBurnID),
+
1417  token::owner(buyer),
+
1418  ter(tecNO_PERMISSION));
1419  env.close();
-
1420  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
1421  }
-
1422  // An NFT with flagBurnable can be burned by the issuer.
-
1423  {
-
1424  uint256 const burnableID = nftToBuyer(tfBurnable);
-
1425  env(token::burn(minter2, burnableID),
-
1426  token::owner(buyer),
-
1427  ter(tecNO_PERMISSION));
-
1428  env.close();
-
1429 
-
1430  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
1431  env(token::burn(alice, burnableID), token::owner(buyer));
-
1432  env.close();
-
1433  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
1434  }
-
1435  // An NFT with flagBurnable can be burned by the owner.
-
1436  {
-
1437  uint256 const burnableID = nftToBuyer(tfBurnable);
-
1438  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
1439  env(token::burn(buyer, burnableID));
+
1420  env(token::burn(minter1, noBurnID),
+
1421  token::owner(buyer),
+
1422  ter(tecNO_PERMISSION));
+
1423  env.close();
+
1424  env(token::burn(minter2, noBurnID),
+
1425  token::owner(buyer),
+
1426  ter(tecNO_PERMISSION));
+
1427  env.close();
+
1428 
+
1429  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
1430  env(token::burn(buyer, noBurnID), token::owner(buyer));
+
1431  env.close();
+
1432  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
1433  }
+
1434  // An NFT with flagBurnable can be burned by the issuer.
+
1435  {
+
1436  uint256 const burnableID = nftToBuyer(tfBurnable);
+
1437  env(token::burn(minter2, burnableID),
+
1438  token::owner(buyer),
+
1439  ter(tecNO_PERMISSION));
1440  env.close();
-
1441  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
1442  }
-
1443  // An NFT with flagBurnable can be burned by the minter.
-
1444  {
-
1445  uint256 const burnableID = nftToBuyer(tfBurnable);
-
1446  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
1447  env(token::burn(buyer, burnableID), token::owner(buyer));
-
1448  env.close();
-
1449  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
1450  }
-
1451  // An nft with flagBurnable may be burned by the issuers' minter,
-
1452  // who may not be the original minter.
-
1453  {
-
1454  uint256 const burnableID = nftToBuyer(tfBurnable);
-
1455  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
1456 
-
1457  env(token::setMinter(alice, minter2));
-
1458  env.close();
-
1459 
-
1460  // minter1 is no longer alice's minter, so no longer has
-
1461  // permisson to burn alice's nfts.
-
1462  env(token::burn(minter1, burnableID),
-
1463  token::owner(buyer),
-
1464  ter(tecNO_PERMISSION));
-
1465  env.close();
-
1466  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
1467 
-
1468  // minter2, however, can burn alice's nfts.
-
1469  env(token::burn(minter2, burnableID), token::owner(buyer));
+
1441 
+
1442  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
1443  env(token::burn(alice, burnableID), token::owner(buyer));
+
1444  env.close();
+
1445  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
1446  }
+
1447  // An NFT with flagBurnable can be burned by the owner.
+
1448  {
+
1449  uint256 const burnableID = nftToBuyer(tfBurnable);
+
1450  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
1451  env(token::burn(buyer, burnableID));
+
1452  env.close();
+
1453  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
1454  }
+
1455  // An NFT with flagBurnable can be burned by the minter.
+
1456  {
+
1457  uint256 const burnableID = nftToBuyer(tfBurnable);
+
1458  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
1459  env(token::burn(buyer, burnableID), token::owner(buyer));
+
1460  env.close();
+
1461  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
1462  }
+
1463  // An nft with flagBurnable may be burned by the issuers' minter,
+
1464  // who may not be the original minter.
+
1465  {
+
1466  uint256 const burnableID = nftToBuyer(tfBurnable);
+
1467  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
1468 
+
1469  env(token::setMinter(alice, minter2));
1470  env.close();
-
1471  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
1472  }
-
1473  }
-
1474 
-
1475  void
-
1476  testMintFlagOnlyXRP(FeatureBitset features)
-
1477  {
-
1478  // Exercise NFTs with flagOnlyXRP set and not set.
-
1479  testcase("Mint flagOnlyXRP");
-
1480 
-
1481  using namespace test::jtx;
-
1482 
-
1483  Env env{*this, features};
-
1484  Account const alice{"alice"};
-
1485  Account const buyer{"buyer"};
-
1486  Account const gw("gw");
-
1487  IOU const gwAUD(gw["AUD"]);
-
1488 
-
1489  // Set trust lines so alice and buyer can use gwAUD.
-
1490  env.fund(XRP(1000), alice, buyer, gw);
-
1491  env.close();
-
1492  env(trust(alice, gwAUD(1000)));
-
1493  env(trust(buyer, gwAUD(1000)));
-
1494  env.close();
-
1495  env(pay(gw, buyer, gwAUD(100)));
-
1496 
-
1497  // Don't set flagOnlyXRP and offers can be made with IOUs.
-
1498  {
-
1499  uint256 const nftIOUsOkayID{
-
1500  token::getNextID(env, alice, 0u, tfTransferable)};
-
1501  env(token::mint(alice, 0u), txflags(tfTransferable));
-
1502  env.close();
-
1503 
-
1504  BEAST_EXPECT(ownerCount(env, alice) == 2);
-
1505  uint256 const aliceOfferIndex =
-
1506  keylet::nftoffer(alice, env.seq(alice)).key;
-
1507  env(token::createOffer(alice, nftIOUsOkayID, gwAUD(50)),
-
1508  txflags(tfSellNFToken));
-
1509  env.close();
-
1510  BEAST_EXPECT(ownerCount(env, alice) == 3);
-
1511 
-
1512  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
1513  uint256 const buyerOfferIndex =
-
1514  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
1515  env(token::createOffer(buyer, nftIOUsOkayID, gwAUD(50)),
-
1516  token::owner(alice));
-
1517  env.close();
-
1518  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
1519 
-
1520  // Cancel the two offers just to be tidy.
-
1521  env(token::cancelOffer(alice, {aliceOfferIndex}));
-
1522  env(token::cancelOffer(buyer, {buyerOfferIndex}));
-
1523  env.close();
-
1524  BEAST_EXPECT(ownerCount(env, alice) == 2);
-
1525  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
1526 
-
1527  // Also burn alice's nft.
-
1528  env(token::burn(alice, nftIOUsOkayID));
+
1471 
+
1472  // minter1 is no longer alice's minter, so no longer has
+
1473  // permisson to burn alice's nfts.
+
1474  env(token::burn(minter1, burnableID),
+
1475  token::owner(buyer),
+
1476  ter(tecNO_PERMISSION));
+
1477  env.close();
+
1478  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
1479 
+
1480  // minter2, however, can burn alice's nfts.
+
1481  env(token::burn(minter2, burnableID), token::owner(buyer));
+
1482  env.close();
+
1483  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
1484  }
+
1485  }
+
1486 
+
1487  void
+
1488  testMintFlagOnlyXRP(FeatureBitset features)
+
1489  {
+
1490  // Exercise NFTs with flagOnlyXRP set and not set.
+
1491  testcase("Mint flagOnlyXRP");
+
1492 
+
1493  using namespace test::jtx;
+
1494 
+
1495  Env env{*this, features};
+
1496  Account const alice{"alice"};
+
1497  Account const buyer{"buyer"};
+
1498  Account const gw("gw");
+
1499  IOU const gwAUD(gw["AUD"]);
+
1500 
+
1501  // Set trust lines so alice and buyer can use gwAUD.
+
1502  env.fund(XRP(1000), alice, buyer, gw);
+
1503  env.close();
+
1504  env(trust(alice, gwAUD(1000)));
+
1505  env(trust(buyer, gwAUD(1000)));
+
1506  env.close();
+
1507  env(pay(gw, buyer, gwAUD(100)));
+
1508 
+
1509  // Don't set flagOnlyXRP and offers can be made with IOUs.
+
1510  {
+
1511  uint256 const nftIOUsOkayID{
+
1512  token::getNextID(env, alice, 0u, tfTransferable)};
+
1513  env(token::mint(alice, 0u), txflags(tfTransferable));
+
1514  env.close();
+
1515 
+
1516  BEAST_EXPECT(ownerCount(env, alice) == 2);
+
1517  uint256 const aliceOfferIndex =
+
1518  keylet::nftoffer(alice, env.seq(alice)).key;
+
1519  env(token::createOffer(alice, nftIOUsOkayID, gwAUD(50)),
+
1520  txflags(tfSellNFToken));
+
1521  env.close();
+
1522  BEAST_EXPECT(ownerCount(env, alice) == 3);
+
1523 
+
1524  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
1525  uint256 const buyerOfferIndex =
+
1526  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
1527  env(token::createOffer(buyer, nftIOUsOkayID, gwAUD(50)),
+
1528  token::owner(alice));
1529  env.close();
-
1530  BEAST_EXPECT(ownerCount(env, alice) == 1);
-
1531  }
-
1532 
-
1533  // Set flagOnlyXRP and offers using IOUs are rejected.
-
1534  {
-
1535  uint256 const nftOnlyXRPID{
-
1536  token::getNextID(env, alice, 0u, tfOnlyXRP | tfTransferable)};
-
1537  env(token::mint(alice, 0u), txflags(tfOnlyXRP | tfTransferable));
-
1538  env.close();
-
1539 
-
1540  BEAST_EXPECT(ownerCount(env, alice) == 2);
-
1541  env(token::createOffer(alice, nftOnlyXRPID, gwAUD(50)),
-
1542  txflags(tfSellNFToken),
-
1543  ter(temBAD_AMOUNT));
-
1544  env.close();
-
1545  BEAST_EXPECT(ownerCount(env, alice) == 2);
-
1546 
-
1547  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
1548  env(token::createOffer(buyer, nftOnlyXRPID, gwAUD(50)),
-
1549  token::owner(alice),
-
1550  ter(temBAD_AMOUNT));
-
1551  env.close();
-
1552  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
1553 
-
1554  // However offers for XRP are okay.
-
1555  BEAST_EXPECT(ownerCount(env, alice) == 2);
-
1556  env(token::createOffer(alice, nftOnlyXRPID, XRP(60)),
-
1557  txflags(tfSellNFToken));
-
1558  env.close();
-
1559  BEAST_EXPECT(ownerCount(env, alice) == 3);
-
1560 
-
1561  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
1562  env(token::createOffer(buyer, nftOnlyXRPID, XRP(60)),
-
1563  token::owner(alice));
-
1564  env.close();
-
1565  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
1566  }
-
1567  }
-
1568 
-
1569  void
-
1570  testMintFlagCreateTrustLine(FeatureBitset features)
-
1571  {
-
1572  // Exercise NFTs with flagCreateTrustLines set and not set.
-
1573  testcase("Mint flagCreateTrustLines");
-
1574 
-
1575  using namespace test::jtx;
-
1576 
-
1577  Account const alice{"alice"};
-
1578  Account const becky{"becky"};
-
1579  Account const cheri{"cheri"};
-
1580  Account const gw("gw");
-
1581  IOU const gwAUD(gw["AUD"]);
-
1582  IOU const gwCAD(gw["CAD"]);
-
1583  IOU const gwEUR(gw["EUR"]);
-
1584 
-
1585  // The behavior of this test changes dramatically based on the
-
1586  // presence (or absence) of the fixRemoveNFTokenAutoTrustLine
-
1587  // amendment. So we test both cases here.
-
1588  for (auto const& tweakedFeatures :
-
1589  {features - fixRemoveNFTokenAutoTrustLine,
-
1590  features | fixRemoveNFTokenAutoTrustLine})
-
1591  {
-
1592  Env env{*this, tweakedFeatures};
-
1593  env.fund(XRP(1000), alice, becky, cheri, gw);
-
1594  env.close();
-
1595 
-
1596  // Set trust lines so becky and cheri can use gw's currency.
-
1597  env(trust(becky, gwAUD(1000)));
-
1598  env(trust(cheri, gwAUD(1000)));
-
1599  env(trust(becky, gwCAD(1000)));
-
1600  env(trust(cheri, gwCAD(1000)));
-
1601  env(trust(becky, gwEUR(1000)));
-
1602  env(trust(cheri, gwEUR(1000)));
-
1603  env.close();
-
1604  env(pay(gw, becky, gwAUD(500)));
-
1605  env(pay(gw, becky, gwCAD(500)));
-
1606  env(pay(gw, becky, gwEUR(500)));
-
1607  env(pay(gw, cheri, gwAUD(500)));
-
1608  env(pay(gw, cheri, gwCAD(500)));
-
1609  env.close();
-
1610 
-
1611  // An nft without flagCreateTrustLines but with a non-zero transfer
-
1612  // fee will not allow creating offers that use IOUs for payment.
-
1613  for (std::uint32_t xferFee : {0, 1})
-
1614  {
-
1615  uint256 const nftNoAutoTrustID{
-
1616  token::getNextID(env, alice, 0u, tfTransferable, xferFee)};
-
1617  env(token::mint(alice, 0u),
-
1618  token::xferFee(xferFee),
-
1619  txflags(tfTransferable));
-
1620  env.close();
-
1621 
-
1622  // becky buys the nft for 1 drop.
-
1623  uint256 const beckyBuyOfferIndex =
-
1624  keylet::nftoffer(becky, env.seq(becky)).key;
-
1625  env(token::createOffer(becky, nftNoAutoTrustID, drops(1)),
-
1626  token::owner(alice));
-
1627  env.close();
-
1628  env(token::acceptBuyOffer(alice, beckyBuyOfferIndex));
-
1629  env.close();
-
1630 
-
1631  // becky attempts to sell the nft for AUD.
-
1632  TER const createOfferTER =
-
1633  xferFee ? TER(tecNO_LINE) : TER(tesSUCCESS);
-
1634  uint256 const beckyOfferIndex =
-
1635  keylet::nftoffer(becky, env.seq(becky)).key;
-
1636  env(token::createOffer(becky, nftNoAutoTrustID, gwAUD(100)),
-
1637  txflags(tfSellNFToken),
-
1638  ter(createOfferTER));
+
1530  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
1531 
+
1532  // Cancel the two offers just to be tidy.
+
1533  env(token::cancelOffer(alice, {aliceOfferIndex}));
+
1534  env(token::cancelOffer(buyer, {buyerOfferIndex}));
+
1535  env.close();
+
1536  BEAST_EXPECT(ownerCount(env, alice) == 2);
+
1537  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
1538 
+
1539  // Also burn alice's nft.
+
1540  env(token::burn(alice, nftIOUsOkayID));
+
1541  env.close();
+
1542  BEAST_EXPECT(ownerCount(env, alice) == 1);
+
1543  }
+
1544 
+
1545  // Set flagOnlyXRP and offers using IOUs are rejected.
+
1546  {
+
1547  uint256 const nftOnlyXRPID{
+
1548  token::getNextID(env, alice, 0u, tfOnlyXRP | tfTransferable)};
+
1549  env(token::mint(alice, 0u), txflags(tfOnlyXRP | tfTransferable));
+
1550  env.close();
+
1551 
+
1552  BEAST_EXPECT(ownerCount(env, alice) == 2);
+
1553  env(token::createOffer(alice, nftOnlyXRPID, gwAUD(50)),
+
1554  txflags(tfSellNFToken),
+
1555  ter(temBAD_AMOUNT));
+
1556  env.close();
+
1557  BEAST_EXPECT(ownerCount(env, alice) == 2);
+
1558 
+
1559  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
1560  env(token::createOffer(buyer, nftOnlyXRPID, gwAUD(50)),
+
1561  token::owner(alice),
+
1562  ter(temBAD_AMOUNT));
+
1563  env.close();
+
1564  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
1565 
+
1566  // However offers for XRP are okay.
+
1567  BEAST_EXPECT(ownerCount(env, alice) == 2);
+
1568  env(token::createOffer(alice, nftOnlyXRPID, XRP(60)),
+
1569  txflags(tfSellNFToken));
+
1570  env.close();
+
1571  BEAST_EXPECT(ownerCount(env, alice) == 3);
+
1572 
+
1573  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
1574  env(token::createOffer(buyer, nftOnlyXRPID, XRP(60)),
+
1575  token::owner(alice));
+
1576  env.close();
+
1577  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
1578  }
+
1579  }
+
1580 
+
1581  void
+
1582  testMintFlagCreateTrustLine(FeatureBitset features)
+
1583  {
+
1584  // Exercise NFTs with flagCreateTrustLines set and not set.
+
1585  testcase("Mint flagCreateTrustLines");
+
1586 
+
1587  using namespace test::jtx;
+
1588 
+
1589  Account const alice{"alice"};
+
1590  Account const becky{"becky"};
+
1591  Account const cheri{"cheri"};
+
1592  Account const gw("gw");
+
1593  IOU const gwAUD(gw["AUD"]);
+
1594  IOU const gwCAD(gw["CAD"]);
+
1595  IOU const gwEUR(gw["EUR"]);
+
1596 
+
1597  // The behavior of this test changes dramatically based on the
+
1598  // presence (or absence) of the fixRemoveNFTokenAutoTrustLine
+
1599  // amendment. So we test both cases here.
+
1600  for (auto const& tweakedFeatures :
+
1601  {features - fixRemoveNFTokenAutoTrustLine,
+
1602  features | fixRemoveNFTokenAutoTrustLine})
+
1603  {
+
1604  Env env{*this, tweakedFeatures};
+
1605  env.fund(XRP(1000), alice, becky, cheri, gw);
+
1606  env.close();
+
1607 
+
1608  // Set trust lines so becky and cheri can use gw's currency.
+
1609  env(trust(becky, gwAUD(1000)));
+
1610  env(trust(cheri, gwAUD(1000)));
+
1611  env(trust(becky, gwCAD(1000)));
+
1612  env(trust(cheri, gwCAD(1000)));
+
1613  env(trust(becky, gwEUR(1000)));
+
1614  env(trust(cheri, gwEUR(1000)));
+
1615  env.close();
+
1616  env(pay(gw, becky, gwAUD(500)));
+
1617  env(pay(gw, becky, gwCAD(500)));
+
1618  env(pay(gw, becky, gwEUR(500)));
+
1619  env(pay(gw, cheri, gwAUD(500)));
+
1620  env(pay(gw, cheri, gwCAD(500)));
+
1621  env.close();
+
1622 
+
1623  // An nft without flagCreateTrustLines but with a non-zero transfer
+
1624  // fee will not allow creating offers that use IOUs for payment.
+
1625  for (std::uint32_t xferFee : {0, 1})
+
1626  {
+
1627  uint256 const nftNoAutoTrustID{
+
1628  token::getNextID(env, alice, 0u, tfTransferable, xferFee)};
+
1629  env(token::mint(alice, 0u),
+
1630  token::xferFee(xferFee),
+
1631  txflags(tfTransferable));
+
1632  env.close();
+
1633 
+
1634  // becky buys the nft for 1 drop.
+
1635  uint256 const beckyBuyOfferIndex =
+
1636  keylet::nftoffer(becky, env.seq(becky)).key;
+
1637  env(token::createOffer(becky, nftNoAutoTrustID, drops(1)),
+
1638  token::owner(alice));
1639  env.close();
-
1640 
-
1641  // cheri offers to buy the nft for CAD.
-
1642  uint256 const cheriOfferIndex =
-
1643  keylet::nftoffer(cheri, env.seq(cheri)).key;
-
1644  env(token::createOffer(cheri, nftNoAutoTrustID, gwCAD(100)),
-
1645  token::owner(becky),
-
1646  ter(createOfferTER));
-
1647  env.close();
-
1648 
-
1649  // To keep things tidy, cancel the offers.
-
1650  env(token::cancelOffer(becky, {beckyOfferIndex}));
-
1651  env(token::cancelOffer(cheri, {cheriOfferIndex}));
-
1652  env.close();
-
1653  }
-
1654  // An nft with flagCreateTrustLines but with a non-zero transfer
-
1655  // fee allows transfers using IOUs for payment.
-
1656  {
-
1657  std::uint16_t transferFee = 10000; // 10%
-
1658 
-
1659  uint256 const nftAutoTrustID{token::getNextID(
-
1660  env, alice, 0u, tfTransferable | tfTrustLine, transferFee)};
-
1661 
-
1662  // If the fixRemoveNFTokenAutoTrustLine amendment is active
-
1663  // then this transaction fails.
-
1664  {
-
1665  TER const mintTER =
-
1666  tweakedFeatures[fixRemoveNFTokenAutoTrustLine]
-
1667  ? static_cast<TER>(temINVALID_FLAG)
-
1668  : static_cast<TER>(tesSUCCESS);
-
1669 
-
1670  env(token::mint(alice, 0u),
-
1671  token::xferFee(transferFee),
-
1672  txflags(tfTransferable | tfTrustLine),
-
1673  ter(mintTER));
-
1674  env.close();
-
1675 
-
1676  // If fixRemoveNFTokenAutoTrustLine is active the rest
-
1677  // of this test falls on its face.
-
1678  if (tweakedFeatures[fixRemoveNFTokenAutoTrustLine])
-
1679  break;
-
1680  }
-
1681  // becky buys the nft for 1 drop.
-
1682  uint256 const beckyBuyOfferIndex =
-
1683  keylet::nftoffer(becky, env.seq(becky)).key;
-
1684  env(token::createOffer(becky, nftAutoTrustID, drops(1)),
-
1685  token::owner(alice));
-
1686  env.close();
-
1687  env(token::acceptBuyOffer(alice, beckyBuyOfferIndex));
-
1688  env.close();
-
1689 
-
1690  // becky sells the nft for AUD.
-
1691  uint256 const beckySellOfferIndex =
-
1692  keylet::nftoffer(becky, env.seq(becky)).key;
-
1693  env(token::createOffer(becky, nftAutoTrustID, gwAUD(100)),
-
1694  txflags(tfSellNFToken));
-
1695  env.close();
-
1696  env(token::acceptSellOffer(cheri, beckySellOfferIndex));
-
1697  env.close();
-
1698 
-
1699  // alice should now have a trust line for gwAUD.
-
1700  BEAST_EXPECT(env.balance(alice, gwAUD) == gwAUD(10));
+
1640  env(token::acceptBuyOffer(alice, beckyBuyOfferIndex));
+
1641  env.close();
+
1642 
+
1643  // becky attempts to sell the nft for AUD.
+
1644  TER const createOfferTER =
+
1645  xferFee ? TER(tecNO_LINE) : TER(tesSUCCESS);
+
1646  uint256 const beckyOfferIndex =
+
1647  keylet::nftoffer(becky, env.seq(becky)).key;
+
1648  env(token::createOffer(becky, nftNoAutoTrustID, gwAUD(100)),
+
1649  txflags(tfSellNFToken),
+
1650  ter(createOfferTER));
+
1651  env.close();
+
1652 
+
1653  // cheri offers to buy the nft for CAD.
+
1654  uint256 const cheriOfferIndex =
+
1655  keylet::nftoffer(cheri, env.seq(cheri)).key;
+
1656  env(token::createOffer(cheri, nftNoAutoTrustID, gwCAD(100)),
+
1657  token::owner(becky),
+
1658  ter(createOfferTER));
+
1659  env.close();
+
1660 
+
1661  // To keep things tidy, cancel the offers.
+
1662  env(token::cancelOffer(becky, {beckyOfferIndex}));
+
1663  env(token::cancelOffer(cheri, {cheriOfferIndex}));
+
1664  env.close();
+
1665  }
+
1666  // An nft with flagCreateTrustLines but with a non-zero transfer
+
1667  // fee allows transfers using IOUs for payment.
+
1668  {
+
1669  std::uint16_t transferFee = 10000; // 10%
+
1670 
+
1671  uint256 const nftAutoTrustID{token::getNextID(
+
1672  env, alice, 0u, tfTransferable | tfTrustLine, transferFee)};
+
1673 
+
1674  // If the fixRemoveNFTokenAutoTrustLine amendment is active
+
1675  // then this transaction fails.
+
1676  {
+
1677  TER const mintTER =
+
1678  tweakedFeatures[fixRemoveNFTokenAutoTrustLine]
+
1679  ? static_cast<TER>(temINVALID_FLAG)
+
1680  : static_cast<TER>(tesSUCCESS);
+
1681 
+
1682  env(token::mint(alice, 0u),
+
1683  token::xferFee(transferFee),
+
1684  txflags(tfTransferable | tfTrustLine),
+
1685  ter(mintTER));
+
1686  env.close();
+
1687 
+
1688  // If fixRemoveNFTokenAutoTrustLine is active the rest
+
1689  // of this test falls on its face.
+
1690  if (tweakedFeatures[fixRemoveNFTokenAutoTrustLine])
+
1691  break;
+
1692  }
+
1693  // becky buys the nft for 1 drop.
+
1694  uint256 const beckyBuyOfferIndex =
+
1695  keylet::nftoffer(becky, env.seq(becky)).key;
+
1696  env(token::createOffer(becky, nftAutoTrustID, drops(1)),
+
1697  token::owner(alice));
+
1698  env.close();
+
1699  env(token::acceptBuyOffer(alice, beckyBuyOfferIndex));
+
1700  env.close();
1701 
-
1702  // becky buys the nft back for CAD.
-
1703  uint256 const beckyBuyBackOfferIndex =
+
1702  // becky sells the nft for AUD.
+
1703  uint256 const beckySellOfferIndex =
1704  keylet::nftoffer(becky, env.seq(becky)).key;
-
1705  env(token::createOffer(becky, nftAutoTrustID, gwCAD(50)),
-
1706  token::owner(cheri));
+
1705  env(token::createOffer(becky, nftAutoTrustID, gwAUD(100)),
+
1706  txflags(tfSellNFToken));
1707  env.close();
-
1708  env(token::acceptBuyOffer(cheri, beckyBuyBackOfferIndex));
+
1708  env(token::acceptSellOffer(cheri, beckySellOfferIndex));
1709  env.close();
1710 
-
1711  // alice should now have a trust line for gwAUD and gwCAD.
+
1711  // alice should now have a trust line for gwAUD.
1712  BEAST_EXPECT(env.balance(alice, gwAUD) == gwAUD(10));
-
1713  BEAST_EXPECT(env.balance(alice, gwCAD) == gwCAD(5));
-
1714  }
-
1715  // Now that alice has trust lines preestablished, an nft without
-
1716  // flagCreateTrustLines will work for preestablished trust lines.
-
1717  {
-
1718  std::uint16_t transferFee = 5000; // 5%
-
1719  uint256 const nftNoAutoTrustID{token::getNextID(
-
1720  env, alice, 0u, tfTransferable, transferFee)};
-
1721  env(token::mint(alice, 0u),
-
1722  token::xferFee(transferFee),
-
1723  txflags(tfTransferable));
-
1724  env.close();
-
1725 
-
1726  // alice sells the nft using AUD.
-
1727  uint256 const aliceSellOfferIndex =
-
1728  keylet::nftoffer(alice, env.seq(alice)).key;
-
1729  env(token::createOffer(alice, nftNoAutoTrustID, gwAUD(200)),
-
1730  txflags(tfSellNFToken));
-
1731  env.close();
-
1732  env(token::acceptSellOffer(cheri, aliceSellOfferIndex));
-
1733  env.close();
-
1734 
-
1735  // alice should now have AUD(210):
-
1736  // o 200 for this sale and
-
1737  // o 10 for the previous sale's fee.
-
1738  BEAST_EXPECT(env.balance(alice, gwAUD) == gwAUD(210));
-
1739 
-
1740  // cheri can't sell the NFT for EUR, but can for CAD.
-
1741  env(token::createOffer(cheri, nftNoAutoTrustID, gwEUR(50)),
-
1742  txflags(tfSellNFToken),
-
1743  ter(tecNO_LINE));
-
1744  env.close();
-
1745  uint256 const cheriSellOfferIndex =
-
1746  keylet::nftoffer(cheri, env.seq(cheri)).key;
-
1747  env(token::createOffer(cheri, nftNoAutoTrustID, gwCAD(100)),
-
1748  txflags(tfSellNFToken));
-
1749  env.close();
-
1750  env(token::acceptSellOffer(becky, cheriSellOfferIndex));
-
1751  env.close();
-
1752 
-
1753  // alice should now have CAD(10):
-
1754  // o 5 from this sale's fee and
-
1755  // o 5 for the previous sale's fee.
-
1756  BEAST_EXPECT(env.balance(alice, gwCAD) == gwCAD(10));
-
1757  }
-
1758  }
-
1759  }
-
1760 
-
1761  void
-
1762  testMintFlagTransferable(FeatureBitset features)
-
1763  {
-
1764  // Exercise NFTs with flagTransferable set and not set.
-
1765  testcase("Mint flagTransferable");
-
1766 
-
1767  using namespace test::jtx;
-
1768 
-
1769  Env env{*this, features};
-
1770 
-
1771  Account const alice{"alice"};
-
1772  Account const becky{"becky"};
-
1773  Account const minter{"minter"};
-
1774 
-
1775  env.fund(XRP(1000), alice, becky, minter);
-
1776  env.close();
-
1777 
-
1778  // First try an nft made by alice without flagTransferable set.
-
1779  {
-
1780  BEAST_EXPECT(ownerCount(env, alice) == 0);
-
1781  uint256 const nftAliceNoTransferID{
-
1782  token::getNextID(env, alice, 0u)};
-
1783  env(token::mint(alice, 0u), token::xferFee(0));
-
1784  env.close();
-
1785  BEAST_EXPECT(ownerCount(env, alice) == 1);
+
1713 
+
1714  // becky buys the nft back for CAD.
+
1715  uint256 const beckyBuyBackOfferIndex =
+
1716  keylet::nftoffer(becky, env.seq(becky)).key;
+
1717  env(token::createOffer(becky, nftAutoTrustID, gwCAD(50)),
+
1718  token::owner(cheri));
+
1719  env.close();
+
1720  env(token::acceptBuyOffer(cheri, beckyBuyBackOfferIndex));
+
1721  env.close();
+
1722 
+
1723  // alice should now have a trust line for gwAUD and gwCAD.
+
1724  BEAST_EXPECT(env.balance(alice, gwAUD) == gwAUD(10));
+
1725  BEAST_EXPECT(env.balance(alice, gwCAD) == gwCAD(5));
+
1726  }
+
1727  // Now that alice has trust lines preestablished, an nft without
+
1728  // flagCreateTrustLines will work for preestablished trust lines.
+
1729  {
+
1730  std::uint16_t transferFee = 5000; // 5%
+
1731  uint256 const nftNoAutoTrustID{token::getNextID(
+
1732  env, alice, 0u, tfTransferable, transferFee)};
+
1733  env(token::mint(alice, 0u),
+
1734  token::xferFee(transferFee),
+
1735  txflags(tfTransferable));
+
1736  env.close();
+
1737 
+
1738  // alice sells the nft using AUD.
+
1739  uint256 const aliceSellOfferIndex =
+
1740  keylet::nftoffer(alice, env.seq(alice)).key;
+
1741  env(token::createOffer(alice, nftNoAutoTrustID, gwAUD(200)),
+
1742  txflags(tfSellNFToken));
+
1743  env.close();
+
1744  env(token::acceptSellOffer(cheri, aliceSellOfferIndex));
+
1745  env.close();
+
1746 
+
1747  // alice should now have AUD(210):
+
1748  // o 200 for this sale and
+
1749  // o 10 for the previous sale's fee.
+
1750  BEAST_EXPECT(env.balance(alice, gwAUD) == gwAUD(210));
+
1751 
+
1752  // cheri can't sell the NFT for EUR, but can for CAD.
+
1753  env(token::createOffer(cheri, nftNoAutoTrustID, gwEUR(50)),
+
1754  txflags(tfSellNFToken),
+
1755  ter(tecNO_LINE));
+
1756  env.close();
+
1757  uint256 const cheriSellOfferIndex =
+
1758  keylet::nftoffer(cheri, env.seq(cheri)).key;
+
1759  env(token::createOffer(cheri, nftNoAutoTrustID, gwCAD(100)),
+
1760  txflags(tfSellNFToken));
+
1761  env.close();
+
1762  env(token::acceptSellOffer(becky, cheriSellOfferIndex));
+
1763  env.close();
+
1764 
+
1765  // alice should now have CAD(10):
+
1766  // o 5 from this sale's fee and
+
1767  // o 5 for the previous sale's fee.
+
1768  BEAST_EXPECT(env.balance(alice, gwCAD) == gwCAD(10));
+
1769  }
+
1770  }
+
1771  }
+
1772 
+
1773  void
+
1774  testMintFlagTransferable(FeatureBitset features)
+
1775  {
+
1776  // Exercise NFTs with flagTransferable set and not set.
+
1777  testcase("Mint flagTransferable");
+
1778 
+
1779  using namespace test::jtx;
+
1780 
+
1781  Env env{*this, features};
+
1782 
+
1783  Account const alice{"alice"};
+
1784  Account const becky{"becky"};
+
1785  Account const minter{"minter"};
1786 
-
1787  // becky tries to offer to buy alice's nft.
-
1788  BEAST_EXPECT(ownerCount(env, becky) == 0);
-
1789  env(token::createOffer(becky, nftAliceNoTransferID, XRP(20)),
-
1790  token::owner(alice),
-
1791  ter(tefNFTOKEN_IS_NOT_TRANSFERABLE));
-
1792 
-
1793  // alice offers to sell the nft and becky accepts the offer.
-
1794  uint256 const aliceSellOfferIndex =
-
1795  keylet::nftoffer(alice, env.seq(alice)).key;
-
1796  env(token::createOffer(alice, nftAliceNoTransferID, XRP(20)),
-
1797  txflags(tfSellNFToken));
-
1798  env.close();
-
1799  env(token::acceptSellOffer(becky, aliceSellOfferIndex));
-
1800  env.close();
-
1801  BEAST_EXPECT(ownerCount(env, alice) == 0);
-
1802  BEAST_EXPECT(ownerCount(env, becky) == 1);
-
1803 
-
1804  // becky tries to offer the nft for sale.
-
1805  env(token::createOffer(becky, nftAliceNoTransferID, XRP(21)),
-
1806  txflags(tfSellNFToken),
-
1807  ter(tefNFTOKEN_IS_NOT_TRANSFERABLE));
-
1808  env.close();
-
1809  BEAST_EXPECT(ownerCount(env, alice) == 0);
-
1810  BEAST_EXPECT(ownerCount(env, becky) == 1);
-
1811 
-
1812  // becky tries to offer the nft for sale with alice as the
-
1813  // destination. That also doesn't work.
-
1814  env(token::createOffer(becky, nftAliceNoTransferID, XRP(21)),
-
1815  txflags(tfSellNFToken),
-
1816  token::destination(alice),
-
1817  ter(tefNFTOKEN_IS_NOT_TRANSFERABLE));
-
1818  env.close();
-
1819  BEAST_EXPECT(ownerCount(env, alice) == 0);
-
1820  BEAST_EXPECT(ownerCount(env, becky) == 1);
-
1821 
-
1822  // alice offers to buy the nft back from becky. becky accepts
-
1823  // the offer.
-
1824  uint256 const aliceBuyOfferIndex =
-
1825  keylet::nftoffer(alice, env.seq(alice)).key;
-
1826  env(token::createOffer(alice, nftAliceNoTransferID, XRP(22)),
-
1827  token::owner(becky));
-
1828  env.close();
-
1829  env(token::acceptBuyOffer(becky, aliceBuyOfferIndex));
+
1787  env.fund(XRP(1000), alice, becky, minter);
+
1788  env.close();
+
1789 
+
1790  // First try an nft made by alice without flagTransferable set.
+
1791  {
+
1792  BEAST_EXPECT(ownerCount(env, alice) == 0);
+
1793  uint256 const nftAliceNoTransferID{
+
1794  token::getNextID(env, alice, 0u)};
+
1795  env(token::mint(alice, 0u), token::xferFee(0));
+
1796  env.close();
+
1797  BEAST_EXPECT(ownerCount(env, alice) == 1);
+
1798 
+
1799  // becky tries to offer to buy alice's nft.
+
1800  BEAST_EXPECT(ownerCount(env, becky) == 0);
+
1801  env(token::createOffer(becky, nftAliceNoTransferID, XRP(20)),
+
1802  token::owner(alice),
+
1803  ter(tefNFTOKEN_IS_NOT_TRANSFERABLE));
+
1804 
+
1805  // alice offers to sell the nft and becky accepts the offer.
+
1806  uint256 const aliceSellOfferIndex =
+
1807  keylet::nftoffer(alice, env.seq(alice)).key;
+
1808  env(token::createOffer(alice, nftAliceNoTransferID, XRP(20)),
+
1809  txflags(tfSellNFToken));
+
1810  env.close();
+
1811  env(token::acceptSellOffer(becky, aliceSellOfferIndex));
+
1812  env.close();
+
1813  BEAST_EXPECT(ownerCount(env, alice) == 0);
+
1814  BEAST_EXPECT(ownerCount(env, becky) == 1);
+
1815 
+
1816  // becky tries to offer the nft for sale.
+
1817  env(token::createOffer(becky, nftAliceNoTransferID, XRP(21)),
+
1818  txflags(tfSellNFToken),
+
1819  ter(tefNFTOKEN_IS_NOT_TRANSFERABLE));
+
1820  env.close();
+
1821  BEAST_EXPECT(ownerCount(env, alice) == 0);
+
1822  BEAST_EXPECT(ownerCount(env, becky) == 1);
+
1823 
+
1824  // becky tries to offer the nft for sale with alice as the
+
1825  // destination. That also doesn't work.
+
1826  env(token::createOffer(becky, nftAliceNoTransferID, XRP(21)),
+
1827  txflags(tfSellNFToken),
+
1828  token::destination(alice),
+
1829  ter(tefNFTOKEN_IS_NOT_TRANSFERABLE));
1830  env.close();
-
1831  BEAST_EXPECT(ownerCount(env, alice) == 1);
-
1832  BEAST_EXPECT(ownerCount(env, becky) == 0);
+
1831  BEAST_EXPECT(ownerCount(env, alice) == 0);
+
1832  BEAST_EXPECT(ownerCount(env, becky) == 1);
1833 
-
1834  // alice burns her nft so accounting is simpler below.
-
1835  env(token::burn(alice, nftAliceNoTransferID));
-
1836  env.close();
-
1837  BEAST_EXPECT(ownerCount(env, alice) == 0);
-
1838  BEAST_EXPECT(ownerCount(env, becky) == 0);
-
1839  }
-
1840  // Try an nft minted by minter for alice without flagTransferable set.
-
1841  {
-
1842  env(token::setMinter(alice, minter));
-
1843  env.close();
-
1844 
-
1845  BEAST_EXPECT(ownerCount(env, minter) == 0);
-
1846  uint256 const nftMinterNoTransferID{
-
1847  token::getNextID(env, alice, 0u)};
-
1848  env(token::mint(minter), token::issuer(alice));
-
1849  env.close();
-
1850  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
1851 
-
1852  // becky tries to offer to buy minter's nft.
-
1853  BEAST_EXPECT(ownerCount(env, becky) == 0);
-
1854  env(token::createOffer(becky, nftMinterNoTransferID, XRP(20)),
-
1855  token::owner(minter),
-
1856  ter(tefNFTOKEN_IS_NOT_TRANSFERABLE));
-
1857  env.close();
-
1858  BEAST_EXPECT(ownerCount(env, becky) == 0);
-
1859 
-
1860  // alice removes authorization of minter.
-
1861  env(token::clearMinter(alice));
-
1862  env.close();
+
1834  // alice offers to buy the nft back from becky. becky accepts
+
1835  // the offer.
+
1836  uint256 const aliceBuyOfferIndex =
+
1837  keylet::nftoffer(alice, env.seq(alice)).key;
+
1838  env(token::createOffer(alice, nftAliceNoTransferID, XRP(22)),
+
1839  token::owner(becky));
+
1840  env.close();
+
1841  env(token::acceptBuyOffer(becky, aliceBuyOfferIndex));
+
1842  env.close();
+
1843  BEAST_EXPECT(ownerCount(env, alice) == 1);
+
1844  BEAST_EXPECT(ownerCount(env, becky) == 0);
+
1845 
+
1846  // alice burns her nft so accounting is simpler below.
+
1847  env(token::burn(alice, nftAliceNoTransferID));
+
1848  env.close();
+
1849  BEAST_EXPECT(ownerCount(env, alice) == 0);
+
1850  BEAST_EXPECT(ownerCount(env, becky) == 0);
+
1851  }
+
1852  // Try an nft minted by minter for alice without flagTransferable set.
+
1853  {
+
1854  env(token::setMinter(alice, minter));
+
1855  env.close();
+
1856 
+
1857  BEAST_EXPECT(ownerCount(env, minter) == 0);
+
1858  uint256 const nftMinterNoTransferID{
+
1859  token::getNextID(env, alice, 0u)};
+
1860  env(token::mint(minter), token::issuer(alice));
+
1861  env.close();
+
1862  BEAST_EXPECT(ownerCount(env, minter) == 1);
1863 
-
1864  // minter tries to offer their nft for sale.
-
1865  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
1866  env(token::createOffer(minter, nftMinterNoTransferID, XRP(21)),
-
1867  txflags(tfSellNFToken),
+
1864  // becky tries to offer to buy minter's nft.
+
1865  BEAST_EXPECT(ownerCount(env, becky) == 0);
+
1866  env(token::createOffer(becky, nftMinterNoTransferID, XRP(20)),
+
1867  token::owner(minter),
1868  ter(tefNFTOKEN_IS_NOT_TRANSFERABLE));
1869  env.close();
-
1870  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
1870  BEAST_EXPECT(ownerCount(env, becky) == 0);
1871 
-
1872  // Let enough ledgers pass that old transactions are no longer
-
1873  // retried, then alice gives authorization back to minter.
-
1874  for (int i = 0; i < 10; ++i)
-
1875  env.close();
-
1876 
-
1877  env(token::setMinter(alice, minter));
-
1878  env.close();
-
1879  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
1880 
-
1881  // minter successfully offers their nft for sale.
+
1872  // alice removes authorization of minter.
+
1873  env(token::clearMinter(alice));
+
1874  env.close();
+
1875 
+
1876  // minter tries to offer their nft for sale.
+
1877  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
1878  env(token::createOffer(minter, nftMinterNoTransferID, XRP(21)),
+
1879  txflags(tfSellNFToken),
+
1880  ter(tefNFTOKEN_IS_NOT_TRANSFERABLE));
+
1881  env.close();
1882  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
1883  uint256 const minterSellOfferIndex =
-
1884  keylet::nftoffer(minter, env.seq(minter)).key;
-
1885  env(token::createOffer(minter, nftMinterNoTransferID, XRP(22)),
-
1886  txflags(tfSellNFToken));
-
1887  env.close();
-
1888  BEAST_EXPECT(ownerCount(env, minter) == 2);
-
1889 
-
1890  // alice removes authorization of minter so we can see whether
-
1891  // minter's pre-existing offer still works.
-
1892  env(token::clearMinter(alice));
-
1893  env.close();
-
1894 
-
1895  // becky buys minter's nft even though minter is no longer alice's
-
1896  // official minter.
-
1897  BEAST_EXPECT(ownerCount(env, becky) == 0);
-
1898  env(token::acceptSellOffer(becky, minterSellOfferIndex));
+
1883 
+
1884  // Let enough ledgers pass that old transactions are no longer
+
1885  // retried, then alice gives authorization back to minter.
+
1886  for (int i = 0; i < 10; ++i)
+
1887  env.close();
+
1888 
+
1889  env(token::setMinter(alice, minter));
+
1890  env.close();
+
1891  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
1892 
+
1893  // minter successfully offers their nft for sale.
+
1894  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
1895  uint256 const minterSellOfferIndex =
+
1896  keylet::nftoffer(minter, env.seq(minter)).key;
+
1897  env(token::createOffer(minter, nftMinterNoTransferID, XRP(22)),
+
1898  txflags(tfSellNFToken));
1899  env.close();
-
1900  BEAST_EXPECT(ownerCount(env, becky) == 1);
-
1901  BEAST_EXPECT(ownerCount(env, minter) == 0);
-
1902 
-
1903  // becky attempts to sell the nft.
-
1904  env(token::createOffer(becky, nftMinterNoTransferID, XRP(23)),
-
1905  txflags(tfSellNFToken),
-
1906  ter(tefNFTOKEN_IS_NOT_TRANSFERABLE));
-
1907  env.close();
-
1908 
-
1909  // Since minter is not, at the moment, alice's official minter
-
1910  // they cannot create an offer to buy the nft they minted.
-
1911  BEAST_EXPECT(ownerCount(env, minter) == 0);
-
1912  env(token::createOffer(minter, nftMinterNoTransferID, XRP(24)),
-
1913  token::owner(becky),
-
1914  ter(tefNFTOKEN_IS_NOT_TRANSFERABLE));
-
1915  env.close();
-
1916  BEAST_EXPECT(ownerCount(env, minter) == 0);
-
1917 
-
1918  // alice can create an offer to buy the nft.
-
1919  BEAST_EXPECT(ownerCount(env, alice) == 0);
-
1920  uint256 const aliceBuyOfferIndex =
-
1921  keylet::nftoffer(alice, env.seq(alice)).key;
-
1922  env(token::createOffer(alice, nftMinterNoTransferID, XRP(25)),
-
1923  token::owner(becky));
-
1924  env.close();
-
1925  BEAST_EXPECT(ownerCount(env, alice) == 1);
-
1926 
-
1927  // Let enough ledgers pass that old transactions are no longer
-
1928  // retried, then alice gives authorization back to minter.
-
1929  for (int i = 0; i < 10; ++i)
-
1930  env.close();
-
1931 
-
1932  env(token::setMinter(alice, minter));
-
1933  env.close();
-
1934 
-
1935  // Now minter can create an offer to buy the nft.
-
1936  BEAST_EXPECT(ownerCount(env, minter) == 0);
-
1937  uint256 const minterBuyOfferIndex =
-
1938  keylet::nftoffer(minter, env.seq(minter)).key;
-
1939  env(token::createOffer(minter, nftMinterNoTransferID, XRP(26)),
-
1940  token::owner(becky));
-
1941  env.close();
-
1942  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
1900  BEAST_EXPECT(ownerCount(env, minter) == 2);
+
1901 
+
1902  // alice removes authorization of minter so we can see whether
+
1903  // minter's pre-existing offer still works.
+
1904  env(token::clearMinter(alice));
+
1905  env.close();
+
1906 
+
1907  // becky buys minter's nft even though minter is no longer alice's
+
1908  // official minter.
+
1909  BEAST_EXPECT(ownerCount(env, becky) == 0);
+
1910  env(token::acceptSellOffer(becky, minterSellOfferIndex));
+
1911  env.close();
+
1912  BEAST_EXPECT(ownerCount(env, becky) == 1);
+
1913  BEAST_EXPECT(ownerCount(env, minter) == 0);
+
1914 
+
1915  // becky attempts to sell the nft.
+
1916  env(token::createOffer(becky, nftMinterNoTransferID, XRP(23)),
+
1917  txflags(tfSellNFToken),
+
1918  ter(tefNFTOKEN_IS_NOT_TRANSFERABLE));
+
1919  env.close();
+
1920 
+
1921  // Since minter is not, at the moment, alice's official minter
+
1922  // they cannot create an offer to buy the nft they minted.
+
1923  BEAST_EXPECT(ownerCount(env, minter) == 0);
+
1924  env(token::createOffer(minter, nftMinterNoTransferID, XRP(24)),
+
1925  token::owner(becky),
+
1926  ter(tefNFTOKEN_IS_NOT_TRANSFERABLE));
+
1927  env.close();
+
1928  BEAST_EXPECT(ownerCount(env, minter) == 0);
+
1929 
+
1930  // alice can create an offer to buy the nft.
+
1931  BEAST_EXPECT(ownerCount(env, alice) == 0);
+
1932  uint256 const aliceBuyOfferIndex =
+
1933  keylet::nftoffer(alice, env.seq(alice)).key;
+
1934  env(token::createOffer(alice, nftMinterNoTransferID, XRP(25)),
+
1935  token::owner(becky));
+
1936  env.close();
+
1937  BEAST_EXPECT(ownerCount(env, alice) == 1);
+
1938 
+
1939  // Let enough ledgers pass that old transactions are no longer
+
1940  // retried, then alice gives authorization back to minter.
+
1941  for (int i = 0; i < 10; ++i)
+
1942  env.close();
1943 
-
1944  // alice removes authorization of minter so we can see whether
-
1945  // minter's pre-existing buy offer still works.
-
1946  env(token::clearMinter(alice));
-
1947  env.close();
-
1948 
-
1949  // becky accepts minter's sell offer.
-
1950  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
1951  BEAST_EXPECT(ownerCount(env, becky) == 1);
-
1952  env(token::acceptBuyOffer(becky, minterBuyOfferIndex));
+
1944  env(token::setMinter(alice, minter));
+
1945  env.close();
+
1946 
+
1947  // Now minter can create an offer to buy the nft.
+
1948  BEAST_EXPECT(ownerCount(env, minter) == 0);
+
1949  uint256 const minterBuyOfferIndex =
+
1950  keylet::nftoffer(minter, env.seq(minter)).key;
+
1951  env(token::createOffer(minter, nftMinterNoTransferID, XRP(26)),
+
1952  token::owner(becky));
1953  env.close();
1954  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
1955  BEAST_EXPECT(ownerCount(env, becky) == 0);
-
1956  BEAST_EXPECT(ownerCount(env, alice) == 1);
-
1957 
-
1958  // minter burns their nft and alice cancels her offer so the
-
1959  // next tests can start with a clean slate.
-
1960  env(token::burn(minter, nftMinterNoTransferID), ter(tesSUCCESS));
-
1961  env.close();
-
1962  env(token::cancelOffer(alice, {aliceBuyOfferIndex}));
-
1963  env.close();
-
1964  BEAST_EXPECT(ownerCount(env, alice) == 0);
-
1965  BEAST_EXPECT(ownerCount(env, becky) == 0);
-
1966  BEAST_EXPECT(ownerCount(env, minter) == 0);
-
1967  }
-
1968  // nfts with flagTransferable set should be buyable and salable
-
1969  // by anybody.
-
1970  {
-
1971  BEAST_EXPECT(ownerCount(env, alice) == 0);
-
1972  uint256 const nftAliceID{
-
1973  token::getNextID(env, alice, 0u, tfTransferable)};
-
1974  env(token::mint(alice, 0u), txflags(tfTransferable));
+
1955 
+
1956  // alice removes authorization of minter so we can see whether
+
1957  // minter's pre-existing buy offer still works.
+
1958  env(token::clearMinter(alice));
+
1959  env.close();
+
1960 
+
1961  // becky accepts minter's sell offer.
+
1962  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
1963  BEAST_EXPECT(ownerCount(env, becky) == 1);
+
1964  env(token::acceptBuyOffer(becky, minterBuyOfferIndex));
+
1965  env.close();
+
1966  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
1967  BEAST_EXPECT(ownerCount(env, becky) == 0);
+
1968  BEAST_EXPECT(ownerCount(env, alice) == 1);
+
1969 
+
1970  // minter burns their nft and alice cancels her offer so the
+
1971  // next tests can start with a clean slate.
+
1972  env(token::burn(minter, nftMinterNoTransferID), ter(tesSUCCESS));
+
1973  env.close();
+
1974  env(token::cancelOffer(alice, {aliceBuyOfferIndex}));
1975  env.close();
-
1976  BEAST_EXPECT(ownerCount(env, alice) == 1);
-
1977 
-
1978  // Both alice and becky can make offers for alice's nft.
-
1979  uint256 const aliceSellOfferIndex =
-
1980  keylet::nftoffer(alice, env.seq(alice)).key;
-
1981  env(token::createOffer(alice, nftAliceID, XRP(20)),
-
1982  txflags(tfSellNFToken));
-
1983  env.close();
-
1984  BEAST_EXPECT(ownerCount(env, alice) == 2);
-
1985 
-
1986  uint256 const beckyBuyOfferIndex =
-
1987  keylet::nftoffer(becky, env.seq(becky)).key;
-
1988  env(token::createOffer(becky, nftAliceID, XRP(21)),
-
1989  token::owner(alice));
-
1990  env.close();
-
1991  BEAST_EXPECT(ownerCount(env, alice) == 2);
-
1992 
-
1993  // becky accepts alice's sell offer.
-
1994  env(token::acceptSellOffer(becky, aliceSellOfferIndex));
+
1976  BEAST_EXPECT(ownerCount(env, alice) == 0);
+
1977  BEAST_EXPECT(ownerCount(env, becky) == 0);
+
1978  BEAST_EXPECT(ownerCount(env, minter) == 0);
+
1979  }
+
1980  // nfts with flagTransferable set should be buyable and salable
+
1981  // by anybody.
+
1982  {
+
1983  BEAST_EXPECT(ownerCount(env, alice) == 0);
+
1984  uint256 const nftAliceID{
+
1985  token::getNextID(env, alice, 0u, tfTransferable)};
+
1986  env(token::mint(alice, 0u), txflags(tfTransferable));
+
1987  env.close();
+
1988  BEAST_EXPECT(ownerCount(env, alice) == 1);
+
1989 
+
1990  // Both alice and becky can make offers for alice's nft.
+
1991  uint256 const aliceSellOfferIndex =
+
1992  keylet::nftoffer(alice, env.seq(alice)).key;
+
1993  env(token::createOffer(alice, nftAliceID, XRP(20)),
+
1994  txflags(tfSellNFToken));
1995  env.close();
-
1996  BEAST_EXPECT(ownerCount(env, alice) == 0);
-
1997  BEAST_EXPECT(ownerCount(env, becky) == 2);
-
1998 
-
1999  // becky offers to sell the nft.
-
2000  uint256 const beckySellOfferIndex =
-
2001  keylet::nftoffer(becky, env.seq(becky)).key;
-
2002  env(token::createOffer(becky, nftAliceID, XRP(22)),
-
2003  txflags(tfSellNFToken));
-
2004  env.close();
-
2005  BEAST_EXPECT(ownerCount(env, alice) == 0);
-
2006  BEAST_EXPECT(ownerCount(env, becky) == 3);
-
2007 
-
2008  // minter buys the nft (even though minter is not currently
-
2009  // alice's minter).
-
2010  env(token::acceptSellOffer(minter, beckySellOfferIndex));
-
2011  env.close();
-
2012  BEAST_EXPECT(ownerCount(env, alice) == 0);
-
2013  BEAST_EXPECT(ownerCount(env, becky) == 1);
-
2014  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
2015 
-
2016  // minter offers to sell the nft.
-
2017  uint256 const minterSellOfferIndex =
-
2018  keylet::nftoffer(minter, env.seq(minter)).key;
-
2019  env(token::createOffer(minter, nftAliceID, XRP(23)),
-
2020  txflags(tfSellNFToken));
-
2021  env.close();
-
2022  BEAST_EXPECT(ownerCount(env, alice) == 0);
-
2023  BEAST_EXPECT(ownerCount(env, becky) == 1);
-
2024  BEAST_EXPECT(ownerCount(env, minter) == 2);
-
2025 
-
2026  // alice buys back the nft.
-
2027  env(token::acceptSellOffer(alice, minterSellOfferIndex));
-
2028  env.close();
-
2029  BEAST_EXPECT(ownerCount(env, alice) == 1);
-
2030  BEAST_EXPECT(ownerCount(env, becky) == 1);
-
2031  BEAST_EXPECT(ownerCount(env, minter) == 0);
-
2032 
-
2033  // Remember the buy offer that becky made for alice's token way
-
2034  // back when? It's still in the ledger, and alice accepts it.
-
2035  env(token::acceptBuyOffer(alice, beckyBuyOfferIndex));
-
2036  env.close();
-
2037  BEAST_EXPECT(ownerCount(env, alice) == 0);
-
2038  BEAST_EXPECT(ownerCount(env, becky) == 1);
-
2039  BEAST_EXPECT(ownerCount(env, minter) == 0);
-
2040 
-
2041  // Just for tidyness, becky burns the token before shutting
-
2042  // things down.
-
2043  env(token::burn(becky, nftAliceID));
-
2044  env.close();
-
2045  BEAST_EXPECT(ownerCount(env, alice) == 0);
-
2046  BEAST_EXPECT(ownerCount(env, becky) == 0);
-
2047  BEAST_EXPECT(ownerCount(env, minter) == 0);
-
2048  }
-
2049  }
-
2050 
-
2051  void
-
2052  testMintTransferFee(FeatureBitset features)
-
2053  {
-
2054  // Exercise NFTs with and without a transferFee.
-
2055  testcase("Mint transferFee");
-
2056 
-
2057  using namespace test::jtx;
-
2058 
-
2059  Env env{*this, features};
-
2060 
-
2061  Account const alice{"alice"};
-
2062  Account const becky{"becky"};
-
2063  Account const carol{"carol"};
-
2064  Account const minter{"minter"};
-
2065  Account const gw{"gw"};
-
2066  IOU const gwXAU(gw["XAU"]);
-
2067 
-
2068  env.fund(XRP(1000), alice, becky, carol, minter, gw);
-
2069  env.close();
+
1996  BEAST_EXPECT(ownerCount(env, alice) == 2);
+
1997 
+
1998  uint256 const beckyBuyOfferIndex =
+
1999  keylet::nftoffer(becky, env.seq(becky)).key;
+
2000  env(token::createOffer(becky, nftAliceID, XRP(21)),
+
2001  token::owner(alice));
+
2002  env.close();
+
2003  BEAST_EXPECT(ownerCount(env, alice) == 2);
+
2004 
+
2005  // becky accepts alice's sell offer.
+
2006  env(token::acceptSellOffer(becky, aliceSellOfferIndex));
+
2007  env.close();
+
2008  BEAST_EXPECT(ownerCount(env, alice) == 0);
+
2009  BEAST_EXPECT(ownerCount(env, becky) == 2);
+
2010 
+
2011  // becky offers to sell the nft.
+
2012  uint256 const beckySellOfferIndex =
+
2013  keylet::nftoffer(becky, env.seq(becky)).key;
+
2014  env(token::createOffer(becky, nftAliceID, XRP(22)),
+
2015  txflags(tfSellNFToken));
+
2016  env.close();
+
2017  BEAST_EXPECT(ownerCount(env, alice) == 0);
+
2018  BEAST_EXPECT(ownerCount(env, becky) == 3);
+
2019 
+
2020  // minter buys the nft (even though minter is not currently
+
2021  // alice's minter).
+
2022  env(token::acceptSellOffer(minter, beckySellOfferIndex));
+
2023  env.close();
+
2024  BEAST_EXPECT(ownerCount(env, alice) == 0);
+
2025  BEAST_EXPECT(ownerCount(env, becky) == 1);
+
2026  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
2027 
+
2028  // minter offers to sell the nft.
+
2029  uint256 const minterSellOfferIndex =
+
2030  keylet::nftoffer(minter, env.seq(minter)).key;
+
2031  env(token::createOffer(minter, nftAliceID, XRP(23)),
+
2032  txflags(tfSellNFToken));
+
2033  env.close();
+
2034  BEAST_EXPECT(ownerCount(env, alice) == 0);
+
2035  BEAST_EXPECT(ownerCount(env, becky) == 1);
+
2036  BEAST_EXPECT(ownerCount(env, minter) == 2);
+
2037 
+
2038  // alice buys back the nft.
+
2039  env(token::acceptSellOffer(alice, minterSellOfferIndex));
+
2040  env.close();
+
2041  BEAST_EXPECT(ownerCount(env, alice) == 1);
+
2042  BEAST_EXPECT(ownerCount(env, becky) == 1);
+
2043  BEAST_EXPECT(ownerCount(env, minter) == 0);
+
2044 
+
2045  // Remember the buy offer that becky made for alice's token way
+
2046  // back when? It's still in the ledger, and alice accepts it.
+
2047  env(token::acceptBuyOffer(alice, beckyBuyOfferIndex));
+
2048  env.close();
+
2049  BEAST_EXPECT(ownerCount(env, alice) == 0);
+
2050  BEAST_EXPECT(ownerCount(env, becky) == 1);
+
2051  BEAST_EXPECT(ownerCount(env, minter) == 0);
+
2052 
+
2053  // Just for tidyness, becky burns the token before shutting
+
2054  // things down.
+
2055  env(token::burn(becky, nftAliceID));
+
2056  env.close();
+
2057  BEAST_EXPECT(ownerCount(env, alice) == 0);
+
2058  BEAST_EXPECT(ownerCount(env, becky) == 0);
+
2059  BEAST_EXPECT(ownerCount(env, minter) == 0);
+
2060  }
+
2061  }
+
2062 
+
2063  void
+
2064  testMintTransferFee(FeatureBitset features)
+
2065  {
+
2066  // Exercise NFTs with and without a transferFee.
+
2067  testcase("Mint transferFee");
+
2068 
+
2069  using namespace test::jtx;
2070 
-
2071  env(trust(alice, gwXAU(2000)));
-
2072  env(trust(becky, gwXAU(2000)));
-
2073  env(trust(carol, gwXAU(2000)));
-
2074  env(trust(minter, gwXAU(2000)));
-
2075  env.close();
-
2076  env(pay(gw, alice, gwXAU(1000)));
-
2077  env(pay(gw, becky, gwXAU(1000)));
-
2078  env(pay(gw, carol, gwXAU(1000)));
-
2079  env(pay(gw, minter, gwXAU(1000)));
-
2080  env.close();
-
2081 
-
2082  // Giving alice a minter helps us see if transfer rates are affected
-
2083  // by that.
-
2084  env(token::setMinter(alice, minter));
-
2085  env.close();
-
2086 
-
2087  // If there is no transferFee, then alice gets nothing for the
-
2088  // transfer.
-
2089  {
-
2090  BEAST_EXPECT(ownerCount(env, alice) == 1);
-
2091  BEAST_EXPECT(ownerCount(env, becky) == 1);
-
2092  BEAST_EXPECT(ownerCount(env, carol) == 1);
-
2093  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
2094 
-
2095  uint256 const nftID =
-
2096  token::getNextID(env, alice, 0u, tfTransferable);
-
2097  env(token::mint(alice), txflags(tfTransferable));
-
2098  env.close();
-
2099 
-
2100  // Becky buys the nft for XAU(10). Check balances.
-
2101  uint256 const beckyBuyOfferIndex =
-
2102  keylet::nftoffer(becky, env.seq(becky)).key;
-
2103  env(token::createOffer(becky, nftID, gwXAU(10)),
-
2104  token::owner(alice));
-
2105  env.close();
-
2106  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1000));
-
2107  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1000));
-
2108 
-
2109  env(token::acceptBuyOffer(alice, beckyBuyOfferIndex));
+
2071  Env env{*this, features};
+
2072 
+
2073  Account const alice{"alice"};
+
2074  Account const becky{"becky"};
+
2075  Account const carol{"carol"};
+
2076  Account const minter{"minter"};
+
2077  Account const gw{"gw"};
+
2078  IOU const gwXAU(gw["XAU"]);
+
2079 
+
2080  env.fund(XRP(1000), alice, becky, carol, minter, gw);
+
2081  env.close();
+
2082 
+
2083  env(trust(alice, gwXAU(2000)));
+
2084  env(trust(becky, gwXAU(2000)));
+
2085  env(trust(carol, gwXAU(2000)));
+
2086  env(trust(minter, gwXAU(2000)));
+
2087  env.close();
+
2088  env(pay(gw, alice, gwXAU(1000)));
+
2089  env(pay(gw, becky, gwXAU(1000)));
+
2090  env(pay(gw, carol, gwXAU(1000)));
+
2091  env(pay(gw, minter, gwXAU(1000)));
+
2092  env.close();
+
2093 
+
2094  // Giving alice a minter helps us see if transfer rates are affected
+
2095  // by that.
+
2096  env(token::setMinter(alice, minter));
+
2097  env.close();
+
2098 
+
2099  // If there is no transferFee, then alice gets nothing for the
+
2100  // transfer.
+
2101  {
+
2102  BEAST_EXPECT(ownerCount(env, alice) == 1);
+
2103  BEAST_EXPECT(ownerCount(env, becky) == 1);
+
2104  BEAST_EXPECT(ownerCount(env, carol) == 1);
+
2105  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
2106 
+
2107  uint256 const nftID =
+
2108  token::getNextID(env, alice, 0u, tfTransferable);
+
2109  env(token::mint(alice), txflags(tfTransferable));
2110  env.close();
-
2111  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1010));
-
2112  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(990));
-
2113 
-
2114  // becky sells nft to carol. alice's balance should not change.
-
2115  uint256 const beckySellOfferIndex =
-
2116  keylet::nftoffer(becky, env.seq(becky)).key;
-
2117  env(token::createOffer(becky, nftID, gwXAU(10)),
-
2118  txflags(tfSellNFToken));
-
2119  env.close();
-
2120  env(token::acceptSellOffer(carol, beckySellOfferIndex));
-
2121  env.close();
-
2122  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1010));
-
2123  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1000));
-
2124  BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(990));
+
2111 
+
2112  // Becky buys the nft for XAU(10). Check balances.
+
2113  uint256 const beckyBuyOfferIndex =
+
2114  keylet::nftoffer(becky, env.seq(becky)).key;
+
2115  env(token::createOffer(becky, nftID, gwXAU(10)),
+
2116  token::owner(alice));
+
2117  env.close();
+
2118  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1000));
+
2119  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1000));
+
2120 
+
2121  env(token::acceptBuyOffer(alice, beckyBuyOfferIndex));
+
2122  env.close();
+
2123  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1010));
+
2124  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(990));
2125 
-
2126  // minter buys nft from carol. alice's balance should not change.
-
2127  uint256 const minterBuyOfferIndex =
-
2128  keylet::nftoffer(minter, env.seq(minter)).key;
-
2129  env(token::createOffer(minter, nftID, gwXAU(10)),
-
2130  token::owner(carol));
+
2126  // becky sells nft to carol. alice's balance should not change.
+
2127  uint256 const beckySellOfferIndex =
+
2128  keylet::nftoffer(becky, env.seq(becky)).key;
+
2129  env(token::createOffer(becky, nftID, gwXAU(10)),
+
2130  txflags(tfSellNFToken));
2131  env.close();
-
2132  env(token::acceptBuyOffer(carol, minterBuyOfferIndex));
+
2132  env(token::acceptSellOffer(carol, beckySellOfferIndex));
2133  env.close();
2134  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1010));
2135  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1000));
-
2136  BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(1000));
-
2137  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(990));
-
2138 
-
2139  // minter sells the nft to alice. gwXAU balances should finish
-
2140  // where they started.
-
2141  uint256 const minterSellOfferIndex =
-
2142  keylet::nftoffer(minter, env.seq(minter)).key;
-
2143  env(token::createOffer(minter, nftID, gwXAU(10)),
-
2144  txflags(tfSellNFToken));
+
2136  BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(990));
+
2137 
+
2138  // minter buys nft from carol. alice's balance should not change.
+
2139  uint256 const minterBuyOfferIndex =
+
2140  keylet::nftoffer(minter, env.seq(minter)).key;
+
2141  env(token::createOffer(minter, nftID, gwXAU(10)),
+
2142  token::owner(carol));
+
2143  env.close();
+
2144  env(token::acceptBuyOffer(carol, minterBuyOfferIndex));
2145  env.close();
-
2146  env(token::acceptSellOffer(alice, minterSellOfferIndex));
-
2147  env.close();
-
2148  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1000));
-
2149  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1000));
-
2150  BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(1000));
-
2151  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(1000));
-
2152 
-
2153  // alice burns the nft to make later tests easier to think about.
-
2154  env(token::burn(alice, nftID));
-
2155  env.close();
-
2156  BEAST_EXPECT(ownerCount(env, alice) == 1);
-
2157  BEAST_EXPECT(ownerCount(env, becky) == 1);
-
2158  BEAST_EXPECT(ownerCount(env, carol) == 1);
-
2159  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
2160  }
-
2161 
-
2162  // Set the smallest possible transfer fee.
-
2163  {
-
2164  // An nft with a transfer fee of 1 basis point.
-
2165  uint256 const nftID =
-
2166  token::getNextID(env, alice, 0u, tfTransferable, 1);
-
2167  env(token::mint(alice), txflags(tfTransferable), token::xferFee(1));
-
2168  env.close();
-
2169 
-
2170  // Becky buys the nft for XAU(10). Check balances.
-
2171  uint256 const beckyBuyOfferIndex =
-
2172  keylet::nftoffer(becky, env.seq(becky)).key;
-
2173  env(token::createOffer(becky, nftID, gwXAU(10)),
-
2174  token::owner(alice));
-
2175  env.close();
-
2176  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1000));
-
2177  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1000));
-
2178 
-
2179  env(token::acceptBuyOffer(alice, beckyBuyOfferIndex));
+
2146  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1010));
+
2147  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1000));
+
2148  BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(1000));
+
2149  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(990));
+
2150 
+
2151  // minter sells the nft to alice. gwXAU balances should finish
+
2152  // where they started.
+
2153  uint256 const minterSellOfferIndex =
+
2154  keylet::nftoffer(minter, env.seq(minter)).key;
+
2155  env(token::createOffer(minter, nftID, gwXAU(10)),
+
2156  txflags(tfSellNFToken));
+
2157  env.close();
+
2158  env(token::acceptSellOffer(alice, minterSellOfferIndex));
+
2159  env.close();
+
2160  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1000));
+
2161  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1000));
+
2162  BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(1000));
+
2163  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(1000));
+
2164 
+
2165  // alice burns the nft to make later tests easier to think about.
+
2166  env(token::burn(alice, nftID));
+
2167  env.close();
+
2168  BEAST_EXPECT(ownerCount(env, alice) == 1);
+
2169  BEAST_EXPECT(ownerCount(env, becky) == 1);
+
2170  BEAST_EXPECT(ownerCount(env, carol) == 1);
+
2171  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
2172  }
+
2173 
+
2174  // Set the smallest possible transfer fee.
+
2175  {
+
2176  // An nft with a transfer fee of 1 basis point.
+
2177  uint256 const nftID =
+
2178  token::getNextID(env, alice, 0u, tfTransferable, 1);
+
2179  env(token::mint(alice), txflags(tfTransferable), token::xferFee(1));
2180  env.close();
-
2181  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1010));
-
2182  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(990));
-
2183 
-
2184  // becky sells nft to carol. alice's balance goes up.
-
2185  uint256 const beckySellOfferIndex =
-
2186  keylet::nftoffer(becky, env.seq(becky)).key;
-
2187  env(token::createOffer(becky, nftID, gwXAU(10)),
-
2188  txflags(tfSellNFToken));
-
2189  env.close();
-
2190  env(token::acceptSellOffer(carol, beckySellOfferIndex));
-
2191  env.close();
-
2192 
-
2193  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1010.0001));
-
2194  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(999.9999));
-
2195  BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(990));
-
2196 
-
2197  // minter buys nft from carol. alice's balance goes up.
-
2198  uint256 const minterBuyOfferIndex =
-
2199  keylet::nftoffer(minter, env.seq(minter)).key;
-
2200  env(token::createOffer(minter, nftID, gwXAU(10)),
-
2201  token::owner(carol));
-
2202  env.close();
-
2203  env(token::acceptBuyOffer(carol, minterBuyOfferIndex));
-
2204  env.close();
-
2205 
-
2206  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1010.0002));
-
2207  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(999.9999));
-
2208  BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(999.9999));
-
2209  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(990));
-
2210 
-
2211  // minter sells the nft to alice. Because alice is part of the
-
2212  // transaction no tranfer fee is removed.
-
2213  uint256 const minterSellOfferIndex =
-
2214  keylet::nftoffer(minter, env.seq(minter)).key;
-
2215  env(token::createOffer(minter, nftID, gwXAU(10)),
-
2216  txflags(tfSellNFToken));
-
2217  env.close();
-
2218  env(token::acceptSellOffer(alice, minterSellOfferIndex));
-
2219  env.close();
-
2220  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1000.0002));
-
2221  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(999.9999));
-
2222  BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(999.9999));
-
2223  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(1000));
-
2224 
-
2225  // alice pays to becky and carol so subsequent tests are easier
-
2226  // to think about.
-
2227  env(pay(alice, becky, gwXAU(0.0001)));
-
2228  env(pay(alice, carol, gwXAU(0.0001)));
+
2181 
+
2182  // Becky buys the nft for XAU(10). Check balances.
+
2183  uint256 const beckyBuyOfferIndex =
+
2184  keylet::nftoffer(becky, env.seq(becky)).key;
+
2185  env(token::createOffer(becky, nftID, gwXAU(10)),
+
2186  token::owner(alice));
+
2187  env.close();
+
2188  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1000));
+
2189  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1000));
+
2190 
+
2191  env(token::acceptBuyOffer(alice, beckyBuyOfferIndex));
+
2192  env.close();
+
2193  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1010));
+
2194  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(990));
+
2195 
+
2196  // becky sells nft to carol. alice's balance goes up.
+
2197  uint256 const beckySellOfferIndex =
+
2198  keylet::nftoffer(becky, env.seq(becky)).key;
+
2199  env(token::createOffer(becky, nftID, gwXAU(10)),
+
2200  txflags(tfSellNFToken));
+
2201  env.close();
+
2202  env(token::acceptSellOffer(carol, beckySellOfferIndex));
+
2203  env.close();
+
2204 
+
2205  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1010.0001));
+
2206  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(999.9999));
+
2207  BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(990));
+
2208 
+
2209  // minter buys nft from carol. alice's balance goes up.
+
2210  uint256 const minterBuyOfferIndex =
+
2211  keylet::nftoffer(minter, env.seq(minter)).key;
+
2212  env(token::createOffer(minter, nftID, gwXAU(10)),
+
2213  token::owner(carol));
+
2214  env.close();
+
2215  env(token::acceptBuyOffer(carol, minterBuyOfferIndex));
+
2216  env.close();
+
2217 
+
2218  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1010.0002));
+
2219  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(999.9999));
+
2220  BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(999.9999));
+
2221  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(990));
+
2222 
+
2223  // minter sells the nft to alice. Because alice is part of the
+
2224  // transaction no tranfer fee is removed.
+
2225  uint256 const minterSellOfferIndex =
+
2226  keylet::nftoffer(minter, env.seq(minter)).key;
+
2227  env(token::createOffer(minter, nftID, gwXAU(10)),
+
2228  txflags(tfSellNFToken));
2229  env.close();
-
2230 
-
2231  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1000));
-
2232  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1000));
-
2233  BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(1000));
-
2234  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(1000));
-
2235 
-
2236  // alice burns the nft to make later tests easier to think about.
-
2237  env(token::burn(alice, nftID));
-
2238  env.close();
-
2239  BEAST_EXPECT(ownerCount(env, alice) == 1);
-
2240  BEAST_EXPECT(ownerCount(env, becky) == 1);
-
2241  BEAST_EXPECT(ownerCount(env, carol) == 1);
-
2242  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
2243  }
-
2244 
-
2245  // Set the largest allowed transfer fee.
-
2246  {
-
2247  // A transfer fee greater than 50% is not allowed.
-
2248  env(token::mint(alice),
-
2249  txflags(tfTransferable),
-
2250  token::xferFee(maxTransferFee + 1),
-
2251  ter(temBAD_NFTOKEN_TRANSFER_FEE));
-
2252  env.close();
-
2253 
-
2254  // Make an nft with a transfer fee of 50%.
-
2255  uint256 const nftID = token::getNextID(
-
2256  env, alice, 0u, tfTransferable, maxTransferFee);
-
2257  env(token::mint(alice),
-
2258  txflags(tfTransferable),
-
2259  token::xferFee(maxTransferFee));
-
2260  env.close();
-
2261 
-
2262  // Becky buys the nft for XAU(10). Check balances.
-
2263  uint256 const beckyBuyOfferIndex =
-
2264  keylet::nftoffer(becky, env.seq(becky)).key;
-
2265  env(token::createOffer(becky, nftID, gwXAU(10)),
-
2266  token::owner(alice));
-
2267  env.close();
-
2268  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1000));
-
2269  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1000));
-
2270 
-
2271  env(token::acceptBuyOffer(alice, beckyBuyOfferIndex));
+
2230  env(token::acceptSellOffer(alice, minterSellOfferIndex));
+
2231  env.close();
+
2232  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1000.0002));
+
2233  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(999.9999));
+
2234  BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(999.9999));
+
2235  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(1000));
+
2236 
+
2237  // alice pays to becky and carol so subsequent tests are easier
+
2238  // to think about.
+
2239  env(pay(alice, becky, gwXAU(0.0001)));
+
2240  env(pay(alice, carol, gwXAU(0.0001)));
+
2241  env.close();
+
2242 
+
2243  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1000));
+
2244  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1000));
+
2245  BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(1000));
+
2246  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(1000));
+
2247 
+
2248  // alice burns the nft to make later tests easier to think about.
+
2249  env(token::burn(alice, nftID));
+
2250  env.close();
+
2251  BEAST_EXPECT(ownerCount(env, alice) == 1);
+
2252  BEAST_EXPECT(ownerCount(env, becky) == 1);
+
2253  BEAST_EXPECT(ownerCount(env, carol) == 1);
+
2254  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
2255  }
+
2256 
+
2257  // Set the largest allowed transfer fee.
+
2258  {
+
2259  // A transfer fee greater than 50% is not allowed.
+
2260  env(token::mint(alice),
+
2261  txflags(tfTransferable),
+
2262  token::xferFee(maxTransferFee + 1),
+
2263  ter(temBAD_NFTOKEN_TRANSFER_FEE));
+
2264  env.close();
+
2265 
+
2266  // Make an nft with a transfer fee of 50%.
+
2267  uint256 const nftID = token::getNextID(
+
2268  env, alice, 0u, tfTransferable, maxTransferFee);
+
2269  env(token::mint(alice),
+
2270  txflags(tfTransferable),
+
2271  token::xferFee(maxTransferFee));
2272  env.close();
-
2273  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1010));
-
2274  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(990));
-
2275 
-
2276  // becky sells nft to minter. alice's balance goes up.
-
2277  uint256 const beckySellOfferIndex =
-
2278  keylet::nftoffer(becky, env.seq(becky)).key;
-
2279  env(token::createOffer(becky, nftID, gwXAU(100)),
-
2280  txflags(tfSellNFToken));
-
2281  env.close();
-
2282  env(token::acceptSellOffer(minter, beckySellOfferIndex));
-
2283  env.close();
-
2284 
-
2285  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1060));
-
2286  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1040));
-
2287  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(900));
-
2288 
-
2289  // carol buys nft from minter. alice's balance goes up.
-
2290  uint256 const carolBuyOfferIndex =
-
2291  keylet::nftoffer(carol, env.seq(carol)).key;
-
2292  env(token::createOffer(carol, nftID, gwXAU(10)),
-
2293  token::owner(minter));
-
2294  env.close();
-
2295  env(token::acceptBuyOffer(minter, carolBuyOfferIndex));
-
2296  env.close();
-
2297 
-
2298  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1065));
-
2299  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1040));
-
2300  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(905));
-
2301  BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(990));
-
2302 
-
2303  // carol sells the nft to alice. Because alice is part of the
-
2304  // transaction no tranfer fee is removed.
-
2305  uint256 const carolSellOfferIndex =
-
2306  keylet::nftoffer(carol, env.seq(carol)).key;
-
2307  env(token::createOffer(carol, nftID, gwXAU(10)),
-
2308  txflags(tfSellNFToken));
-
2309  env.close();
-
2310  env(token::acceptSellOffer(alice, carolSellOfferIndex));
-
2311  env.close();
-
2312 
-
2313  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1055));
-
2314  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1040));
-
2315  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(905));
-
2316  BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(1000));
-
2317 
-
2318  // rebalance so subsequent tests are easier to think about.
-
2319  env(pay(alice, minter, gwXAU(55)));
-
2320  env(pay(becky, minter, gwXAU(40)));
+
2273 
+
2274  // Becky buys the nft for XAU(10). Check balances.
+
2275  uint256 const beckyBuyOfferIndex =
+
2276  keylet::nftoffer(becky, env.seq(becky)).key;
+
2277  env(token::createOffer(becky, nftID, gwXAU(10)),
+
2278  token::owner(alice));
+
2279  env.close();
+
2280  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1000));
+
2281  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1000));
+
2282 
+
2283  env(token::acceptBuyOffer(alice, beckyBuyOfferIndex));
+
2284  env.close();
+
2285  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1010));
+
2286  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(990));
+
2287 
+
2288  // becky sells nft to minter. alice's balance goes up.
+
2289  uint256 const beckySellOfferIndex =
+
2290  keylet::nftoffer(becky, env.seq(becky)).key;
+
2291  env(token::createOffer(becky, nftID, gwXAU(100)),
+
2292  txflags(tfSellNFToken));
+
2293  env.close();
+
2294  env(token::acceptSellOffer(minter, beckySellOfferIndex));
+
2295  env.close();
+
2296 
+
2297  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1060));
+
2298  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1040));
+
2299  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(900));
+
2300 
+
2301  // carol buys nft from minter. alice's balance goes up.
+
2302  uint256 const carolBuyOfferIndex =
+
2303  keylet::nftoffer(carol, env.seq(carol)).key;
+
2304  env(token::createOffer(carol, nftID, gwXAU(10)),
+
2305  token::owner(minter));
+
2306  env.close();
+
2307  env(token::acceptBuyOffer(minter, carolBuyOfferIndex));
+
2308  env.close();
+
2309 
+
2310  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1065));
+
2311  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1040));
+
2312  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(905));
+
2313  BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(990));
+
2314 
+
2315  // carol sells the nft to alice. Because alice is part of the
+
2316  // transaction no tranfer fee is removed.
+
2317  uint256 const carolSellOfferIndex =
+
2318  keylet::nftoffer(carol, env.seq(carol)).key;
+
2319  env(token::createOffer(carol, nftID, gwXAU(10)),
+
2320  txflags(tfSellNFToken));
2321  env.close();
-
2322  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1000));
-
2323  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1000));
-
2324  BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(1000));
-
2325  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(1000));
-
2326 
-
2327  // alice burns the nft to make later tests easier to think about.
-
2328  env(token::burn(alice, nftID));
-
2329  env.close();
-
2330  BEAST_EXPECT(ownerCount(env, alice) == 1);
-
2331  BEAST_EXPECT(ownerCount(env, becky) == 1);
-
2332  BEAST_EXPECT(ownerCount(env, carol) == 1);
-
2333  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
2334  }
-
2335 
-
2336  // See the impact of rounding when the nft is sold for small amounts
-
2337  // of drops.
-
2338  {
-
2339  // An nft with a transfer fee of 1 basis point.
-
2340  uint256 const nftID =
-
2341  token::getNextID(env, alice, 0u, tfTransferable, 1);
-
2342  env(token::mint(alice), txflags(tfTransferable), token::xferFee(1));
-
2343  env.close();
-
2344 
-
2345  // minter buys the nft for XRP(1). Since the transfer involves
-
2346  // alice there should be no transfer fee.
-
2347  STAmount fee = drops(10);
-
2348  STAmount aliceBalance = env.balance(alice);
-
2349  STAmount minterBalance = env.balance(minter);
-
2350  uint256 const minterBuyOfferIndex =
-
2351  keylet::nftoffer(minter, env.seq(minter)).key;
-
2352  env(token::createOffer(minter, nftID, XRP(1)), token::owner(alice));
-
2353  env.close();
-
2354  env(token::acceptBuyOffer(alice, minterBuyOfferIndex));
+
2322  env(token::acceptSellOffer(alice, carolSellOfferIndex));
+
2323  env.close();
+
2324 
+
2325  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1055));
+
2326  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1040));
+
2327  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(905));
+
2328  BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(1000));
+
2329 
+
2330  // rebalance so subsequent tests are easier to think about.
+
2331  env(pay(alice, minter, gwXAU(55)));
+
2332  env(pay(becky, minter, gwXAU(40)));
+
2333  env.close();
+
2334  BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1000));
+
2335  BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1000));
+
2336  BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(1000));
+
2337  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(1000));
+
2338 
+
2339  // alice burns the nft to make later tests easier to think about.
+
2340  env(token::burn(alice, nftID));
+
2341  env.close();
+
2342  BEAST_EXPECT(ownerCount(env, alice) == 1);
+
2343  BEAST_EXPECT(ownerCount(env, becky) == 1);
+
2344  BEAST_EXPECT(ownerCount(env, carol) == 1);
+
2345  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
2346  }
+
2347 
+
2348  // See the impact of rounding when the nft is sold for small amounts
+
2349  // of drops.
+
2350  {
+
2351  // An nft with a transfer fee of 1 basis point.
+
2352  uint256 const nftID =
+
2353  token::getNextID(env, alice, 0u, tfTransferable, 1);
+
2354  env(token::mint(alice), txflags(tfTransferable), token::xferFee(1));
2355  env.close();
-
2356  aliceBalance += XRP(1) - fee;
-
2357  minterBalance -= XRP(1) + fee;
-
2358  BEAST_EXPECT(env.balance(alice) == aliceBalance);
-
2359  BEAST_EXPECT(env.balance(minter) == minterBalance);
-
2360 
-
2361  // minter sells to carol. The payment is just small enough that
-
2362  // alice does not get any transfer fee.
-
2363  STAmount carolBalance = env.balance(carol);
-
2364  uint256 const minterSellOfferIndex =
-
2365  keylet::nftoffer(minter, env.seq(minter)).key;
-
2366  env(token::createOffer(minter, nftID, drops(99999)),
-
2367  txflags(tfSellNFToken));
-
2368  env.close();
-
2369  env(token::acceptSellOffer(carol, minterSellOfferIndex));
-
2370  env.close();
-
2371  minterBalance += drops(99999) - fee;
-
2372  carolBalance -= drops(99999) + fee;
-
2373  BEAST_EXPECT(env.balance(alice) == aliceBalance);
-
2374  BEAST_EXPECT(env.balance(minter) == minterBalance);
-
2375  BEAST_EXPECT(env.balance(carol) == carolBalance);
-
2376 
-
2377  // carol sells to becky. This is the smallest amount to pay for a
-
2378  // transfer that enables a transfer fee of 1 basis point.
-
2379  STAmount beckyBalance = env.balance(becky);
-
2380  uint256 const beckyBuyOfferIndex =
-
2381  keylet::nftoffer(becky, env.seq(becky)).key;
-
2382  env(token::createOffer(becky, nftID, drops(100000)),
-
2383  token::owner(carol));
-
2384  env.close();
-
2385  env(token::acceptBuyOffer(carol, beckyBuyOfferIndex));
-
2386  env.close();
-
2387  carolBalance += drops(99999) - fee;
-
2388  beckyBalance -= drops(100000) + fee;
-
2389  aliceBalance += drops(1);
-
2390 
-
2391  BEAST_EXPECT(env.balance(alice) == aliceBalance);
-
2392  BEAST_EXPECT(env.balance(minter) == minterBalance);
-
2393  BEAST_EXPECT(env.balance(carol) == carolBalance);
-
2394  BEAST_EXPECT(env.balance(becky) == beckyBalance);
-
2395  }
-
2396 
-
2397  // See the impact of rounding when the nft is sold for small amounts
-
2398  // of an IOU.
-
2399  {
-
2400  // An nft with a transfer fee of 1 basis point.
-
2401  uint256 const nftID =
-
2402  token::getNextID(env, alice, 0u, tfTransferable, 1);
-
2403  env(token::mint(alice), txflags(tfTransferable), token::xferFee(1));
-
2404  env.close();
-
2405 
-
2406  // Due to the floating point nature of IOUs we need to
-
2407  // significantly reduce the gwXAU balances of our accounts prior
-
2408  // to the iou transfer. Otherwise no transfers will happen.
-
2409  env(pay(alice, gw, env.balance(alice, gwXAU)));
-
2410  env(pay(minter, gw, env.balance(minter, gwXAU)));
-
2411  env(pay(becky, gw, env.balance(becky, gwXAU)));
-
2412  env.close();
-
2413 
-
2414  STAmount const startXAUBalance(
-
2415  gwXAU.issue(), STAmount::cMinValue, STAmount::cMinOffset + 5);
-
2416  env(pay(gw, alice, startXAUBalance));
-
2417  env(pay(gw, minter, startXAUBalance));
-
2418  env(pay(gw, becky, startXAUBalance));
-
2419  env.close();
-
2420 
-
2421  // Here is the smallest expressible gwXAU amount.
-
2422  STAmount tinyXAU(
-
2423  gwXAU.issue(), STAmount::cMinValue, STAmount::cMinOffset);
-
2424 
-
2425  // minter buys the nft for tinyXAU. Since the transfer involves
-
2426  // alice there should be no transfer fee.
-
2427  STAmount aliceBalance = env.balance(alice, gwXAU);
-
2428  STAmount minterBalance = env.balance(minter, gwXAU);
-
2429  uint256 const minterBuyOfferIndex =
-
2430  keylet::nftoffer(minter, env.seq(minter)).key;
-
2431  env(token::createOffer(minter, nftID, tinyXAU),
-
2432  token::owner(alice));
-
2433  env.close();
-
2434  env(token::acceptBuyOffer(alice, minterBuyOfferIndex));
-
2435  env.close();
-
2436  aliceBalance += tinyXAU;
-
2437  minterBalance -= tinyXAU;
-
2438  BEAST_EXPECT(env.balance(alice, gwXAU) == aliceBalance);
-
2439  BEAST_EXPECT(env.balance(minter, gwXAU) == minterBalance);
-
2440 
-
2441  // minter sells to carol.
-
2442  STAmount carolBalance = env.balance(carol, gwXAU);
-
2443  uint256 const minterSellOfferIndex =
-
2444  keylet::nftoffer(minter, env.seq(minter)).key;
-
2445  env(token::createOffer(minter, nftID, tinyXAU),
-
2446  txflags(tfSellNFToken));
+
2356 
+
2357  // minter buys the nft for XRP(1). Since the transfer involves
+
2358  // alice there should be no transfer fee.
+
2359  STAmount fee = drops(10);
+
2360  STAmount aliceBalance = env.balance(alice);
+
2361  STAmount minterBalance = env.balance(minter);
+
2362  uint256 const minterBuyOfferIndex =
+
2363  keylet::nftoffer(minter, env.seq(minter)).key;
+
2364  env(token::createOffer(minter, nftID, XRP(1)), token::owner(alice));
+
2365  env.close();
+
2366  env(token::acceptBuyOffer(alice, minterBuyOfferIndex));
+
2367  env.close();
+
2368  aliceBalance += XRP(1) - fee;
+
2369  minterBalance -= XRP(1) + fee;
+
2370  BEAST_EXPECT(env.balance(alice) == aliceBalance);
+
2371  BEAST_EXPECT(env.balance(minter) == minterBalance);
+
2372 
+
2373  // minter sells to carol. The payment is just small enough that
+
2374  // alice does not get any transfer fee.
+
2375  STAmount carolBalance = env.balance(carol);
+
2376  uint256 const minterSellOfferIndex =
+
2377  keylet::nftoffer(minter, env.seq(minter)).key;
+
2378  env(token::createOffer(minter, nftID, drops(99999)),
+
2379  txflags(tfSellNFToken));
+
2380  env.close();
+
2381  env(token::acceptSellOffer(carol, minterSellOfferIndex));
+
2382  env.close();
+
2383  minterBalance += drops(99999) - fee;
+
2384  carolBalance -= drops(99999) + fee;
+
2385  BEAST_EXPECT(env.balance(alice) == aliceBalance);
+
2386  BEAST_EXPECT(env.balance(minter) == minterBalance);
+
2387  BEAST_EXPECT(env.balance(carol) == carolBalance);
+
2388 
+
2389  // carol sells to becky. This is the smallest amount to pay for a
+
2390  // transfer that enables a transfer fee of 1 basis point.
+
2391  STAmount beckyBalance = env.balance(becky);
+
2392  uint256 const beckyBuyOfferIndex =
+
2393  keylet::nftoffer(becky, env.seq(becky)).key;
+
2394  env(token::createOffer(becky, nftID, drops(100000)),
+
2395  token::owner(carol));
+
2396  env.close();
+
2397  env(token::acceptBuyOffer(carol, beckyBuyOfferIndex));
+
2398  env.close();
+
2399  carolBalance += drops(99999) - fee;
+
2400  beckyBalance -= drops(100000) + fee;
+
2401  aliceBalance += drops(1);
+
2402 
+
2403  BEAST_EXPECT(env.balance(alice) == aliceBalance);
+
2404  BEAST_EXPECT(env.balance(minter) == minterBalance);
+
2405  BEAST_EXPECT(env.balance(carol) == carolBalance);
+
2406  BEAST_EXPECT(env.balance(becky) == beckyBalance);
+
2407  }
+
2408 
+
2409  // See the impact of rounding when the nft is sold for small amounts
+
2410  // of an IOU.
+
2411  {
+
2412  // An nft with a transfer fee of 1 basis point.
+
2413  uint256 const nftID =
+
2414  token::getNextID(env, alice, 0u, tfTransferable, 1);
+
2415  env(token::mint(alice), txflags(tfTransferable), token::xferFee(1));
+
2416  env.close();
+
2417 
+
2418  // Due to the floating point nature of IOUs we need to
+
2419  // significantly reduce the gwXAU balances of our accounts prior
+
2420  // to the iou transfer. Otherwise no transfers will happen.
+
2421  env(pay(alice, gw, env.balance(alice, gwXAU)));
+
2422  env(pay(minter, gw, env.balance(minter, gwXAU)));
+
2423  env(pay(becky, gw, env.balance(becky, gwXAU)));
+
2424  env.close();
+
2425 
+
2426  STAmount const startXAUBalance(
+
2427  gwXAU.issue(), STAmount::cMinValue, STAmount::cMinOffset + 5);
+
2428  env(pay(gw, alice, startXAUBalance));
+
2429  env(pay(gw, minter, startXAUBalance));
+
2430  env(pay(gw, becky, startXAUBalance));
+
2431  env.close();
+
2432 
+
2433  // Here is the smallest expressible gwXAU amount.
+
2434  STAmount tinyXAU(
+
2435  gwXAU.issue(), STAmount::cMinValue, STAmount::cMinOffset);
+
2436 
+
2437  // minter buys the nft for tinyXAU. Since the transfer involves
+
2438  // alice there should be no transfer fee.
+
2439  STAmount aliceBalance = env.balance(alice, gwXAU);
+
2440  STAmount minterBalance = env.balance(minter, gwXAU);
+
2441  uint256 const minterBuyOfferIndex =
+
2442  keylet::nftoffer(minter, env.seq(minter)).key;
+
2443  env(token::createOffer(minter, nftID, tinyXAU),
+
2444  token::owner(alice));
+
2445  env.close();
+
2446  env(token::acceptBuyOffer(alice, minterBuyOfferIndex));
2447  env.close();
-
2448  env(token::acceptSellOffer(carol, minterSellOfferIndex));
-
2449  env.close();
-
2450 
-
2451  minterBalance += tinyXAU;
-
2452  carolBalance -= tinyXAU;
-
2453  // tiny XAU is so small that alice does not get a transfer fee.
-
2454  BEAST_EXPECT(env.balance(alice, gwXAU) == aliceBalance);
-
2455  BEAST_EXPECT(env.balance(minter, gwXAU) == minterBalance);
-
2456  BEAST_EXPECT(env.balance(carol, gwXAU) == carolBalance);
-
2457 
-
2458  // carol sells to becky. This is the smallest gwXAU amount
-
2459  // to pay for a transfer that enables a transfer fee of 1.
-
2460  STAmount const cheapNFT(
-
2461  gwXAU.issue(), STAmount::cMinValue, STAmount::cMinOffset + 5);
+
2448  aliceBalance += tinyXAU;
+
2449  minterBalance -= tinyXAU;
+
2450  BEAST_EXPECT(env.balance(alice, gwXAU) == aliceBalance);
+
2451  BEAST_EXPECT(env.balance(minter, gwXAU) == minterBalance);
+
2452 
+
2453  // minter sells to carol.
+
2454  STAmount carolBalance = env.balance(carol, gwXAU);
+
2455  uint256 const minterSellOfferIndex =
+
2456  keylet::nftoffer(minter, env.seq(minter)).key;
+
2457  env(token::createOffer(minter, nftID, tinyXAU),
+
2458  txflags(tfSellNFToken));
+
2459  env.close();
+
2460  env(token::acceptSellOffer(carol, minterSellOfferIndex));
+
2461  env.close();
2462 
-
2463  STAmount beckyBalance = env.balance(becky, gwXAU);
-
2464  uint256 const beckyBuyOfferIndex =
-
2465  keylet::nftoffer(becky, env.seq(becky)).key;
-
2466  env(token::createOffer(becky, nftID, cheapNFT),
-
2467  token::owner(carol));
-
2468  env.close();
-
2469  env(token::acceptBuyOffer(carol, beckyBuyOfferIndex));
-
2470  env.close();
-
2471 
-
2472  aliceBalance += tinyXAU;
-
2473  beckyBalance -= cheapNFT;
-
2474  carolBalance += cheapNFT - tinyXAU;
-
2475  BEAST_EXPECT(env.balance(alice, gwXAU) == aliceBalance);
-
2476  BEAST_EXPECT(env.balance(minter, gwXAU) == minterBalance);
-
2477  BEAST_EXPECT(env.balance(carol, gwXAU) == carolBalance);
-
2478  BEAST_EXPECT(env.balance(becky, gwXAU) == beckyBalance);
-
2479  }
-
2480  }
-
2481 
-
2482  void
-
2483  testMintTaxon(FeatureBitset features)
-
2484  {
-
2485  // Exercise the NFT taxon field.
-
2486  testcase("Mint taxon");
-
2487 
-
2488  using namespace test::jtx;
-
2489 
-
2490  Env env{*this, features};
-
2491 
-
2492  Account const alice{"alice"};
-
2493  Account const becky{"becky"};
-
2494 
-
2495  env.fund(XRP(1000), alice, becky);
-
2496  env.close();
-
2497 
-
2498  // The taxon field is incorporated straight into the NFT ID. So
-
2499  // tests only need to operate on NFT IDs; we don't need to generate
-
2500  // any transactions.
+
2463  minterBalance += tinyXAU;
+
2464  carolBalance -= tinyXAU;
+
2465  // tiny XAU is so small that alice does not get a transfer fee.
+
2466  BEAST_EXPECT(env.balance(alice, gwXAU) == aliceBalance);
+
2467  BEAST_EXPECT(env.balance(minter, gwXAU) == minterBalance);
+
2468  BEAST_EXPECT(env.balance(carol, gwXAU) == carolBalance);
+
2469 
+
2470  // carol sells to becky. This is the smallest gwXAU amount
+
2471  // to pay for a transfer that enables a transfer fee of 1.
+
2472  STAmount const cheapNFT(
+
2473  gwXAU.issue(), STAmount::cMinValue, STAmount::cMinOffset + 5);
+
2474 
+
2475  STAmount beckyBalance = env.balance(becky, gwXAU);
+
2476  uint256 const beckyBuyOfferIndex =
+
2477  keylet::nftoffer(becky, env.seq(becky)).key;
+
2478  env(token::createOffer(becky, nftID, cheapNFT),
+
2479  token::owner(carol));
+
2480  env.close();
+
2481  env(token::acceptBuyOffer(carol, beckyBuyOfferIndex));
+
2482  env.close();
+
2483 
+
2484  aliceBalance += tinyXAU;
+
2485  beckyBalance -= cheapNFT;
+
2486  carolBalance += cheapNFT - tinyXAU;
+
2487  BEAST_EXPECT(env.balance(alice, gwXAU) == aliceBalance);
+
2488  BEAST_EXPECT(env.balance(minter, gwXAU) == minterBalance);
+
2489  BEAST_EXPECT(env.balance(carol, gwXAU) == carolBalance);
+
2490  BEAST_EXPECT(env.balance(becky, gwXAU) == beckyBalance);
+
2491  }
+
2492  }
+
2493 
+
2494  void
+
2495  testMintTaxon(FeatureBitset features)
+
2496  {
+
2497  // Exercise the NFT taxon field.
+
2498  testcase("Mint taxon");
+
2499 
+
2500  using namespace test::jtx;
2501 
-
2502  // The taxon value should be recoverable from the NFT ID.
-
2503  {
-
2504  uint256 const nftID = token::getNextID(env, alice, 0u);
-
2505  BEAST_EXPECT(nft::getTaxon(nftID) == nft::toTaxon(0));
-
2506  }
-
2507 
-
2508  // Make sure the full range of taxon values work. We just tried
-
2509  // the minimum. Now try the largest.
-
2510  {
-
2511  uint256 const nftID = token::getNextID(env, alice, 0xFFFFFFFFu);
-
2512  BEAST_EXPECT(nft::getTaxon(nftID) == nft::toTaxon((0xFFFFFFFF)));
-
2513  }
-
2514 
-
2515  // Do some touch testing to show that the taxon is recoverable no
-
2516  // matter what else changes around it in the nft ID.
-
2517  {
-
2518  std::uint32_t const taxon = rand_int<std::uint32_t>();
-
2519  for (int i = 0; i < 10; ++i)
-
2520  {
-
2521  // lambda to produce a useful message on error.
-
2522  auto check = [this](std::uint32_t taxon, uint256 const& nftID) {
-
2523  nft::Taxon const gotTaxon = nft::getTaxon(nftID);
-
2524  if (nft::toTaxon(taxon) == gotTaxon)
-
2525  pass();
-
2526  else
-
2527  {
-
2528  std::stringstream ss;
-
2529  ss << "Taxon recovery failed from nftID "
-
2530  << to_string(nftID) << ". Expected: " << taxon
-
2531  << "; got: " << gotTaxon;
-
2532  fail(ss.str());
-
2533  }
-
2534  };
-
2535 
-
2536  uint256 const nftAliceID = token::getID(
-
2537  alice,
-
2538  taxon,
-
2539  rand_int<std::uint32_t>(),
-
2540  rand_int<std::uint16_t>(),
-
2541  rand_int<std::uint16_t>());
-
2542  check(taxon, nftAliceID);
-
2543 
-
2544  uint256 const nftBeckyID = token::getID(
-
2545  becky,
-
2546  taxon,
-
2547  rand_int<std::uint32_t>(),
-
2548  rand_int<std::uint16_t>(),
-
2549  rand_int<std::uint16_t>());
-
2550  check(taxon, nftBeckyID);
-
2551  }
-
2552  }
-
2553  }
-
2554 
-
2555  void
-
2556  testMintURI(FeatureBitset features)
-
2557  {
-
2558  // Exercise the NFT URI field.
-
2559  // 1. Create a number of NFTs with and without URIs.
-
2560  // 2. Retrieve the NFTs from the server.
-
2561  // 3. Make sure the right URI is attached to each NFT.
-
2562  testcase("Mint URI");
-
2563 
-
2564  using namespace test::jtx;
-
2565 
-
2566  Env env{*this, features};
-
2567 
-
2568  Account const alice{"alice"};
-
2569  Account const becky{"becky"};
-
2570 
-
2571  env.fund(XRP(10000), alice, becky);
-
2572  env.close();
-
2573 
-
2574  // lambda that returns a randomly generated string which fits
-
2575  // the constraints of a URI. Empty strings may be returned.
-
2576  // In the empty string case do not add the URI to the nft.
-
2577  auto randURI = []() {
-
2578  std::string ret;
+
2502  Env env{*this, features};
+
2503 
+
2504  Account const alice{"alice"};
+
2505  Account const becky{"becky"};
+
2506 
+
2507  env.fund(XRP(1000), alice, becky);
+
2508  env.close();
+
2509 
+
2510  // The taxon field is incorporated straight into the NFT ID. So
+
2511  // tests only need to operate on NFT IDs; we don't need to generate
+
2512  // any transactions.
+
2513 
+
2514  // The taxon value should be recoverable from the NFT ID.
+
2515  {
+
2516  uint256 const nftID = token::getNextID(env, alice, 0u);
+
2517  BEAST_EXPECT(nft::getTaxon(nftID) == nft::toTaxon(0));
+
2518  }
+
2519 
+
2520  // Make sure the full range of taxon values work. We just tried
+
2521  // the minimum. Now try the largest.
+
2522  {
+
2523  uint256 const nftID = token::getNextID(env, alice, 0xFFFFFFFFu);
+
2524  BEAST_EXPECT(nft::getTaxon(nftID) == nft::toTaxon((0xFFFFFFFF)));
+
2525  }
+
2526 
+
2527  // Do some touch testing to show that the taxon is recoverable no
+
2528  // matter what else changes around it in the nft ID.
+
2529  {
+
2530  std::uint32_t const taxon = rand_int<std::uint32_t>();
+
2531  for (int i = 0; i < 10; ++i)
+
2532  {
+
2533  // lambda to produce a useful message on error.
+
2534  auto check = [this](std::uint32_t taxon, uint256 const& nftID) {
+
2535  nft::Taxon const gotTaxon = nft::getTaxon(nftID);
+
2536  if (nft::toTaxon(taxon) == gotTaxon)
+
2537  pass();
+
2538  else
+
2539  {
+
2540  std::stringstream ss;
+
2541  ss << "Taxon recovery failed from nftID "
+
2542  << to_string(nftID) << ". Expected: " << taxon
+
2543  << "; got: " << gotTaxon;
+
2544  fail(ss.str());
+
2545  }
+
2546  };
+
2547 
+
2548  uint256 const nftAliceID = token::getID(
+
2549  alice,
+
2550  taxon,
+
2551  rand_int<std::uint32_t>(),
+
2552  rand_int<std::uint16_t>(),
+
2553  rand_int<std::uint16_t>());
+
2554  check(taxon, nftAliceID);
+
2555 
+
2556  uint256 const nftBeckyID = token::getID(
+
2557  becky,
+
2558  taxon,
+
2559  rand_int<std::uint32_t>(),
+
2560  rand_int<std::uint16_t>(),
+
2561  rand_int<std::uint16_t>());
+
2562  check(taxon, nftBeckyID);
+
2563  }
+
2564  }
+
2565  }
+
2566 
+
2567  void
+
2568  testMintURI(FeatureBitset features)
+
2569  {
+
2570  // Exercise the NFT URI field.
+
2571  // 1. Create a number of NFTs with and without URIs.
+
2572  // 2. Retrieve the NFTs from the server.
+
2573  // 3. Make sure the right URI is attached to each NFT.
+
2574  testcase("Mint URI");
+
2575 
+
2576  using namespace test::jtx;
+
2577 
+
2578  Env env{*this, features};
2579 
-
2580  // About 20% of the returned strings should be empty
-
2581  if (rand_int(4) == 0)
-
2582  return ret;
-
2583 
-
2584  std::size_t const strLen = rand_int(256);
-
2585  ret.reserve(strLen);
-
2586  for (std::size_t i = 0; i < strLen; ++i)
-
2587  ret.push_back(rand_byte());
-
2588 
-
2589  return ret;
-
2590  };
+
2580  Account const alice{"alice"};
+
2581  Account const becky{"becky"};
+
2582 
+
2583  env.fund(XRP(10000), alice, becky);
+
2584  env.close();
+
2585 
+
2586  // lambda that returns a randomly generated string which fits
+
2587  // the constraints of a URI. Empty strings may be returned.
+
2588  // In the empty string case do not add the URI to the nft.
+
2589  auto randURI = []() {
+
2590  std::string ret;
2591 
-
2592  // Make a list of URIs that we'll put in nfts.
-
2593  struct Entry
-
2594  {
-
2595  std::string uri;
-
2596  std::uint32_t taxon;
-
2597 
-
2598  Entry(std::string uri_, std::uint32_t taxon_)
-
2599  : uri(std::move(uri_)), taxon(taxon_)
-
2600  {
-
2601  }
+
2592  // About 20% of the returned strings should be empty
+
2593  if (rand_int(4) == 0)
+
2594  return ret;
+
2595 
+
2596  std::size_t const strLen = rand_int(256);
+
2597  ret.reserve(strLen);
+
2598  for (std::size_t i = 0; i < strLen; ++i)
+
2599  ret.push_back(rand_byte());
+
2600 
+
2601  return ret;
2602  };
2603 
-
2604  std::vector<Entry> entries;
-
2605  entries.reserve(100);
-
2606  for (std::size_t i = 0; i < 100; ++i)
-
2607  entries.emplace_back(randURI(), rand_int<std::uint32_t>());
-
2608 
-
2609  // alice creates nfts using entries.
-
2610  for (Entry const& entry : entries)
-
2611  {
-
2612  if (entry.uri.empty())
-
2613  {
-
2614  env(token::mint(alice, entry.taxon));
-
2615  }
-
2616  else
-
2617  {
-
2618  env(token::mint(alice, entry.taxon), token::uri(entry.uri));
-
2619  }
-
2620  env.close();
-
2621  }
-
2622 
-
2623  // Recover alice's nfts from the ledger.
-
2624  Json::Value aliceNFTs = [&env, &alice]() {
-
2625  Json::Value params;
-
2626  params[jss::account] = alice.human();
-
2627  params[jss::type] = "state";
-
2628  return env.rpc("json", "account_nfts", to_string(params));
-
2629  }();
-
2630 
-
2631  // Verify that the returned NFTs match what we sent.
-
2632  Json::Value& nfts = aliceNFTs[jss::result][jss::account_nfts];
-
2633  if (!BEAST_EXPECT(nfts.size() == entries.size()))
-
2634  return;
-
2635 
-
2636  // Sort the returned NFTs by nft_serial so the are in the same order
-
2637  // as entries.
-
2638  std::vector<Json::Value> sortedNFTs;
-
2639  sortedNFTs.reserve(nfts.size());
-
2640  for (std::size_t i = 0; i < nfts.size(); ++i)
-
2641  sortedNFTs.push_back(nfts[i]);
-
2642  std::sort(
-
2643  sortedNFTs.begin(),
-
2644  sortedNFTs.end(),
-
2645  [](Json::Value const& lhs, Json::Value const& rhs) {
-
2646  return lhs[jss::nft_serial] < rhs[jss::nft_serial];
-
2647  });
-
2648 
-
2649  for (std::size_t i = 0; i < entries.size(); ++i)
-
2650  {
-
2651  Entry const& entry = entries[i];
-
2652  Json::Value const& ret = sortedNFTs[i];
-
2653  BEAST_EXPECT(entry.taxon == ret[sfNFTokenTaxon.jsonName]);
-
2654  if (entry.uri.empty())
-
2655  {
-
2656  BEAST_EXPECT(!ret.isMember(sfURI.jsonName));
-
2657  }
-
2658  else
-
2659  {
-
2660  BEAST_EXPECT(strHex(entry.uri) == ret[sfURI.jsonName]);
-
2661  }
-
2662  }
-
2663  }
-
2664 
-
2665  void
-
2666  testCreateOfferDestination(FeatureBitset features)
-
2667  {
-
2668  // Explore the CreateOffer Destination field.
-
2669  testcase("Create offer destination");
-
2670 
-
2671  using namespace test::jtx;
-
2672 
-
2673  Env env{*this, features};
-
2674 
-
2675  Account const issuer{"issuer"};
-
2676  Account const minter{"minter"};
-
2677  Account const buyer{"buyer"};
-
2678  Account const broker{"broker"};
-
2679 
-
2680  env.fund(XRP(1000), issuer, minter, buyer, broker);
-
2681 
-
2682  // We want to explore how issuers vs minters fits into the permission
-
2683  // scheme. So issuer issues and minter mints.
-
2684  env(token::setMinter(issuer, minter));
-
2685  env.close();
+
2604  // Make a list of URIs that we'll put in nfts.
+
2605  struct Entry
+
2606  {
+
2607  std::string uri;
+
2608  std::uint32_t taxon;
+
2609 
+
2610  Entry(std::string uri_, std::uint32_t taxon_)
+
2611  : uri(std::move(uri_)), taxon(taxon_)
+
2612  {
+
2613  }
+
2614  };
+
2615 
+
2616  std::vector<Entry> entries;
+
2617  entries.reserve(100);
+
2618  for (std::size_t i = 0; i < 100; ++i)
+
2619  entries.emplace_back(randURI(), rand_int<std::uint32_t>());
+
2620 
+
2621  // alice creates nfts using entries.
+
2622  for (Entry const& entry : entries)
+
2623  {
+
2624  if (entry.uri.empty())
+
2625  {
+
2626  env(token::mint(alice, entry.taxon));
+
2627  }
+
2628  else
+
2629  {
+
2630  env(token::mint(alice, entry.taxon), token::uri(entry.uri));
+
2631  }
+
2632  env.close();
+
2633  }
+
2634 
+
2635  // Recover alice's nfts from the ledger.
+
2636  Json::Value aliceNFTs = [&env, &alice]() {
+
2637  Json::Value params;
+
2638  params[jss::account] = alice.human();
+
2639  params[jss::type] = "state";
+
2640  return env.rpc("json", "account_nfts", to_string(params));
+
2641  }();
+
2642 
+
2643  // Verify that the returned NFTs match what we sent.
+
2644  Json::Value& nfts = aliceNFTs[jss::result][jss::account_nfts];
+
2645  if (!BEAST_EXPECT(nfts.size() == entries.size()))
+
2646  return;
+
2647 
+
2648  // Sort the returned NFTs by nft_serial so the are in the same order
+
2649  // as entries.
+
2650  std::vector<Json::Value> sortedNFTs;
+
2651  sortedNFTs.reserve(nfts.size());
+
2652  for (std::size_t i = 0; i < nfts.size(); ++i)
+
2653  sortedNFTs.push_back(nfts[i]);
+
2654  std::sort(
+
2655  sortedNFTs.begin(),
+
2656  sortedNFTs.end(),
+
2657  [](Json::Value const& lhs, Json::Value const& rhs) {
+
2658  return lhs[jss::nft_serial] < rhs[jss::nft_serial];
+
2659  });
+
2660 
+
2661  for (std::size_t i = 0; i < entries.size(); ++i)
+
2662  {
+
2663  Entry const& entry = entries[i];
+
2664  Json::Value const& ret = sortedNFTs[i];
+
2665  BEAST_EXPECT(entry.taxon == ret[sfNFTokenTaxon.jsonName]);
+
2666  if (entry.uri.empty())
+
2667  {
+
2668  BEAST_EXPECT(!ret.isMember(sfURI.jsonName));
+
2669  }
+
2670  else
+
2671  {
+
2672  BEAST_EXPECT(strHex(entry.uri) == ret[sfURI.jsonName]);
+
2673  }
+
2674  }
+
2675  }
+
2676 
+
2677  void
+
2678  testCreateOfferDestination(FeatureBitset features)
+
2679  {
+
2680  // Explore the CreateOffer Destination field.
+
2681  testcase("Create offer destination");
+
2682 
+
2683  using namespace test::jtx;
+
2684 
+
2685  Env env{*this, features};
2686 
-
2687  uint256 const nftokenID =
-
2688  token::getNextID(env, issuer, 0, tfTransferable);
-
2689  env(token::mint(minter, 0),
-
2690  token::issuer(issuer),
-
2691  txflags(tfTransferable));
-
2692  env.close();
+
2687  Account const issuer{"issuer"};
+
2688  Account const minter{"minter"};
+
2689  Account const buyer{"buyer"};
+
2690  Account const broker{"broker"};
+
2691 
+
2692  env.fund(XRP(1000), issuer, minter, buyer, broker);
2693 
-
2694  // Test how adding a Destination field to an offer affects permissions
-
2695  // for canceling offers.
-
2696  {
-
2697  uint256 const offerMinterToIssuer =
-
2698  keylet::nftoffer(minter, env.seq(minter)).key;
-
2699  env(token::createOffer(minter, nftokenID, drops(1)),
-
2700  token::destination(issuer),
-
2701  txflags(tfSellNFToken));
-
2702 
-
2703  uint256 const offerMinterToBuyer =
-
2704  keylet::nftoffer(minter, env.seq(minter)).key;
-
2705  env(token::createOffer(minter, nftokenID, drops(1)),
-
2706  token::destination(buyer),
-
2707  txflags(tfSellNFToken));
-
2708 
-
2709  uint256 const offerIssuerToMinter =
-
2710  keylet::nftoffer(issuer, env.seq(issuer)).key;
-
2711  env(token::createOffer(issuer, nftokenID, drops(1)),
-
2712  token::owner(minter),
-
2713  token::destination(minter));
+
2694  // We want to explore how issuers vs minters fits into the permission
+
2695  // scheme. So issuer issues and minter mints.
+
2696  env(token::setMinter(issuer, minter));
+
2697  env.close();
+
2698 
+
2699  uint256 const nftokenID =
+
2700  token::getNextID(env, issuer, 0, tfTransferable);
+
2701  env(token::mint(minter, 0),
+
2702  token::issuer(issuer),
+
2703  txflags(tfTransferable));
+
2704  env.close();
+
2705 
+
2706  // Test how adding a Destination field to an offer affects permissions
+
2707  // for canceling offers.
+
2708  {
+
2709  uint256 const offerMinterToIssuer =
+
2710  keylet::nftoffer(minter, env.seq(minter)).key;
+
2711  env(token::createOffer(minter, nftokenID, drops(1)),
+
2712  token::destination(issuer),
+
2713  txflags(tfSellNFToken));
2714 
-
2715  uint256 const offerIssuerToBuyer =
-
2716  keylet::nftoffer(issuer, env.seq(issuer)).key;
-
2717  env(token::createOffer(issuer, nftokenID, drops(1)),
-
2718  token::owner(minter),
-
2719  token::destination(buyer));
+
2715  uint256 const offerMinterToBuyer =
+
2716  keylet::nftoffer(minter, env.seq(minter)).key;
+
2717  env(token::createOffer(minter, nftokenID, drops(1)),
+
2718  token::destination(buyer),
+
2719  txflags(tfSellNFToken));
2720 
-
2721  env.close();
-
2722  BEAST_EXPECT(ownerCount(env, issuer) == 2);
-
2723  BEAST_EXPECT(ownerCount(env, minter) == 3);
-
2724  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
2725 
-
2726  // Test who gets to cancel the offers. Anyone outside of the
-
2727  // offer-owner/destination pair should not be able to cancel the
-
2728  // offers.
-
2729  //
-
2730  // Note that issuer does not have any special permissions regarding
-
2731  // offer cancellation. issuer cannot cancel an offer for an
-
2732  // NFToken they issued.
-
2733  env(token::cancelOffer(issuer, {offerMinterToBuyer}),
-
2734  ter(tecNO_PERMISSION));
-
2735  env(token::cancelOffer(buyer, {offerMinterToIssuer}),
-
2736  ter(tecNO_PERMISSION));
-
2737  env(token::cancelOffer(buyer, {offerIssuerToMinter}),
-
2738  ter(tecNO_PERMISSION));
-
2739  env(token::cancelOffer(minter, {offerIssuerToBuyer}),
-
2740  ter(tecNO_PERMISSION));
-
2741  env.close();
-
2742  BEAST_EXPECT(ownerCount(env, issuer) == 2);
-
2743  BEAST_EXPECT(ownerCount(env, minter) == 3);
-
2744  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
2745 
-
2746  // Both the offer creator and and destination should be able to
-
2747  // cancel the offers.
-
2748  env(token::cancelOffer(buyer, {offerMinterToBuyer}));
-
2749  env(token::cancelOffer(minter, {offerMinterToIssuer}));
-
2750  env(token::cancelOffer(buyer, {offerIssuerToBuyer}));
-
2751  env(token::cancelOffer(issuer, {offerIssuerToMinter}));
-
2752  env.close();
-
2753  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
2754  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
2755  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
2756  }
+
2721  uint256 const offerIssuerToMinter =
+
2722  keylet::nftoffer(issuer, env.seq(issuer)).key;
+
2723  env(token::createOffer(issuer, nftokenID, drops(1)),
+
2724  token::owner(minter),
+
2725  token::destination(minter));
+
2726 
+
2727  uint256 const offerIssuerToBuyer =
+
2728  keylet::nftoffer(issuer, env.seq(issuer)).key;
+
2729  env(token::createOffer(issuer, nftokenID, drops(1)),
+
2730  token::owner(minter),
+
2731  token::destination(buyer));
+
2732 
+
2733  env.close();
+
2734  BEAST_EXPECT(ownerCount(env, issuer) == 2);
+
2735  BEAST_EXPECT(ownerCount(env, minter) == 3);
+
2736  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
2737 
+
2738  // Test who gets to cancel the offers. Anyone outside of the
+
2739  // offer-owner/destination pair should not be able to cancel the
+
2740  // offers.
+
2741  //
+
2742  // Note that issuer does not have any special permissions regarding
+
2743  // offer cancellation. issuer cannot cancel an offer for an
+
2744  // NFToken they issued.
+
2745  env(token::cancelOffer(issuer, {offerMinterToBuyer}),
+
2746  ter(tecNO_PERMISSION));
+
2747  env(token::cancelOffer(buyer, {offerMinterToIssuer}),
+
2748  ter(tecNO_PERMISSION));
+
2749  env(token::cancelOffer(buyer, {offerIssuerToMinter}),
+
2750  ter(tecNO_PERMISSION));
+
2751  env(token::cancelOffer(minter, {offerIssuerToBuyer}),
+
2752  ter(tecNO_PERMISSION));
+
2753  env.close();
+
2754  BEAST_EXPECT(ownerCount(env, issuer) == 2);
+
2755  BEAST_EXPECT(ownerCount(env, minter) == 3);
+
2756  BEAST_EXPECT(ownerCount(env, buyer) == 0);
2757 
-
2758  // Test how adding a Destination field to a sell offer affects
-
2759  // accepting that offer.
-
2760  {
-
2761  uint256 const offerMinterSellsToBuyer =
-
2762  keylet::nftoffer(minter, env.seq(minter)).key;
-
2763  env(token::createOffer(minter, nftokenID, drops(1)),
-
2764  token::destination(buyer),
-
2765  txflags(tfSellNFToken));
-
2766  env.close();
-
2767  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
2768  BEAST_EXPECT(ownerCount(env, minter) == 2);
-
2769  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
2770 
-
2771  // issuer cannot accept a sell offer where they are not the
-
2772  // destination.
-
2773  env(token::acceptSellOffer(issuer, offerMinterSellsToBuyer),
-
2774  ter(tecNO_PERMISSION));
-
2775  env.close();
-
2776  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
2777  BEAST_EXPECT(ownerCount(env, minter) == 2);
-
2778  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
2779 
-
2780  // However buyer can accept the sell offer.
-
2781  env(token::acceptSellOffer(buyer, offerMinterSellsToBuyer));
-
2782  env.close();
-
2783  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
2784  BEAST_EXPECT(ownerCount(env, minter) == 0);
-
2785  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
2786  }
-
2787 
-
2788  // Test how adding a Destination field to a buy offer affects
-
2789  // accepting that offer.
-
2790  {
-
2791  uint256 const offerMinterBuysFromBuyer =
-
2792  keylet::nftoffer(minter, env.seq(minter)).key;
-
2793  env(token::createOffer(minter, nftokenID, drops(1)),
-
2794  token::owner(buyer),
-
2795  token::destination(buyer));
-
2796  env.close();
-
2797  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
2798  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
2799  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
2800 
-
2801  // issuer cannot accept a buy offer where they are the
-
2802  // destination.
-
2803  env(token::acceptBuyOffer(issuer, offerMinterBuysFromBuyer),
-
2804  ter(tecNO_PERMISSION));
-
2805  env.close();
-
2806  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
2807  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
2808  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
2809 
-
2810  // Buyer accepts minter's offer.
-
2811  env(token::acceptBuyOffer(buyer, offerMinterBuysFromBuyer));
-
2812  env.close();
-
2813  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
2814  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
2815  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
2816 
-
2817  // If a destination other than the NFToken owner is set, that
-
2818  // destination must act as a broker. The NFToken owner may not
-
2819  // simply accept the offer.
-
2820  uint256 const offerBuyerBuysFromMinter =
-
2821  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
2822  env(token::createOffer(buyer, nftokenID, drops(1)),
-
2823  token::owner(minter),
-
2824  token::destination(broker));
-
2825  env.close();
-
2826  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
2827  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
2828  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
2829 
-
2830  env(token::acceptBuyOffer(minter, offerBuyerBuysFromMinter),
-
2831  ter(tecNO_PERMISSION));
-
2832  env.close();
-
2833 
-
2834  // Clean up the unused offer.
-
2835  env(token::cancelOffer(buyer, {offerBuyerBuysFromMinter}));
-
2836  env.close();
-
2837  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
2838  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
2839  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
2840  }
+
2758  // Both the offer creator and and destination should be able to
+
2759  // cancel the offers.
+
2760  env(token::cancelOffer(buyer, {offerMinterToBuyer}));
+
2761  env(token::cancelOffer(minter, {offerMinterToIssuer}));
+
2762  env(token::cancelOffer(buyer, {offerIssuerToBuyer}));
+
2763  env(token::cancelOffer(issuer, {offerIssuerToMinter}));
+
2764  env.close();
+
2765  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
2766  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
2767  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
2768  }
+
2769 
+
2770  // Test how adding a Destination field to a sell offer affects
+
2771  // accepting that offer.
+
2772  {
+
2773  uint256 const offerMinterSellsToBuyer =
+
2774  keylet::nftoffer(minter, env.seq(minter)).key;
+
2775  env(token::createOffer(minter, nftokenID, drops(1)),
+
2776  token::destination(buyer),
+
2777  txflags(tfSellNFToken));
+
2778  env.close();
+
2779  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
2780  BEAST_EXPECT(ownerCount(env, minter) == 2);
+
2781  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
2782 
+
2783  // issuer cannot accept a sell offer where they are not the
+
2784  // destination.
+
2785  env(token::acceptSellOffer(issuer, offerMinterSellsToBuyer),
+
2786  ter(tecNO_PERMISSION));
+
2787  env.close();
+
2788  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
2789  BEAST_EXPECT(ownerCount(env, minter) == 2);
+
2790  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
2791 
+
2792  // However buyer can accept the sell offer.
+
2793  env(token::acceptSellOffer(buyer, offerMinterSellsToBuyer));
+
2794  env.close();
+
2795  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
2796  BEAST_EXPECT(ownerCount(env, minter) == 0);
+
2797  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
2798  }
+
2799 
+
2800  // Test how adding a Destination field to a buy offer affects
+
2801  // accepting that offer.
+
2802  {
+
2803  uint256 const offerMinterBuysFromBuyer =
+
2804  keylet::nftoffer(minter, env.seq(minter)).key;
+
2805  env(token::createOffer(minter, nftokenID, drops(1)),
+
2806  token::owner(buyer),
+
2807  token::destination(buyer));
+
2808  env.close();
+
2809  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
2810  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
2811  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
2812 
+
2813  // issuer cannot accept a buy offer where they are the
+
2814  // destination.
+
2815  env(token::acceptBuyOffer(issuer, offerMinterBuysFromBuyer),
+
2816  ter(tecNO_PERMISSION));
+
2817  env.close();
+
2818  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
2819  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
2820  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
2821 
+
2822  // Buyer accepts minter's offer.
+
2823  env(token::acceptBuyOffer(buyer, offerMinterBuysFromBuyer));
+
2824  env.close();
+
2825  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
2826  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
2827  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
2828 
+
2829  // If a destination other than the NFToken owner is set, that
+
2830  // destination must act as a broker. The NFToken owner may not
+
2831  // simply accept the offer.
+
2832  uint256 const offerBuyerBuysFromMinter =
+
2833  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
2834  env(token::createOffer(buyer, nftokenID, drops(1)),
+
2835  token::owner(minter),
+
2836  token::destination(broker));
+
2837  env.close();
+
2838  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
2839  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
2840  BEAST_EXPECT(ownerCount(env, buyer) == 1);
2841 
-
2842  // Show that a sell offer's Destination can broker that sell offer
-
2843  // to another account.
-
2844  {
-
2845  uint256 const offerMinterToBroker =
-
2846  keylet::nftoffer(minter, env.seq(minter)).key;
-
2847  env(token::createOffer(minter, nftokenID, drops(1)),
-
2848  token::destination(broker),
-
2849  txflags(tfSellNFToken));
-
2850 
-
2851  uint256 const offerBuyerToMinter =
-
2852  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
2853  env(token::createOffer(buyer, nftokenID, drops(1)),
-
2854  token::owner(minter));
-
2855 
-
2856  env.close();
-
2857  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
2858  BEAST_EXPECT(ownerCount(env, minter) == 2);
-
2859  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
2860 
-
2861  // issuer cannot broker the offers, because they are not the
-
2862  // Destination.
-
2863  env(token::brokerOffers(
-
2864  issuer, offerBuyerToMinter, offerMinterToBroker),
-
2865  ter(tecNFTOKEN_BUY_SELL_MISMATCH));
-
2866  env.close();
-
2867  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
2868  BEAST_EXPECT(ownerCount(env, minter) == 2);
-
2869  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
2870 
-
2871  // Since broker is the sell offer's destination, they can broker
-
2872  // the two offers.
-
2873  env(token::brokerOffers(
-
2874  broker, offerBuyerToMinter, offerMinterToBroker));
-
2875  env.close();
-
2876  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
2877  BEAST_EXPECT(ownerCount(env, minter) == 0);
-
2878  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
2879  }
-
2880 
-
2881  // Show that brokered mode cannot complete a transfer where the
-
2882  // Destination doesn't match, but can complete if the Destination
-
2883  // does match.
-
2884  {
-
2885  uint256 const offerBuyerToMinter =
-
2886  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
2887  env(token::createOffer(buyer, nftokenID, drops(1)),
-
2888  token::destination(minter),
-
2889  txflags(tfSellNFToken));
-
2890 
-
2891  uint256 const offerMinterToBuyer =
-
2892  keylet::nftoffer(minter, env.seq(minter)).key;
-
2893  env(token::createOffer(minter, nftokenID, drops(1)),
-
2894  token::owner(buyer));
-
2895 
-
2896  uint256 const offerIssuerToBuyer =
-
2897  keylet::nftoffer(issuer, env.seq(issuer)).key;
-
2898  env(token::createOffer(issuer, nftokenID, drops(1)),
-
2899  token::owner(buyer));
-
2900 
-
2901  env.close();
-
2902  BEAST_EXPECT(ownerCount(env, issuer) == 1);
-
2903  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
2904  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
2905 
-
2906  // Cannot broker offers when the sell destination is not the buyer.
-
2907  env(token::brokerOffers(
-
2908  broker, offerIssuerToBuyer, offerBuyerToMinter),
-
2909  ter(tecNFTOKEN_BUY_SELL_MISMATCH));
-
2910  env.close();
-
2911  BEAST_EXPECT(ownerCount(env, issuer) == 1);
-
2912  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
2913  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
2914 
-
2915  // Broker is successful when destination is buyer.
-
2916  env(token::brokerOffers(
-
2917  broker, offerMinterToBuyer, offerBuyerToMinter));
-
2918  env.close();
-
2919  BEAST_EXPECT(ownerCount(env, issuer) == 1);
-
2920  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
2921  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
2922 
-
2923  // Clean out the unconsumed offer.
-
2924  env(token::cancelOffer(issuer, {offerIssuerToBuyer}));
-
2925  env.close();
-
2926  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
2927  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
2928  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
2929  }
-
2930 
-
2931  // Show that if a buy and a sell offer both have the same destination,
-
2932  // then that destination can broker the offers.
-
2933  {
-
2934  uint256 const offerMinterToBroker =
-
2935  keylet::nftoffer(minter, env.seq(minter)).key;
-
2936  env(token::createOffer(minter, nftokenID, drops(1)),
-
2937  token::destination(broker),
-
2938  txflags(tfSellNFToken));
-
2939 
-
2940  uint256 const offerBuyerToBroker =
-
2941  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
2942  env(token::createOffer(buyer, nftokenID, drops(1)),
-
2943  token::owner(minter),
-
2944  token::destination(broker));
-
2945 
-
2946  // Cannot broker offers when the sell destination is not the buyer
-
2947  // or the broker.
-
2948  env(token::brokerOffers(
-
2949  issuer, offerBuyerToBroker, offerMinterToBroker),
-
2950  ter(tecNFTOKEN_BUY_SELL_MISMATCH));
-
2951  env.close();
-
2952  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
2953  BEAST_EXPECT(ownerCount(env, minter) == 2);
-
2954  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
2955 
-
2956  // Broker is successful if they are the destination of both offers.
-
2957  env(token::brokerOffers(
-
2958  broker, offerBuyerToBroker, offerMinterToBroker));
-
2959  env.close();
-
2960  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
2961  BEAST_EXPECT(ownerCount(env, minter) == 0);
-
2962  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
2963  }
-
2964  }
-
2965 
-
2966  void
-
2967  testCreateOfferExpiration(FeatureBitset features)
-
2968  {
-
2969  // Explore the CreateOffer Expiration field.
-
2970  testcase("Create offer expiration");
-
2971 
-
2972  using namespace test::jtx;
-
2973 
-
2974  Env env{*this, features};
-
2975 
-
2976  Account const issuer{"issuer"};
-
2977  Account const minter{"minter"};
-
2978  Account const buyer{"buyer"};
-
2979 
-
2980  env.fund(XRP(1000), issuer, minter, buyer);
-
2981 
-
2982  // We want to explore how issuers vs minters fits into the permission
-
2983  // scheme. So issuer issues and minter mints.
-
2984  env(token::setMinter(issuer, minter));
-
2985  env.close();
-
2986 
-
2987  uint256 const nftokenID0 =
-
2988  token::getNextID(env, issuer, 0, tfTransferable);
-
2989  env(token::mint(minter, 0),
-
2990  token::issuer(issuer),
-
2991  txflags(tfTransferable));
-
2992  env.close();
+
2842  env(token::acceptBuyOffer(minter, offerBuyerBuysFromMinter),
+
2843  ter(tecNO_PERMISSION));
+
2844  env.close();
+
2845 
+
2846  // Clean up the unused offer.
+
2847  env(token::cancelOffer(buyer, {offerBuyerBuysFromMinter}));
+
2848  env.close();
+
2849  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
2850  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
2851  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
2852  }
+
2853 
+
2854  // Show that a sell offer's Destination can broker that sell offer
+
2855  // to another account.
+
2856  {
+
2857  uint256 const offerMinterToBroker =
+
2858  keylet::nftoffer(minter, env.seq(minter)).key;
+
2859  env(token::createOffer(minter, nftokenID, drops(1)),
+
2860  token::destination(broker),
+
2861  txflags(tfSellNFToken));
+
2862 
+
2863  uint256 const offerBuyerToMinter =
+
2864  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
2865  env(token::createOffer(buyer, nftokenID, drops(1)),
+
2866  token::owner(minter));
+
2867 
+
2868  env.close();
+
2869  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
2870  BEAST_EXPECT(ownerCount(env, minter) == 2);
+
2871  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
2872 
+
2873  // issuer cannot broker the offers, because they are not the
+
2874  // Destination.
+
2875  env(token::brokerOffers(
+
2876  issuer, offerBuyerToMinter, offerMinterToBroker),
+
2877  ter(tecNFTOKEN_BUY_SELL_MISMATCH));
+
2878  env.close();
+
2879  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
2880  BEAST_EXPECT(ownerCount(env, minter) == 2);
+
2881  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
2882 
+
2883  // Since broker is the sell offer's destination, they can broker
+
2884  // the two offers.
+
2885  env(token::brokerOffers(
+
2886  broker, offerBuyerToMinter, offerMinterToBroker));
+
2887  env.close();
+
2888  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
2889  BEAST_EXPECT(ownerCount(env, minter) == 0);
+
2890  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
2891  }
+
2892 
+
2893  // Show that brokered mode cannot complete a transfer where the
+
2894  // Destination doesn't match, but can complete if the Destination
+
2895  // does match.
+
2896  {
+
2897  uint256 const offerBuyerToMinter =
+
2898  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
2899  env(token::createOffer(buyer, nftokenID, drops(1)),
+
2900  token::destination(minter),
+
2901  txflags(tfSellNFToken));
+
2902 
+
2903  uint256 const offerMinterToBuyer =
+
2904  keylet::nftoffer(minter, env.seq(minter)).key;
+
2905  env(token::createOffer(minter, nftokenID, drops(1)),
+
2906  token::owner(buyer));
+
2907 
+
2908  uint256 const offerIssuerToBuyer =
+
2909  keylet::nftoffer(issuer, env.seq(issuer)).key;
+
2910  env(token::createOffer(issuer, nftokenID, drops(1)),
+
2911  token::owner(buyer));
+
2912 
+
2913  env.close();
+
2914  BEAST_EXPECT(ownerCount(env, issuer) == 1);
+
2915  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
2916  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
2917 
+
2918  // Cannot broker offers when the sell destination is not the buyer.
+
2919  env(token::brokerOffers(
+
2920  broker, offerIssuerToBuyer, offerBuyerToMinter),
+
2921  ter(tecNFTOKEN_BUY_SELL_MISMATCH));
+
2922  env.close();
+
2923  BEAST_EXPECT(ownerCount(env, issuer) == 1);
+
2924  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
2925  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
2926 
+
2927  // Broker is successful when destination is buyer.
+
2928  env(token::brokerOffers(
+
2929  broker, offerMinterToBuyer, offerBuyerToMinter));
+
2930  env.close();
+
2931  BEAST_EXPECT(ownerCount(env, issuer) == 1);
+
2932  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
2933  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
2934 
+
2935  // Clean out the unconsumed offer.
+
2936  env(token::cancelOffer(issuer, {offerIssuerToBuyer}));
+
2937  env.close();
+
2938  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
2939  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
2940  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
2941  }
+
2942 
+
2943  // Show that if a buy and a sell offer both have the same destination,
+
2944  // then that destination can broker the offers.
+
2945  {
+
2946  uint256 const offerMinterToBroker =
+
2947  keylet::nftoffer(minter, env.seq(minter)).key;
+
2948  env(token::createOffer(minter, nftokenID, drops(1)),
+
2949  token::destination(broker),
+
2950  txflags(tfSellNFToken));
+
2951 
+
2952  uint256 const offerBuyerToBroker =
+
2953  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
2954  env(token::createOffer(buyer, nftokenID, drops(1)),
+
2955  token::owner(minter),
+
2956  token::destination(broker));
+
2957 
+
2958  // Cannot broker offers when the sell destination is not the buyer
+
2959  // or the broker.
+
2960  env(token::brokerOffers(
+
2961  issuer, offerBuyerToBroker, offerMinterToBroker),
+
2962  ter(tecNFTOKEN_BUY_SELL_MISMATCH));
+
2963  env.close();
+
2964  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
2965  BEAST_EXPECT(ownerCount(env, minter) == 2);
+
2966  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
2967 
+
2968  // Broker is successful if they are the destination of both offers.
+
2969  env(token::brokerOffers(
+
2970  broker, offerBuyerToBroker, offerMinterToBroker));
+
2971  env.close();
+
2972  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
2973  BEAST_EXPECT(ownerCount(env, minter) == 0);
+
2974  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
2975  }
+
2976  }
+
2977 
+
2978  void
+
2979  testCreateOfferExpiration(FeatureBitset features)
+
2980  {
+
2981  // Explore the CreateOffer Expiration field.
+
2982  testcase("Create offer expiration");
+
2983 
+
2984  using namespace test::jtx;
+
2985 
+
2986  Env env{*this, features};
+
2987 
+
2988  Account const issuer{"issuer"};
+
2989  Account const minter{"minter"};
+
2990  Account const buyer{"buyer"};
+
2991 
+
2992  env.fund(XRP(1000), issuer, minter, buyer);
2993 
-
2994  uint256 const nftokenID1 =
-
2995  token::getNextID(env, issuer, 0, tfTransferable);
-
2996  env(token::mint(minter, 0),
-
2997  token::issuer(issuer),
-
2998  txflags(tfTransferable));
-
2999  env.close();
-
3000 
-
3001  // Test how adding an Expiration field to an offer affects permissions
-
3002  // for cancelling offers.
-
3003  {
-
3004  std::uint32_t const expiration = lastClose(env) + 25;
+
2994  // We want to explore how issuers vs minters fits into the permission
+
2995  // scheme. So issuer issues and minter mints.
+
2996  env(token::setMinter(issuer, minter));
+
2997  env.close();
+
2998 
+
2999  uint256 const nftokenID0 =
+
3000  token::getNextID(env, issuer, 0, tfTransferable);
+
3001  env(token::mint(minter, 0),
+
3002  token::issuer(issuer),
+
3003  txflags(tfTransferable));
+
3004  env.close();
3005 
-
3006  uint256 const offerMinterToIssuer =
-
3007  keylet::nftoffer(minter, env.seq(minter)).key;
-
3008  env(token::createOffer(minter, nftokenID0, drops(1)),
-
3009  token::destination(issuer),
-
3010  token::expiration(expiration),
-
3011  txflags(tfSellNFToken));
+
3006  uint256 const nftokenID1 =
+
3007  token::getNextID(env, issuer, 0, tfTransferable);
+
3008  env(token::mint(minter, 0),
+
3009  token::issuer(issuer),
+
3010  txflags(tfTransferable));
+
3011  env.close();
3012 
-
3013  uint256 const offerMinterToAnyone =
-
3014  keylet::nftoffer(minter, env.seq(minter)).key;
-
3015  env(token::createOffer(minter, nftokenID0, drops(1)),
-
3016  token::expiration(expiration),
-
3017  txflags(tfSellNFToken));
-
3018 
-
3019  uint256 const offerIssuerToMinter =
-
3020  keylet::nftoffer(issuer, env.seq(issuer)).key;
-
3021  env(token::createOffer(issuer, nftokenID0, drops(1)),
-
3022  token::owner(minter),
-
3023  token::expiration(expiration));
+
3013  // Test how adding an Expiration field to an offer affects permissions
+
3014  // for cancelling offers.
+
3015  {
+
3016  std::uint32_t const expiration = lastClose(env) + 25;
+
3017 
+
3018  uint256 const offerMinterToIssuer =
+
3019  keylet::nftoffer(minter, env.seq(minter)).key;
+
3020  env(token::createOffer(minter, nftokenID0, drops(1)),
+
3021  token::destination(issuer),
+
3022  token::expiration(expiration),
+
3023  txflags(tfSellNFToken));
3024 
-
3025  uint256 const offerBuyerToMinter =
-
3026  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
3027  env(token::createOffer(buyer, nftokenID0, drops(1)),
-
3028  token::owner(minter),
-
3029  token::expiration(expiration));
-
3030  env.close();
-
3031  BEAST_EXPECT(ownerCount(env, issuer) == 1);
-
3032  BEAST_EXPECT(ownerCount(env, minter) == 3);
-
3033  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
3034 
-
3035  // Test who gets to cancel the offers. Anyone outside of the
-
3036  // offer-owner/destination pair should not be able to cancel
-
3037  // unexpired offers.
-
3038  //
-
3039  // Note that these are tec responses, so these transactions will
-
3040  // not be retried by the ledger.
-
3041  env(token::cancelOffer(issuer, {offerMinterToAnyone}),
-
3042  ter(tecNO_PERMISSION));
-
3043  env(token::cancelOffer(buyer, {offerIssuerToMinter}),
-
3044  ter(tecNO_PERMISSION));
-
3045  env.close();
-
3046  BEAST_EXPECT(lastClose(env) < expiration);
-
3047  BEAST_EXPECT(ownerCount(env, issuer) == 1);
-
3048  BEAST_EXPECT(ownerCount(env, minter) == 3);
-
3049  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
3050 
-
3051  // The offer creator can cancel their own unexpired offer.
-
3052  env(token::cancelOffer(minter, {offerMinterToAnyone}));
-
3053 
-
3054  // The destination of a sell offer can cancel the NFT owner's
-
3055  // unexpired offer.
-
3056  env(token::cancelOffer(issuer, {offerMinterToIssuer}));
-
3057 
-
3058  // Close enough ledgers to get past the expiration.
-
3059  while (lastClose(env) < expiration)
-
3060  env.close();
-
3061 
-
3062  BEAST_EXPECT(ownerCount(env, issuer) == 1);
-
3063  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
3064  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
3025  uint256 const offerMinterToAnyone =
+
3026  keylet::nftoffer(minter, env.seq(minter)).key;
+
3027  env(token::createOffer(minter, nftokenID0, drops(1)),
+
3028  token::expiration(expiration),
+
3029  txflags(tfSellNFToken));
+
3030 
+
3031  uint256 const offerIssuerToMinter =
+
3032  keylet::nftoffer(issuer, env.seq(issuer)).key;
+
3033  env(token::createOffer(issuer, nftokenID0, drops(1)),
+
3034  token::owner(minter),
+
3035  token::expiration(expiration));
+
3036 
+
3037  uint256 const offerBuyerToMinter =
+
3038  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
3039  env(token::createOffer(buyer, nftokenID0, drops(1)),
+
3040  token::owner(minter),
+
3041  token::expiration(expiration));
+
3042  env.close();
+
3043  BEAST_EXPECT(ownerCount(env, issuer) == 1);
+
3044  BEAST_EXPECT(ownerCount(env, minter) == 3);
+
3045  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
3046 
+
3047  // Test who gets to cancel the offers. Anyone outside of the
+
3048  // offer-owner/destination pair should not be able to cancel
+
3049  // unexpired offers.
+
3050  //
+
3051  // Note that these are tec responses, so these transactions will
+
3052  // not be retried by the ledger.
+
3053  env(token::cancelOffer(issuer, {offerMinterToAnyone}),
+
3054  ter(tecNO_PERMISSION));
+
3055  env(token::cancelOffer(buyer, {offerIssuerToMinter}),
+
3056  ter(tecNO_PERMISSION));
+
3057  env.close();
+
3058  BEAST_EXPECT(lastClose(env) < expiration);
+
3059  BEAST_EXPECT(ownerCount(env, issuer) == 1);
+
3060  BEAST_EXPECT(ownerCount(env, minter) == 3);
+
3061  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
3062 
+
3063  // The offer creator can cancel their own unexpired offer.
+
3064  env(token::cancelOffer(minter, {offerMinterToAnyone}));
3065 
-
3066  // Anyone can cancel expired offers.
-
3067  env(token::cancelOffer(issuer, {offerBuyerToMinter}));
-
3068  env(token::cancelOffer(buyer, {offerIssuerToMinter}));
-
3069  env.close();
-
3070  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3071  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
3072  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
3073  }
-
3074  // Show that:
-
3075  // 1. An unexpired sell offer with an expiration can be accepted.
-
3076  // 2. An expired sell offer cannot be accepted and remains
-
3077  // in ledger after the accept fails.
-
3078  {
-
3079  std::uint32_t const expiration = lastClose(env) + 25;
-
3080 
-
3081  uint256 const offer0 =
-
3082  keylet::nftoffer(minter, env.seq(minter)).key;
-
3083  env(token::createOffer(minter, nftokenID0, drops(1)),
-
3084  token::expiration(expiration),
-
3085  txflags(tfSellNFToken));
-
3086 
-
3087  uint256 const offer1 =
-
3088  keylet::nftoffer(minter, env.seq(minter)).key;
-
3089  env(token::createOffer(minter, nftokenID1, drops(1)),
-
3090  token::expiration(expiration),
-
3091  txflags(tfSellNFToken));
-
3092  env.close();
-
3093  BEAST_EXPECT(lastClose(env) < expiration);
-
3094  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3095  BEAST_EXPECT(ownerCount(env, minter) == 3);
-
3096  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
3097 
-
3098  // Anyone can accept an unexpired sell offer.
-
3099  env(token::acceptSellOffer(buyer, offer0));
-
3100 
-
3101  // Close enough ledgers to get past the expiration.
-
3102  while (lastClose(env) < expiration)
-
3103  env.close();
-
3104 
-
3105  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3106  BEAST_EXPECT(ownerCount(env, minter) == 2);
-
3107  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
3108 
-
3109  // No one can accept an expired sell offer.
-
3110  env(token::acceptSellOffer(buyer, offer1), ter(tecEXPIRED));
-
3111  env(token::acceptSellOffer(issuer, offer1), ter(tecEXPIRED));
-
3112  env.close();
-
3113 
-
3114  // The expired sell offer is still in the ledger.
-
3115  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3116  BEAST_EXPECT(ownerCount(env, minter) == 2);
-
3117  BEAST_EXPECT(ownerCount(env, buyer) == 1);
-
3118 
-
3119  // Anyone can cancel the expired sell offer.
-
3120  env(token::cancelOffer(issuer, {offer1}));
-
3121  env.close();
-
3122  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3123  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
3124  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
3066  // The destination of a sell offer can cancel the NFT owner's
+
3067  // unexpired offer.
+
3068  env(token::cancelOffer(issuer, {offerMinterToIssuer}));
+
3069 
+
3070  // Close enough ledgers to get past the expiration.
+
3071  while (lastClose(env) < expiration)
+
3072  env.close();
+
3073 
+
3074  BEAST_EXPECT(ownerCount(env, issuer) == 1);
+
3075  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
3076  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
3077 
+
3078  // Anyone can cancel expired offers.
+
3079  env(token::cancelOffer(issuer, {offerBuyerToMinter}));
+
3080  env(token::cancelOffer(buyer, {offerIssuerToMinter}));
+
3081  env.close();
+
3082  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3083  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
3084  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
3085  }
+
3086  // Show that:
+
3087  // 1. An unexpired sell offer with an expiration can be accepted.
+
3088  // 2. An expired sell offer cannot be accepted and remains
+
3089  // in ledger after the accept fails.
+
3090  {
+
3091  std::uint32_t const expiration = lastClose(env) + 25;
+
3092 
+
3093  uint256 const offer0 =
+
3094  keylet::nftoffer(minter, env.seq(minter)).key;
+
3095  env(token::createOffer(minter, nftokenID0, drops(1)),
+
3096  token::expiration(expiration),
+
3097  txflags(tfSellNFToken));
+
3098 
+
3099  uint256 const offer1 =
+
3100  keylet::nftoffer(minter, env.seq(minter)).key;
+
3101  env(token::createOffer(minter, nftokenID1, drops(1)),
+
3102  token::expiration(expiration),
+
3103  txflags(tfSellNFToken));
+
3104  env.close();
+
3105  BEAST_EXPECT(lastClose(env) < expiration);
+
3106  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3107  BEAST_EXPECT(ownerCount(env, minter) == 3);
+
3108  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
3109 
+
3110  // Anyone can accept an unexpired sell offer.
+
3111  env(token::acceptSellOffer(buyer, offer0));
+
3112 
+
3113  // Close enough ledgers to get past the expiration.
+
3114  while (lastClose(env) < expiration)
+
3115  env.close();
+
3116 
+
3117  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3118  BEAST_EXPECT(ownerCount(env, minter) == 2);
+
3119  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
3120 
+
3121  // No one can accept an expired sell offer.
+
3122  env(token::acceptSellOffer(buyer, offer1), ter(tecEXPIRED));
+
3123  env(token::acceptSellOffer(issuer, offer1), ter(tecEXPIRED));
+
3124  env.close();
3125 
-
3126  // Transfer nftokenID0 back to minter so we start the next test in
-
3127  // a simple place.
-
3128  uint256 const offerSellBack =
-
3129  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
3130  env(token::createOffer(buyer, nftokenID0, XRP(0)),
-
3131  txflags(tfSellNFToken),
-
3132  token::destination(minter));
+
3126  // The expired sell offer is still in the ledger.
+
3127  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3128  BEAST_EXPECT(ownerCount(env, minter) == 2);
+
3129  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
3130 
+
3131  // Anyone can cancel the expired sell offer.
+
3132  env(token::cancelOffer(issuer, {offer1}));
3133  env.close();
-
3134  env(token::acceptSellOffer(minter, offerSellBack));
-
3135  env.close();
-
3136  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3137  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
3138  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
3139  }
-
3140  // Show that:
-
3141  // 1. An unexpired buy offer with an expiration can be accepted.
-
3142  // 2. An expired buy offer cannot be accepted and remains
-
3143  // in ledger after the accept fails.
-
3144  {
-
3145  std::uint32_t const expiration = lastClose(env) + 25;
-
3146 
-
3147  uint256 const offer0 = keylet::nftoffer(buyer, env.seq(buyer)).key;
-
3148  env(token::createOffer(buyer, nftokenID0, drops(1)),
-
3149  token::owner(minter),
-
3150  token::expiration(expiration));
-
3151 
-
3152  uint256 const offer1 = keylet::nftoffer(buyer, env.seq(buyer)).key;
-
3153  env(token::createOffer(buyer, nftokenID1, drops(1)),
-
3154  token::owner(minter),
-
3155  token::expiration(expiration));
-
3156  env.close();
-
3157  BEAST_EXPECT(lastClose(env) < expiration);
-
3158  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3159  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
3160  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
3161 
-
3162  // An unexpired buy offer can be accepted.
-
3163  env(token::acceptBuyOffer(minter, offer0));
-
3164 
-
3165  // Close enough ledgers to get past the expiration.
-
3166  while (lastClose(env) < expiration)
-
3167  env.close();
-
3168 
-
3169  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3170  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
3171  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
3172 
-
3173  // An expired buy offer cannot be accepted.
-
3174  env(token::acceptBuyOffer(minter, offer1), ter(tecEXPIRED));
-
3175  env(token::acceptBuyOffer(issuer, offer1), ter(tecEXPIRED));
-
3176  env.close();
-
3177 
-
3178  // The expired buy offer is still in the ledger.
-
3179  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3180  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
3181  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
3182 
-
3183  // Anyone can cancel the expired buy offer.
-
3184  env(token::cancelOffer(issuer, {offer1}));
-
3185  env.close();
-
3186  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3187  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
3188  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
3134  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3135  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
3136  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
3137 
+
3138  // Transfer nftokenID0 back to minter so we start the next test in
+
3139  // a simple place.
+
3140  uint256 const offerSellBack =
+
3141  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
3142  env(token::createOffer(buyer, nftokenID0, XRP(0)),
+
3143  txflags(tfSellNFToken),
+
3144  token::destination(minter));
+
3145  env.close();
+
3146  env(token::acceptSellOffer(minter, offerSellBack));
+
3147  env.close();
+
3148  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3149  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
3150  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
3151  }
+
3152  // Show that:
+
3153  // 1. An unexpired buy offer with an expiration can be accepted.
+
3154  // 2. An expired buy offer cannot be accepted and remains
+
3155  // in ledger after the accept fails.
+
3156  {
+
3157  std::uint32_t const expiration = lastClose(env) + 25;
+
3158 
+
3159  uint256 const offer0 = keylet::nftoffer(buyer, env.seq(buyer)).key;
+
3160  env(token::createOffer(buyer, nftokenID0, drops(1)),
+
3161  token::owner(minter),
+
3162  token::expiration(expiration));
+
3163 
+
3164  uint256 const offer1 = keylet::nftoffer(buyer, env.seq(buyer)).key;
+
3165  env(token::createOffer(buyer, nftokenID1, drops(1)),
+
3166  token::owner(minter),
+
3167  token::expiration(expiration));
+
3168  env.close();
+
3169  BEAST_EXPECT(lastClose(env) < expiration);
+
3170  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3171  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
3172  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
3173 
+
3174  // An unexpired buy offer can be accepted.
+
3175  env(token::acceptBuyOffer(minter, offer0));
+
3176 
+
3177  // Close enough ledgers to get past the expiration.
+
3178  while (lastClose(env) < expiration)
+
3179  env.close();
+
3180 
+
3181  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3182  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
3183  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
3184 
+
3185  // An expired buy offer cannot be accepted.
+
3186  env(token::acceptBuyOffer(minter, offer1), ter(tecEXPIRED));
+
3187  env(token::acceptBuyOffer(issuer, offer1), ter(tecEXPIRED));
+
3188  env.close();
3189 
-
3190  // Transfer nftokenID0 back to minter so we start the next test in
-
3191  // a simple place.
-
3192  uint256 const offerSellBack =
-
3193  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
3194  env(token::createOffer(buyer, nftokenID0, XRP(0)),
-
3195  txflags(tfSellNFToken),
-
3196  token::destination(minter));
+
3190  // The expired buy offer is still in the ledger.
+
3191  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3192  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
3193  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
3194 
+
3195  // Anyone can cancel the expired buy offer.
+
3196  env(token::cancelOffer(issuer, {offer1}));
3197  env.close();
-
3198  env(token::acceptSellOffer(minter, offerSellBack));
-
3199  env.close();
-
3200  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3201  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
3202  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
3203  }
-
3204  // Show that in brokered mode:
-
3205  // 1. An unexpired sell offer with an expiration can be accepted.
-
3206  // 2. An expired sell offer cannot be accepted and remains
-
3207  // in ledger after the accept fails.
-
3208  {
-
3209  std::uint32_t const expiration = lastClose(env) + 25;
-
3210 
-
3211  uint256 const sellOffer0 =
-
3212  keylet::nftoffer(minter, env.seq(minter)).key;
-
3213  env(token::createOffer(minter, nftokenID0, drops(1)),
-
3214  token::expiration(expiration),
-
3215  txflags(tfSellNFToken));
-
3216 
-
3217  uint256 const sellOffer1 =
-
3218  keylet::nftoffer(minter, env.seq(minter)).key;
-
3219  env(token::createOffer(minter, nftokenID1, drops(1)),
-
3220  token::expiration(expiration),
-
3221  txflags(tfSellNFToken));
+
3198  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3199  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
3200  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
3201 
+
3202  // Transfer nftokenID0 back to minter so we start the next test in
+
3203  // a simple place.
+
3204  uint256 const offerSellBack =
+
3205  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
3206  env(token::createOffer(buyer, nftokenID0, XRP(0)),
+
3207  txflags(tfSellNFToken),
+
3208  token::destination(minter));
+
3209  env.close();
+
3210  env(token::acceptSellOffer(minter, offerSellBack));
+
3211  env.close();
+
3212  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3213  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
3214  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
3215  }
+
3216  // Show that in brokered mode:
+
3217  // 1. An unexpired sell offer with an expiration can be accepted.
+
3218  // 2. An expired sell offer cannot be accepted and remains
+
3219  // in ledger after the accept fails.
+
3220  {
+
3221  std::uint32_t const expiration = lastClose(env) + 25;
3222 
-
3223  uint256 const buyOffer0 =
-
3224  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
3225  env(token::createOffer(buyer, nftokenID0, drops(1)),
-
3226  token::owner(minter));
-
3227 
-
3228  uint256 const buyOffer1 =
-
3229  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
3230  env(token::createOffer(buyer, nftokenID1, drops(1)),
-
3231  token::owner(minter));
-
3232 
-
3233  env.close();
-
3234  BEAST_EXPECT(lastClose(env) < expiration);
-
3235  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3236  BEAST_EXPECT(ownerCount(env, minter) == 3);
-
3237  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
3238 
-
3239  // An unexpired offer can be brokered.
-
3240  env(token::brokerOffers(issuer, buyOffer0, sellOffer0));
-
3241 
-
3242  // Close enough ledgers to get past the expiration.
-
3243  while (lastClose(env) < expiration)
-
3244  env.close();
-
3245 
-
3246  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3247  BEAST_EXPECT(ownerCount(env, minter) == 2);
-
3248  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
3249 
-
3250  // If the sell offer is expired it cannot be brokered.
-
3251  env(token::brokerOffers(issuer, buyOffer1, sellOffer1),
-
3252  ter(tecEXPIRED));
-
3253  env.close();
-
3254 
-
3255  // The expired sell offer is still in the ledger.
-
3256  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3257  BEAST_EXPECT(ownerCount(env, minter) == 2);
-
3258  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
3259 
-
3260  // Anyone can cancel the expired sell offer.
-
3261  env(token::cancelOffer(buyer, {buyOffer1, sellOffer1}));
-
3262  env.close();
-
3263  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3264  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
3265  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
3223  uint256 const sellOffer0 =
+
3224  keylet::nftoffer(minter, env.seq(minter)).key;
+
3225  env(token::createOffer(minter, nftokenID0, drops(1)),
+
3226  token::expiration(expiration),
+
3227  txflags(tfSellNFToken));
+
3228 
+
3229  uint256 const sellOffer1 =
+
3230  keylet::nftoffer(minter, env.seq(minter)).key;
+
3231  env(token::createOffer(minter, nftokenID1, drops(1)),
+
3232  token::expiration(expiration),
+
3233  txflags(tfSellNFToken));
+
3234 
+
3235  uint256 const buyOffer0 =
+
3236  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
3237  env(token::createOffer(buyer, nftokenID0, drops(1)),
+
3238  token::owner(minter));
+
3239 
+
3240  uint256 const buyOffer1 =
+
3241  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
3242  env(token::createOffer(buyer, nftokenID1, drops(1)),
+
3243  token::owner(minter));
+
3244 
+
3245  env.close();
+
3246  BEAST_EXPECT(lastClose(env) < expiration);
+
3247  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3248  BEAST_EXPECT(ownerCount(env, minter) == 3);
+
3249  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
3250 
+
3251  // An unexpired offer can be brokered.
+
3252  env(token::brokerOffers(issuer, buyOffer0, sellOffer0));
+
3253 
+
3254  // Close enough ledgers to get past the expiration.
+
3255  while (lastClose(env) < expiration)
+
3256  env.close();
+
3257 
+
3258  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3259  BEAST_EXPECT(ownerCount(env, minter) == 2);
+
3260  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
3261 
+
3262  // If the sell offer is expired it cannot be brokered.
+
3263  env(token::brokerOffers(issuer, buyOffer1, sellOffer1),
+
3264  ter(tecEXPIRED));
+
3265  env.close();
3266 
-
3267  // Transfer nftokenID0 back to minter so we start the next test in
-
3268  // a simple place.
-
3269  uint256 const offerSellBack =
-
3270  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
3271  env(token::createOffer(buyer, nftokenID0, XRP(0)),
-
3272  txflags(tfSellNFToken),
-
3273  token::destination(minter));
+
3267  // The expired sell offer is still in the ledger.
+
3268  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3269  BEAST_EXPECT(ownerCount(env, minter) == 2);
+
3270  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
3271 
+
3272  // Anyone can cancel the expired sell offer.
+
3273  env(token::cancelOffer(buyer, {buyOffer1, sellOffer1}));
3274  env.close();
-
3275  env(token::acceptSellOffer(minter, offerSellBack));
-
3276  env.close();
-
3277  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3278  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
3279  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
3280  }
-
3281  // Show that in brokered mode:
-
3282  // 1. An unexpired buy offer with an expiration can be accepted.
-
3283  // 2. An expired buy offer cannot be accepted and remains
-
3284  // in ledger after the accept fails.
-
3285  {
-
3286  std::uint32_t const expiration = lastClose(env) + 25;
-
3287 
-
3288  uint256 const sellOffer0 =
-
3289  keylet::nftoffer(minter, env.seq(minter)).key;
-
3290  env(token::createOffer(minter, nftokenID0, drops(1)),
-
3291  txflags(tfSellNFToken));
-
3292 
-
3293  uint256 const sellOffer1 =
-
3294  keylet::nftoffer(minter, env.seq(minter)).key;
-
3295  env(token::createOffer(minter, nftokenID1, drops(1)),
-
3296  txflags(tfSellNFToken));
-
3297 
-
3298  uint256 const buyOffer0 =
-
3299  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
3300  env(token::createOffer(buyer, nftokenID0, drops(1)),
-
3301  token::expiration(expiration),
-
3302  token::owner(minter));
-
3303 
-
3304  uint256 const buyOffer1 =
-
3305  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
3306  env(token::createOffer(buyer, nftokenID1, drops(1)),
-
3307  token::expiration(expiration),
-
3308  token::owner(minter));
+
3275  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3276  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
3277  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
3278 
+
3279  // Transfer nftokenID0 back to minter so we start the next test in
+
3280  // a simple place.
+
3281  uint256 const offerSellBack =
+
3282  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
3283  env(token::createOffer(buyer, nftokenID0, XRP(0)),
+
3284  txflags(tfSellNFToken),
+
3285  token::destination(minter));
+
3286  env.close();
+
3287  env(token::acceptSellOffer(minter, offerSellBack));
+
3288  env.close();
+
3289  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3290  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
3291  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
3292  }
+
3293  // Show that in brokered mode:
+
3294  // 1. An unexpired buy offer with an expiration can be accepted.
+
3295  // 2. An expired buy offer cannot be accepted and remains
+
3296  // in ledger after the accept fails.
+
3297  {
+
3298  std::uint32_t const expiration = lastClose(env) + 25;
+
3299 
+
3300  uint256 const sellOffer0 =
+
3301  keylet::nftoffer(minter, env.seq(minter)).key;
+
3302  env(token::createOffer(minter, nftokenID0, drops(1)),
+
3303  txflags(tfSellNFToken));
+
3304 
+
3305  uint256 const sellOffer1 =
+
3306  keylet::nftoffer(minter, env.seq(minter)).key;
+
3307  env(token::createOffer(minter, nftokenID1, drops(1)),
+
3308  txflags(tfSellNFToken));
3309 
-
3310  env.close();
-
3311  BEAST_EXPECT(lastClose(env) < expiration);
-
3312  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3313  BEAST_EXPECT(ownerCount(env, minter) == 3);
-
3314  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
3310  uint256 const buyOffer0 =
+
3311  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
3312  env(token::createOffer(buyer, nftokenID0, drops(1)),
+
3313  token::expiration(expiration),
+
3314  token::owner(minter));
3315 
-
3316  // An unexpired offer can be brokered.
-
3317  env(token::brokerOffers(issuer, buyOffer0, sellOffer0));
-
3318 
-
3319  // Close enough ledgers to get past the expiration.
-
3320  while (lastClose(env) < expiration)
-
3321  env.close();
-
3322 
-
3323  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3324  BEAST_EXPECT(ownerCount(env, minter) == 2);
-
3325  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
3326 
-
3327  // If the buy offer is expired it cannot be brokered.
-
3328  env(token::brokerOffers(issuer, buyOffer1, sellOffer1),
-
3329  ter(tecEXPIRED));
-
3330  env.close();
-
3331 
-
3332  // The expired buy offer is still in the ledger.
-
3333  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3334  BEAST_EXPECT(ownerCount(env, minter) == 2);
-
3335  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
3336 
-
3337  // Anyone can cancel the expired buy offer.
-
3338  env(token::cancelOffer(minter, {buyOffer1, sellOffer1}));
-
3339  env.close();
-
3340  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3341  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
3342  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
3316  uint256 const buyOffer1 =
+
3317  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
3318  env(token::createOffer(buyer, nftokenID1, drops(1)),
+
3319  token::expiration(expiration),
+
3320  token::owner(minter));
+
3321 
+
3322  env.close();
+
3323  BEAST_EXPECT(lastClose(env) < expiration);
+
3324  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3325  BEAST_EXPECT(ownerCount(env, minter) == 3);
+
3326  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
3327 
+
3328  // An unexpired offer can be brokered.
+
3329  env(token::brokerOffers(issuer, buyOffer0, sellOffer0));
+
3330 
+
3331  // Close enough ledgers to get past the expiration.
+
3332  while (lastClose(env) < expiration)
+
3333  env.close();
+
3334 
+
3335  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3336  BEAST_EXPECT(ownerCount(env, minter) == 2);
+
3337  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
3338 
+
3339  // If the buy offer is expired it cannot be brokered.
+
3340  env(token::brokerOffers(issuer, buyOffer1, sellOffer1),
+
3341  ter(tecEXPIRED));
+
3342  env.close();
3343 
-
3344  // Transfer nftokenID0 back to minter so we start the next test in
-
3345  // a simple place.
-
3346  uint256 const offerSellBack =
-
3347  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
3348  env(token::createOffer(buyer, nftokenID0, XRP(0)),
-
3349  txflags(tfSellNFToken),
-
3350  token::destination(minter));
+
3344  // The expired buy offer is still in the ledger.
+
3345  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3346  BEAST_EXPECT(ownerCount(env, minter) == 2);
+
3347  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
3348 
+
3349  // Anyone can cancel the expired buy offer.
+
3350  env(token::cancelOffer(minter, {buyOffer1, sellOffer1}));
3351  env.close();
-
3352  env(token::acceptSellOffer(minter, offerSellBack));
-
3353  env.close();
-
3354  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3355  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
3356  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
3357  }
-
3358  // Show that in brokered mode:
-
3359  // 1. An unexpired buy/sell offer pair with an expiration can be
-
3360  // accepted.
-
3361  // 2. An expired buy/sell offer pair cannot be accepted and they
-
3362  // remain in ledger after the accept fails.
-
3363  {
-
3364  std::uint32_t const expiration = lastClose(env) + 25;
-
3365 
-
3366  uint256 const sellOffer0 =
-
3367  keylet::nftoffer(minter, env.seq(minter)).key;
-
3368  env(token::createOffer(minter, nftokenID0, drops(1)),
-
3369  token::expiration(expiration),
-
3370  txflags(tfSellNFToken));
-
3371 
-
3372  uint256 const sellOffer1 =
-
3373  keylet::nftoffer(minter, env.seq(minter)).key;
-
3374  env(token::createOffer(minter, nftokenID1, drops(1)),
-
3375  token::expiration(expiration),
-
3376  txflags(tfSellNFToken));
+
3352  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3353  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
3354  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
3355 
+
3356  // Transfer nftokenID0 back to minter so we start the next test in
+
3357  // a simple place.
+
3358  uint256 const offerSellBack =
+
3359  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
3360  env(token::createOffer(buyer, nftokenID0, XRP(0)),
+
3361  txflags(tfSellNFToken),
+
3362  token::destination(minter));
+
3363  env.close();
+
3364  env(token::acceptSellOffer(minter, offerSellBack));
+
3365  env.close();
+
3366  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3367  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
3368  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
3369  }
+
3370  // Show that in brokered mode:
+
3371  // 1. An unexpired buy/sell offer pair with an expiration can be
+
3372  // accepted.
+
3373  // 2. An expired buy/sell offer pair cannot be accepted and they
+
3374  // remain in ledger after the accept fails.
+
3375  {
+
3376  std::uint32_t const expiration = lastClose(env) + 25;
3377 
-
3378  uint256 const buyOffer0 =
-
3379  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
3380  env(token::createOffer(buyer, nftokenID0, drops(1)),
+
3378  uint256 const sellOffer0 =
+
3379  keylet::nftoffer(minter, env.seq(minter)).key;
+
3380  env(token::createOffer(minter, nftokenID0, drops(1)),
3381  token::expiration(expiration),
-
3382  token::owner(minter));
+
3382  txflags(tfSellNFToken));
3383 
-
3384  uint256 const buyOffer1 =
-
3385  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
3386  env(token::createOffer(buyer, nftokenID1, drops(1)),
+
3384  uint256 const sellOffer1 =
+
3385  keylet::nftoffer(minter, env.seq(minter)).key;
+
3386  env(token::createOffer(minter, nftokenID1, drops(1)),
3387  token::expiration(expiration),
-
3388  token::owner(minter));
+
3388  txflags(tfSellNFToken));
3389 
-
3390  env.close();
-
3391  BEAST_EXPECT(lastClose(env) < expiration);
-
3392  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3393  BEAST_EXPECT(ownerCount(env, minter) == 3);
-
3394  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
3390  uint256 const buyOffer0 =
+
3391  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
3392  env(token::createOffer(buyer, nftokenID0, drops(1)),
+
3393  token::expiration(expiration),
+
3394  token::owner(minter));
3395 
-
3396  // Unexpired offers can be brokered.
-
3397  env(token::brokerOffers(issuer, buyOffer0, sellOffer0));
-
3398 
-
3399  // Close enough ledgers to get past the expiration.
-
3400  while (lastClose(env) < expiration)
-
3401  env.close();
-
3402 
-
3403  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3404  BEAST_EXPECT(ownerCount(env, minter) == 2);
-
3405  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
3406 
-
3407  // If the offers are expired they cannot be brokered.
-
3408  env(token::brokerOffers(issuer, buyOffer1, sellOffer1),
-
3409  ter(tecEXPIRED));
-
3410  env.close();
-
3411 
-
3412  // The expired offers are still in the ledger.
-
3413  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3414  BEAST_EXPECT(ownerCount(env, minter) == 2);
-
3415  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
3416 
-
3417  // Anyone can cancel the expired offers.
-
3418  env(token::cancelOffer(issuer, {buyOffer1, sellOffer1}));
-
3419  env.close();
-
3420  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3421  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
3422  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
3396  uint256 const buyOffer1 =
+
3397  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
3398  env(token::createOffer(buyer, nftokenID1, drops(1)),
+
3399  token::expiration(expiration),
+
3400  token::owner(minter));
+
3401 
+
3402  env.close();
+
3403  BEAST_EXPECT(lastClose(env) < expiration);
+
3404  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3405  BEAST_EXPECT(ownerCount(env, minter) == 3);
+
3406  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
3407 
+
3408  // Unexpired offers can be brokered.
+
3409  env(token::brokerOffers(issuer, buyOffer0, sellOffer0));
+
3410 
+
3411  // Close enough ledgers to get past the expiration.
+
3412  while (lastClose(env) < expiration)
+
3413  env.close();
+
3414 
+
3415  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3416  BEAST_EXPECT(ownerCount(env, minter) == 2);
+
3417  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
3418 
+
3419  // If the offers are expired they cannot be brokered.
+
3420  env(token::brokerOffers(issuer, buyOffer1, sellOffer1),
+
3421  ter(tecEXPIRED));
+
3422  env.close();
3423 
-
3424  // Transfer nftokenID0 back to minter so we start the next test in
-
3425  // a simple place.
-
3426  uint256 const offerSellBack =
-
3427  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
3428  env(token::createOffer(buyer, nftokenID0, XRP(0)),
-
3429  txflags(tfSellNFToken),
-
3430  token::destination(minter));
+
3424  // The expired offers are still in the ledger.
+
3425  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3426  BEAST_EXPECT(ownerCount(env, minter) == 2);
+
3427  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
3428 
+
3429  // Anyone can cancel the expired offers.
+
3430  env(token::cancelOffer(issuer, {buyOffer1, sellOffer1}));
3431  env.close();
-
3432  env(token::acceptSellOffer(minter, offerSellBack));
-
3433  env.close();
-
3434  BEAST_EXPECT(ownerCount(env, issuer) == 0);
-
3435  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
3436  BEAST_EXPECT(ownerCount(env, buyer) == 0);
-
3437  }
-
3438  }
-
3439 
-
3440  void
-
3441  testCancelOffers(FeatureBitset features)
-
3442  {
-
3443  // Look at offer canceling.
-
3444  testcase("Cancel offers");
-
3445 
-
3446  using namespace test::jtx;
-
3447 
-
3448  Env env{*this, features};
-
3449 
-
3450  Account const alice("alice");
-
3451  Account const becky("becky");
-
3452  Account const minter("minter");
-
3453  env.fund(XRP(50000), alice, becky, minter);
-
3454  env.close();
-
3455 
-
3456  // alice has a minter to see if minters have offer canceling permission.
-
3457  env(token::setMinter(alice, minter));
-
3458  env.close();
+
3432  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3433  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
3434  BEAST_EXPECT(ownerCount(env, buyer) == 1);
+
3435 
+
3436  // Transfer nftokenID0 back to minter so we start the next test in
+
3437  // a simple place.
+
3438  uint256 const offerSellBack =
+
3439  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
3440  env(token::createOffer(buyer, nftokenID0, XRP(0)),
+
3441  txflags(tfSellNFToken),
+
3442  token::destination(minter));
+
3443  env.close();
+
3444  env(token::acceptSellOffer(minter, offerSellBack));
+
3445  env.close();
+
3446  BEAST_EXPECT(ownerCount(env, issuer) == 0);
+
3447  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
3448  BEAST_EXPECT(ownerCount(env, buyer) == 0);
+
3449  }
+
3450  }
+
3451 
+
3452  void
+
3453  testCancelOffers(FeatureBitset features)
+
3454  {
+
3455  // Look at offer canceling.
+
3456  testcase("Cancel offers");
+
3457 
+
3458  using namespace test::jtx;
3459 
-
3460  uint256 const nftokenID =
-
3461  token::getNextID(env, alice, 0, tfTransferable);
-
3462  env(token::mint(alice, 0), txflags(tfTransferable));
-
3463  env.close();
-
3464 
-
3465  // Anyone can cancel an expired offer.
-
3466  uint256 const expiredOfferIndex =
-
3467  keylet::nftoffer(alice, env.seq(alice)).key;
-
3468 
-
3469  env(token::createOffer(alice, nftokenID, XRP(1000)),
-
3470  txflags(tfSellNFToken),
-
3471  token::expiration(lastClose(env) + 13));
-
3472  env.close();
-
3473 
-
3474  // The offer has not expired yet, so becky can't cancel it now.
-
3475  BEAST_EXPECT(ownerCount(env, alice) == 2);
-
3476  env(token::cancelOffer(becky, {expiredOfferIndex}),
-
3477  ter(tecNO_PERMISSION));
-
3478  env.close();
-
3479 
-
3480  // Close a couple of ledgers and advance the time. Then becky
-
3481  // should be able to cancel the (now) expired offer.
-
3482  env.close();
-
3483  env.close();
-
3484  env(token::cancelOffer(becky, {expiredOfferIndex}));
-
3485  env.close();
-
3486  BEAST_EXPECT(ownerCount(env, alice) == 1);
-
3487 
-
3488  // Create a couple of offers with a destination. Those offers
-
3489  // should be cancellable by the creator and the destination.
-
3490  uint256 const dest1OfferIndex =
-
3491  keylet::nftoffer(alice, env.seq(alice)).key;
-
3492 
-
3493  env(token::createOffer(alice, nftokenID, XRP(1000)),
-
3494  token::destination(becky),
-
3495  txflags(tfSellNFToken));
-
3496  env.close();
-
3497  BEAST_EXPECT(ownerCount(env, alice) == 2);
-
3498 
-
3499  // Minter can't cancel that offer, but becky (the destination) can.
-
3500  env(token::cancelOffer(minter, {dest1OfferIndex}),
-
3501  ter(tecNO_PERMISSION));
-
3502  env.close();
-
3503  BEAST_EXPECT(ownerCount(env, alice) == 2);
+
3460  Env env{*this, features};
+
3461 
+
3462  Account const alice("alice");
+
3463  Account const becky("becky");
+
3464  Account const minter("minter");
+
3465  env.fund(XRP(50000), alice, becky, minter);
+
3466  env.close();
+
3467 
+
3468  // alice has a minter to see if minters have offer canceling permission.
+
3469  env(token::setMinter(alice, minter));
+
3470  env.close();
+
3471 
+
3472  uint256 const nftokenID =
+
3473  token::getNextID(env, alice, 0, tfTransferable);
+
3474  env(token::mint(alice, 0), txflags(tfTransferable));
+
3475  env.close();
+
3476 
+
3477  // Anyone can cancel an expired offer.
+
3478  uint256 const expiredOfferIndex =
+
3479  keylet::nftoffer(alice, env.seq(alice)).key;
+
3480 
+
3481  env(token::createOffer(alice, nftokenID, XRP(1000)),
+
3482  txflags(tfSellNFToken),
+
3483  token::expiration(lastClose(env) + 13));
+
3484  env.close();
+
3485 
+
3486  // The offer has not expired yet, so becky can't cancel it now.
+
3487  BEAST_EXPECT(ownerCount(env, alice) == 2);
+
3488  env(token::cancelOffer(becky, {expiredOfferIndex}),
+
3489  ter(tecNO_PERMISSION));
+
3490  env.close();
+
3491 
+
3492  // Close a couple of ledgers and advance the time. Then becky
+
3493  // should be able to cancel the (now) expired offer.
+
3494  env.close();
+
3495  env.close();
+
3496  env(token::cancelOffer(becky, {expiredOfferIndex}));
+
3497  env.close();
+
3498  BEAST_EXPECT(ownerCount(env, alice) == 1);
+
3499 
+
3500  // Create a couple of offers with a destination. Those offers
+
3501  // should be cancellable by the creator and the destination.
+
3502  uint256 const dest1OfferIndex =
+
3503  keylet::nftoffer(alice, env.seq(alice)).key;
3504 
-
3505  env(token::cancelOffer(becky, {dest1OfferIndex}));
-
3506  env.close();
-
3507  BEAST_EXPECT(ownerCount(env, alice) == 1);
-
3508 
-
3509  // alice can cancel her own offer, even if becky is the destination.
-
3510  uint256 const dest2OfferIndex =
-
3511  keylet::nftoffer(alice, env.seq(alice)).key;
-
3512 
-
3513  env(token::createOffer(alice, nftokenID, XRP(1000)),
-
3514  token::destination(becky),
-
3515  txflags(tfSellNFToken));
-
3516  env.close();
-
3517  BEAST_EXPECT(ownerCount(env, alice) == 2);
-
3518 
-
3519  env(token::cancelOffer(alice, {dest2OfferIndex}));
-
3520  env.close();
-
3521  BEAST_EXPECT(ownerCount(env, alice) == 1);
-
3522 
-
3523  // The issuer has no special permissions regarding offer cancellation.
-
3524  // Minter creates a token with alice as issuer. alice cannot cancel
-
3525  // minter's offer.
-
3526  uint256 const mintersNFTokenID =
-
3527  token::getNextID(env, alice, 0, tfTransferable);
-
3528  env(token::mint(minter, 0),
-
3529  token::issuer(alice),
-
3530  txflags(tfTransferable));
-
3531  env.close();
-
3532 
-
3533  uint256 const minterOfferIndex =
-
3534  keylet::nftoffer(minter, env.seq(minter)).key;
-
3535 
-
3536  env(token::createOffer(minter, mintersNFTokenID, XRP(1000)),
-
3537  txflags(tfSellNFToken));
-
3538  env.close();
-
3539  BEAST_EXPECT(ownerCount(env, minter) == 2);
-
3540 
-
3541  // Nobody other than minter should be able to cancel minter's offer.
-
3542  env(token::cancelOffer(alice, {minterOfferIndex}),
-
3543  ter(tecNO_PERMISSION));
-
3544  env(token::cancelOffer(becky, {minterOfferIndex}),
-
3545  ter(tecNO_PERMISSION));
-
3546  env.close();
-
3547  BEAST_EXPECT(ownerCount(env, minter) == 2);
-
3548 
-
3549  env(token::cancelOffer(minter, {minterOfferIndex}));
+
3505  env(token::createOffer(alice, nftokenID, XRP(1000)),
+
3506  token::destination(becky),
+
3507  txflags(tfSellNFToken));
+
3508  env.close();
+
3509  BEAST_EXPECT(ownerCount(env, alice) == 2);
+
3510 
+
3511  // Minter can't cancel that offer, but becky (the destination) can.
+
3512  env(token::cancelOffer(minter, {dest1OfferIndex}),
+
3513  ter(tecNO_PERMISSION));
+
3514  env.close();
+
3515  BEAST_EXPECT(ownerCount(env, alice) == 2);
+
3516 
+
3517  env(token::cancelOffer(becky, {dest1OfferIndex}));
+
3518  env.close();
+
3519  BEAST_EXPECT(ownerCount(env, alice) == 1);
+
3520 
+
3521  // alice can cancel her own offer, even if becky is the destination.
+
3522  uint256 const dest2OfferIndex =
+
3523  keylet::nftoffer(alice, env.seq(alice)).key;
+
3524 
+
3525  env(token::createOffer(alice, nftokenID, XRP(1000)),
+
3526  token::destination(becky),
+
3527  txflags(tfSellNFToken));
+
3528  env.close();
+
3529  BEAST_EXPECT(ownerCount(env, alice) == 2);
+
3530 
+
3531  env(token::cancelOffer(alice, {dest2OfferIndex}));
+
3532  env.close();
+
3533  BEAST_EXPECT(ownerCount(env, alice) == 1);
+
3534 
+
3535  // The issuer has no special permissions regarding offer cancellation.
+
3536  // Minter creates a token with alice as issuer. alice cannot cancel
+
3537  // minter's offer.
+
3538  uint256 const mintersNFTokenID =
+
3539  token::getNextID(env, alice, 0, tfTransferable);
+
3540  env(token::mint(minter, 0),
+
3541  token::issuer(alice),
+
3542  txflags(tfTransferable));
+
3543  env.close();
+
3544 
+
3545  uint256 const minterOfferIndex =
+
3546  keylet::nftoffer(minter, env.seq(minter)).key;
+
3547 
+
3548  env(token::createOffer(minter, mintersNFTokenID, XRP(1000)),
+
3549  txflags(tfSellNFToken));
3550  env.close();
-
3551  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
3552  }
-
3553 
-
3554  void
-
3555  testCancelTooManyOffers(FeatureBitset features)
-
3556  {
-
3557  // Look at the case where too many offers are passed in a cancel.
-
3558  testcase("Cancel too many offers");
-
3559 
-
3560  using namespace test::jtx;
-
3561 
-
3562  Env env{*this, features};
-
3563 
-
3564  // We want to maximize the metadata from a cancel offer transaction to
-
3565  // make sure we don't hit metadata limits. The way we'll do that is:
-
3566  //
-
3567  // 1. Generate twice as many separate funded accounts as we have
-
3568  // offers.
-
3569  // 2.
-
3570  // a. One of these accounts mints an NFT with a full URL.
-
3571  // b. The other account makes an offer that will expire soon.
-
3572  // 3. After all of these offers have expired, cancel all of the
-
3573  // expired offers in a single transaction.
-
3574  //
-
3575  // I can't think of any way to increase the metadata beyond this,
-
3576  // but I'm open to ideas.
-
3577  Account const alice("alice");
-
3578  env.fund(XRP(1000), alice);
-
3579  env.close();
-
3580 
-
3581  std::string const uri(maxTokenURILength, '?');
-
3582  std::vector<uint256> offerIndexes;
-
3583  offerIndexes.reserve(maxTokenOfferCancelCount + 1);
-
3584  for (uint32_t i = 0; i < maxTokenOfferCancelCount + 1; ++i)
-
3585  {
-
3586  Account const nftAcct(std::string("nftAcct") + std::to_string(i));
-
3587  Account const offerAcct(
-
3588  std::string("offerAcct") + std::to_string(i));
-
3589  env.fund(XRP(1000), nftAcct, offerAcct);
-
3590  env.close();
-
3591 
-
3592  uint256 const nftokenID =
-
3593  token::getNextID(env, nftAcct, 0, tfTransferable);
-
3594  env(token::mint(nftAcct, 0),
-
3595  token::uri(uri),
-
3596  txflags(tfTransferable));
-
3597  env.close();
-
3598 
-
3599  offerIndexes.push_back(
-
3600  keylet::nftoffer(offerAcct, env.seq(offerAcct)).key);
-
3601  env(token::createOffer(offerAcct, nftokenID, drops(1)),
-
3602  token::owner(nftAcct),
-
3603  token::expiration(lastClose(env) + 5));
-
3604  env.close();
-
3605  }
-
3606 
-
3607  // Close the ledger so the last of the offers expire.
-
3608  env.close();
-
3609 
-
3610  // All offers should be in the ledger.
-
3611  for (uint256 const& offerIndex : offerIndexes)
-
3612  {
-
3613  BEAST_EXPECT(env.le(keylet::nftoffer(offerIndex)));
-
3614  }
-
3615 
-
3616  // alice attempts to cancel all of the expired offers. There is one
-
3617  // too many so the request fails.
-
3618  env(token::cancelOffer(alice, offerIndexes), ter(temMALFORMED));
-
3619  env.close();
-
3620 
-
3621  // However alice can cancel just one of the offers.
-
3622  env(token::cancelOffer(alice, {offerIndexes.back()}));
-
3623  env.close();
-
3624 
-
3625  // Verify that offer is gone from the ledger.
-
3626  BEAST_EXPECT(!env.le(keylet::nftoffer(offerIndexes.back())));
-
3627  offerIndexes.pop_back();
-
3628 
-
3629  // But alice adds a sell offer to the list...
-
3630  {
-
3631  uint256 const nftokenID =
-
3632  token::getNextID(env, alice, 0, tfTransferable);
-
3633  env(token::mint(alice, 0),
-
3634  token::uri(uri),
-
3635  txflags(tfTransferable));
-
3636  env.close();
-
3637 
-
3638  offerIndexes.push_back(keylet::nftoffer(alice, env.seq(alice)).key);
-
3639  env(token::createOffer(alice, nftokenID, drops(1)),
-
3640  txflags(tfSellNFToken));
-
3641  env.close();
-
3642 
-
3643  // alice's owner count should now to 2 for the nft and the offer.
-
3644  BEAST_EXPECT(ownerCount(env, alice) == 2);
-
3645 
-
3646  // Because alice added the sell offer there are still too many
-
3647  // offers in the list to cancel.
-
3648  env(token::cancelOffer(alice, offerIndexes), ter(temMALFORMED));
-
3649  env.close();
-
3650 
-
3651  // alice burns her nft which removes the nft and the offer.
-
3652  env(token::burn(alice, nftokenID));
+
3551  BEAST_EXPECT(ownerCount(env, minter) == 2);
+
3552 
+
3553  // Nobody other than minter should be able to cancel minter's offer.
+
3554  env(token::cancelOffer(alice, {minterOfferIndex}),
+
3555  ter(tecNO_PERMISSION));
+
3556  env(token::cancelOffer(becky, {minterOfferIndex}),
+
3557  ter(tecNO_PERMISSION));
+
3558  env.close();
+
3559  BEAST_EXPECT(ownerCount(env, minter) == 2);
+
3560 
+
3561  env(token::cancelOffer(minter, {minterOfferIndex}));
+
3562  env.close();
+
3563  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
3564  }
+
3565 
+
3566  void
+
3567  testCancelTooManyOffers(FeatureBitset features)
+
3568  {
+
3569  // Look at the case where too many offers are passed in a cancel.
+
3570  testcase("Cancel too many offers");
+
3571 
+
3572  using namespace test::jtx;
+
3573 
+
3574  Env env{*this, features};
+
3575 
+
3576  // We want to maximize the metadata from a cancel offer transaction to
+
3577  // make sure we don't hit metadata limits. The way we'll do that is:
+
3578  //
+
3579  // 1. Generate twice as many separate funded accounts as we have
+
3580  // offers.
+
3581  // 2.
+
3582  // a. One of these accounts mints an NFT with a full URL.
+
3583  // b. The other account makes an offer that will expire soon.
+
3584  // 3. After all of these offers have expired, cancel all of the
+
3585  // expired offers in a single transaction.
+
3586  //
+
3587  // I can't think of any way to increase the metadata beyond this,
+
3588  // but I'm open to ideas.
+
3589  Account const alice("alice");
+
3590  env.fund(XRP(1000), alice);
+
3591  env.close();
+
3592 
+
3593  std::string const uri(maxTokenURILength, '?');
+
3594  std::vector<uint256> offerIndexes;
+
3595  offerIndexes.reserve(maxTokenOfferCancelCount + 1);
+
3596  for (uint32_t i = 0; i < maxTokenOfferCancelCount + 1; ++i)
+
3597  {
+
3598  Account const nftAcct(std::string("nftAcct") + std::to_string(i));
+
3599  Account const offerAcct(
+
3600  std::string("offerAcct") + std::to_string(i));
+
3601  env.fund(XRP(1000), nftAcct, offerAcct);
+
3602  env.close();
+
3603 
+
3604  uint256 const nftokenID =
+
3605  token::getNextID(env, nftAcct, 0, tfTransferable);
+
3606  env(token::mint(nftAcct, 0),
+
3607  token::uri(uri),
+
3608  txflags(tfTransferable));
+
3609  env.close();
+
3610 
+
3611  offerIndexes.push_back(
+
3612  keylet::nftoffer(offerAcct, env.seq(offerAcct)).key);
+
3613  env(token::createOffer(offerAcct, nftokenID, drops(1)),
+
3614  token::owner(nftAcct),
+
3615  token::expiration(lastClose(env) + 5));
+
3616  env.close();
+
3617  }
+
3618 
+
3619  // Close the ledger so the last of the offers expire.
+
3620  env.close();
+
3621 
+
3622  // All offers should be in the ledger.
+
3623  for (uint256 const& offerIndex : offerIndexes)
+
3624  {
+
3625  BEAST_EXPECT(env.le(keylet::nftoffer(offerIndex)));
+
3626  }
+
3627 
+
3628  // alice attempts to cancel all of the expired offers. There is one
+
3629  // too many so the request fails.
+
3630  env(token::cancelOffer(alice, offerIndexes), ter(temMALFORMED));
+
3631  env.close();
+
3632 
+
3633  // However alice can cancel just one of the offers.
+
3634  env(token::cancelOffer(alice, {offerIndexes.back()}));
+
3635  env.close();
+
3636 
+
3637  // Verify that offer is gone from the ledger.
+
3638  BEAST_EXPECT(!env.le(keylet::nftoffer(offerIndexes.back())));
+
3639  offerIndexes.pop_back();
+
3640 
+
3641  // But alice adds a sell offer to the list...
+
3642  {
+
3643  uint256 const nftokenID =
+
3644  token::getNextID(env, alice, 0, tfTransferable);
+
3645  env(token::mint(alice, 0),
+
3646  token::uri(uri),
+
3647  txflags(tfTransferable));
+
3648  env.close();
+
3649 
+
3650  offerIndexes.push_back(keylet::nftoffer(alice, env.seq(alice)).key);
+
3651  env(token::createOffer(alice, nftokenID, drops(1)),
+
3652  txflags(tfSellNFToken));
3653  env.close();
3654 
-
3655  // If alice's owner count is zero we can see that the offer
-
3656  // and nft are both gone.
-
3657  BEAST_EXPECT(ownerCount(env, alice) == 0);
-
3658  offerIndexes.pop_back();
-
3659  }
-
3660 
-
3661  // Now there are few enough offers in the list that they can all
-
3662  // be cancelled in a single transaction.
-
3663  env(token::cancelOffer(alice, offerIndexes));
-
3664  env.close();
-
3665 
-
3666  // Verify that remaining offers are gone from the ledger.
-
3667  for (uint256 const& offerIndex : offerIndexes)
-
3668  {
-
3669  BEAST_EXPECT(!env.le(keylet::nftoffer(offerIndex)));
-
3670  }
-
3671  }
+
3655  // alice's owner count should now to 2 for the nft and the offer.
+
3656  BEAST_EXPECT(ownerCount(env, alice) == 2);
+
3657 
+
3658  // Because alice added the sell offer there are still too many
+
3659  // offers in the list to cancel.
+
3660  env(token::cancelOffer(alice, offerIndexes), ter(temMALFORMED));
+
3661  env.close();
+
3662 
+
3663  // alice burns her nft which removes the nft and the offer.
+
3664  env(token::burn(alice, nftokenID));
+
3665  env.close();
+
3666 
+
3667  // If alice's owner count is zero we can see that the offer
+
3668  // and nft are both gone.
+
3669  BEAST_EXPECT(ownerCount(env, alice) == 0);
+
3670  offerIndexes.pop_back();
+
3671  }
3672 
-
3673  void
-
3674  testBrokeredAccept(FeatureBitset features)
-
3675  {
-
3676  // Look at the case where too many offers are passed in a cancel.
-
3677  testcase("Brokered NFT offer accept");
-
3678 
-
3679  using namespace test::jtx;
-
3680 
-
3681  Env env{*this, features};
-
3682 
-
3683  // The most important thing to explore here is the way funds are
-
3684  // assigned from the buyer to...
-
3685  // o the Seller,
-
3686  // o the Broker, and
-
3687  // o the Issuer (in the case of a transfer fee).
-
3688 
-
3689  Account const issuer{"issuer"};
-
3690  Account const minter{"minter"};
-
3691  Account const buyer{"buyer"};
-
3692  Account const broker{"broker"};
-
3693  Account const gw{"gw"};
-
3694  IOU const gwXAU(gw["XAU"]);
-
3695 
-
3696  env.fund(XRP(1000), issuer, minter, buyer, broker, gw);
-
3697  env.close();
-
3698 
-
3699  env(trust(issuer, gwXAU(2000)));
-
3700  env(trust(minter, gwXAU(2000)));
-
3701  env(trust(buyer, gwXAU(2000)));
-
3702  env(trust(broker, gwXAU(2000)));
-
3703  env.close();
-
3704 
-
3705  env(token::setMinter(issuer, minter));
-
3706  env.close();
+
3673  // Now there are few enough offers in the list that they can all
+
3674  // be cancelled in a single transaction.
+
3675  env(token::cancelOffer(alice, offerIndexes));
+
3676  env.close();
+
3677 
+
3678  // Verify that remaining offers are gone from the ledger.
+
3679  for (uint256 const& offerIndex : offerIndexes)
+
3680  {
+
3681  BEAST_EXPECT(!env.le(keylet::nftoffer(offerIndex)));
+
3682  }
+
3683  }
+
3684 
+
3685  void
+
3686  testBrokeredAccept(FeatureBitset features)
+
3687  {
+
3688  // Look at the case where too many offers are passed in a cancel.
+
3689  testcase("Brokered NFT offer accept");
+
3690 
+
3691  using namespace test::jtx;
+
3692 
+
3693  Env env{*this, features};
+
3694 
+
3695  // The most important thing to explore here is the way funds are
+
3696  // assigned from the buyer to...
+
3697  // o the Seller,
+
3698  // o the Broker, and
+
3699  // o the Issuer (in the case of a transfer fee).
+
3700 
+
3701  Account const issuer{"issuer"};
+
3702  Account const minter{"minter"};
+
3703  Account const buyer{"buyer"};
+
3704  Account const broker{"broker"};
+
3705  Account const gw{"gw"};
+
3706  IOU const gwXAU(gw["XAU"]);
3707 
-
3708  // Lambda to check owner count of all accounts is one.
-
3709  auto checkOwnerCountIsOne =
-
3710  [this, &env](
-
3711  std::initializer_list<std::reference_wrapper<Account const>>
-
3712  accounts,
-
3713  int line) {
-
3714  for (Account const& acct : accounts)
-
3715  {
-
3716  if (std::uint32_t ownerCount = this->ownerCount(env, acct);
-
3717  ownerCount != 1)
-
3718  {
-
3719  std::stringstream ss;
-
3720  ss << "Account " << acct.human()
-
3721  << " expected ownerCount == 1. Got " << ownerCount;
-
3722  fail(ss.str(), __FILE__, line);
-
3723  }
-
3724  }
-
3725  };
-
3726 
-
3727  // Lambda that mints an NFT and returns the nftID.
-
3728  auto mintNFT = [&env, &issuer, &minter](std::uint16_t xferFee = 0) {
-
3729  uint256 const nftID =
-
3730  token::getNextID(env, issuer, 0, tfTransferable, xferFee);
-
3731  env(token::mint(minter, 0),
-
3732  token::issuer(issuer),
-
3733  token::xferFee(xferFee),
-
3734  txflags(tfTransferable));
-
3735  env.close();
-
3736  return nftID;
-
3737  };
+
3708  env.fund(XRP(1000), issuer, minter, buyer, broker, gw);
+
3709  env.close();
+
3710 
+
3711  env(trust(issuer, gwXAU(2000)));
+
3712  env(trust(minter, gwXAU(2000)));
+
3713  env(trust(buyer, gwXAU(2000)));
+
3714  env(trust(broker, gwXAU(2000)));
+
3715  env.close();
+
3716 
+
3717  env(token::setMinter(issuer, minter));
+
3718  env.close();
+
3719 
+
3720  // Lambda to check owner count of all accounts is one.
+
3721  auto checkOwnerCountIsOne =
+
3722  [this, &env](
+
3723  std::initializer_list<std::reference_wrapper<Account const>>
+
3724  accounts,
+
3725  int line) {
+
3726  for (Account const& acct : accounts)
+
3727  {
+
3728  if (std::uint32_t ownerCount = this->ownerCount(env, acct);
+
3729  ownerCount != 1)
+
3730  {
+
3731  std::stringstream ss;
+
3732  ss << "Account " << acct.human()
+
3733  << " expected ownerCount == 1. Got " << ownerCount;
+
3734  fail(ss.str(), __FILE__, line);
+
3735  }
+
3736  }
+
3737  };
3738 
-
3739  // o Seller is selling for zero XRP.
-
3740  // o Broker charges no fee.
-
3741  // o No transfer fee.
-
3742  //
-
3743  // Since minter is selling for zero the currency must be XRP.
-
3744  {
-
3745  checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__);
-
3746 
-
3747  uint256 const nftID = mintNFT();
-
3748 
-
3749  // minter creates their offer.
-
3750  uint256 const minterOfferIndex =
-
3751  keylet::nftoffer(minter, env.seq(minter)).key;
-
3752  env(token::createOffer(minter, nftID, XRP(0)),
-
3753  txflags(tfSellNFToken));
-
3754  env.close();
-
3755 
-
3756  // buyer creates their offer. Note: a buy offer can never
-
3757  // offer zero.
-
3758  uint256 const buyOfferIndex =
-
3759  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
3760  env(token::createOffer(buyer, nftID, XRP(1)), token::owner(minter));
-
3761  env.close();
-
3762 
-
3763  auto const minterBalance = env.balance(minter);
-
3764  auto const buyerBalance = env.balance(buyer);
-
3765  auto const brokerBalance = env.balance(broker);
-
3766  auto const issuerBalance = env.balance(issuer);
+
3739  // Lambda that mints an NFT and returns the nftID.
+
3740  auto mintNFT = [&env, &issuer, &minter](std::uint16_t xferFee = 0) {
+
3741  uint256 const nftID =
+
3742  token::getNextID(env, issuer, 0, tfTransferable, xferFee);
+
3743  env(token::mint(minter, 0),
+
3744  token::issuer(issuer),
+
3745  token::xferFee(xferFee),
+
3746  txflags(tfTransferable));
+
3747  env.close();
+
3748  return nftID;
+
3749  };
+
3750 
+
3751  // o Seller is selling for zero XRP.
+
3752  // o Broker charges no fee.
+
3753  // o No transfer fee.
+
3754  //
+
3755  // Since minter is selling for zero the currency must be XRP.
+
3756  {
+
3757  checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__);
+
3758 
+
3759  uint256 const nftID = mintNFT();
+
3760 
+
3761  // minter creates their offer.
+
3762  uint256 const minterOfferIndex =
+
3763  keylet::nftoffer(minter, env.seq(minter)).key;
+
3764  env(token::createOffer(minter, nftID, XRP(0)),
+
3765  txflags(tfSellNFToken));
+
3766  env.close();
3767 
-
3768  // Broker charges no brokerFee.
-
3769  env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex));
-
3770  env.close();
-
3771 
-
3772  // Note that minter's XRP balance goes up even though they
-
3773  // requested XRP(0).
-
3774  BEAST_EXPECT(env.balance(minter) == minterBalance + XRP(1));
-
3775  BEAST_EXPECT(env.balance(buyer) == buyerBalance - XRP(1));
-
3776  BEAST_EXPECT(env.balance(broker) == brokerBalance - drops(10));
-
3777  BEAST_EXPECT(env.balance(issuer) == issuerBalance);
-
3778 
-
3779  // Burn the NFT so the next test starts with a clean state.
-
3780  env(token::burn(buyer, nftID));
-
3781  env.close();
-
3782  }
+
3768  // buyer creates their offer. Note: a buy offer can never
+
3769  // offer zero.
+
3770  uint256 const buyOfferIndex =
+
3771  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
3772  env(token::createOffer(buyer, nftID, XRP(1)), token::owner(minter));
+
3773  env.close();
+
3774 
+
3775  auto const minterBalance = env.balance(minter);
+
3776  auto const buyerBalance = env.balance(buyer);
+
3777  auto const brokerBalance = env.balance(broker);
+
3778  auto const issuerBalance = env.balance(issuer);
+
3779 
+
3780  // Broker charges no brokerFee.
+
3781  env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex));
+
3782  env.close();
3783 
-
3784  // o Seller is selling for zero XRP.
-
3785  // o Broker charges a fee.
-
3786  // o No transfer fee.
-
3787  //
-
3788  // Since minter is selling for zero the currency must be XRP.
-
3789  {
-
3790  checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__);
-
3791 
-
3792  uint256 const nftID = mintNFT();
-
3793 
-
3794  // minter creates their offer.
-
3795  uint256 const minterOfferIndex =
-
3796  keylet::nftoffer(minter, env.seq(minter)).key;
-
3797  env(token::createOffer(minter, nftID, XRP(0)),
-
3798  txflags(tfSellNFToken));
-
3799  env.close();
-
3800 
-
3801  // buyer creates their offer. Note: a buy offer can never
-
3802  // offer zero.
-
3803  uint256 const buyOfferIndex =
-
3804  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
3805  env(token::createOffer(buyer, nftID, XRP(1)), token::owner(minter));
-
3806  env.close();
-
3807 
-
3808  // Broker attempts to charge a 1.1 XRP brokerFee and fails.
-
3809  env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
-
3810  token::brokerFee(XRP(1.1)),
-
3811  ter(tecINSUFFICIENT_PAYMENT));
-
3812  env.close();
-
3813 
-
3814  auto const minterBalance = env.balance(minter);
-
3815  auto const buyerBalance = env.balance(buyer);
-
3816  auto const brokerBalance = env.balance(broker);
-
3817  auto const issuerBalance = env.balance(issuer);
-
3818 
-
3819  // Broker charges a 0.5 XRP brokerFee.
-
3820  env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
-
3821  token::brokerFee(XRP(0.5)));
-
3822  env.close();
-
3823 
-
3824  // Note that minter's XRP balance goes up even though they
-
3825  // requested XRP(0).
-
3826  BEAST_EXPECT(env.balance(minter) == minterBalance + XRP(0.5));
-
3827  BEAST_EXPECT(env.balance(buyer) == buyerBalance - XRP(1));
-
3828  BEAST_EXPECT(
-
3829  env.balance(broker) == brokerBalance + XRP(0.5) - drops(10));
-
3830  BEAST_EXPECT(env.balance(issuer) == issuerBalance);
-
3831 
-
3832  // Burn the NFT so the next test starts with a clean state.
-
3833  env(token::burn(buyer, nftID));
+
3784  // Note that minter's XRP balance goes up even though they
+
3785  // requested XRP(0).
+
3786  BEAST_EXPECT(env.balance(minter) == minterBalance + XRP(1));
+
3787  BEAST_EXPECT(env.balance(buyer) == buyerBalance - XRP(1));
+
3788  BEAST_EXPECT(env.balance(broker) == brokerBalance - drops(10));
+
3789  BEAST_EXPECT(env.balance(issuer) == issuerBalance);
+
3790 
+
3791  // Burn the NFT so the next test starts with a clean state.
+
3792  env(token::burn(buyer, nftID));
+
3793  env.close();
+
3794  }
+
3795 
+
3796  // o Seller is selling for zero XRP.
+
3797  // o Broker charges a fee.
+
3798  // o No transfer fee.
+
3799  //
+
3800  // Since minter is selling for zero the currency must be XRP.
+
3801  {
+
3802  checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__);
+
3803 
+
3804  uint256 const nftID = mintNFT();
+
3805 
+
3806  // minter creates their offer.
+
3807  uint256 const minterOfferIndex =
+
3808  keylet::nftoffer(minter, env.seq(minter)).key;
+
3809  env(token::createOffer(minter, nftID, XRP(0)),
+
3810  txflags(tfSellNFToken));
+
3811  env.close();
+
3812 
+
3813  // buyer creates their offer. Note: a buy offer can never
+
3814  // offer zero.
+
3815  uint256 const buyOfferIndex =
+
3816  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
3817  env(token::createOffer(buyer, nftID, XRP(1)), token::owner(minter));
+
3818  env.close();
+
3819 
+
3820  // Broker attempts to charge a 1.1 XRP brokerFee and fails.
+
3821  env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
+
3822  token::brokerFee(XRP(1.1)),
+
3823  ter(tecINSUFFICIENT_PAYMENT));
+
3824  env.close();
+
3825 
+
3826  auto const minterBalance = env.balance(minter);
+
3827  auto const buyerBalance = env.balance(buyer);
+
3828  auto const brokerBalance = env.balance(broker);
+
3829  auto const issuerBalance = env.balance(issuer);
+
3830 
+
3831  // Broker charges a 0.5 XRP brokerFee.
+
3832  env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
+
3833  token::brokerFee(XRP(0.5)));
3834  env.close();
-
3835  }
-
3836 
-
3837  // o Seller is selling for zero XRP.
-
3838  // o Broker charges no fee.
-
3839  // o 50% transfer fee.
-
3840  //
-
3841  // Since minter is selling for zero the currency must be XRP.
-
3842  {
-
3843  checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__);
-
3844 
-
3845  uint256 const nftID = mintNFT(maxTransferFee);
-
3846 
-
3847  // minter creates their offer.
-
3848  uint256 const minterOfferIndex =
-
3849  keylet::nftoffer(minter, env.seq(minter)).key;
-
3850  env(token::createOffer(minter, nftID, XRP(0)),
-
3851  txflags(tfSellNFToken));
-
3852  env.close();
-
3853 
-
3854  // buyer creates their offer. Note: a buy offer can never
-
3855  // offer zero.
-
3856  uint256 const buyOfferIndex =
-
3857  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
3858  env(token::createOffer(buyer, nftID, XRP(1)), token::owner(minter));
-
3859  env.close();
-
3860 
-
3861  auto const minterBalance = env.balance(minter);
-
3862  auto const buyerBalance = env.balance(buyer);
-
3863  auto const brokerBalance = env.balance(broker);
-
3864  auto const issuerBalance = env.balance(issuer);
+
3835 
+
3836  // Note that minter's XRP balance goes up even though they
+
3837  // requested XRP(0).
+
3838  BEAST_EXPECT(env.balance(minter) == minterBalance + XRP(0.5));
+
3839  BEAST_EXPECT(env.balance(buyer) == buyerBalance - XRP(1));
+
3840  BEAST_EXPECT(
+
3841  env.balance(broker) == brokerBalance + XRP(0.5) - drops(10));
+
3842  BEAST_EXPECT(env.balance(issuer) == issuerBalance);
+
3843 
+
3844  // Burn the NFT so the next test starts with a clean state.
+
3845  env(token::burn(buyer, nftID));
+
3846  env.close();
+
3847  }
+
3848 
+
3849  // o Seller is selling for zero XRP.
+
3850  // o Broker charges no fee.
+
3851  // o 50% transfer fee.
+
3852  //
+
3853  // Since minter is selling for zero the currency must be XRP.
+
3854  {
+
3855  checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__);
+
3856 
+
3857  uint256 const nftID = mintNFT(maxTransferFee);
+
3858 
+
3859  // minter creates their offer.
+
3860  uint256 const minterOfferIndex =
+
3861  keylet::nftoffer(minter, env.seq(minter)).key;
+
3862  env(token::createOffer(minter, nftID, XRP(0)),
+
3863  txflags(tfSellNFToken));
+
3864  env.close();
3865 
-
3866  // Broker charges no brokerFee.
-
3867  env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex));
-
3868  env.close();
-
3869 
-
3870  // Note that minter's XRP balance goes up even though they
-
3871  // requested XRP(0).
-
3872  BEAST_EXPECT(env.balance(minter) == minterBalance + XRP(0.5));
-
3873  BEAST_EXPECT(env.balance(buyer) == buyerBalance - XRP(1));
-
3874  BEAST_EXPECT(env.balance(broker) == brokerBalance - drops(10));
-
3875  BEAST_EXPECT(env.balance(issuer) == issuerBalance + XRP(0.5));
-
3876 
-
3877  // Burn the NFT so the next test starts with a clean state.
-
3878  env(token::burn(buyer, nftID));
-
3879  env.close();
-
3880  }
+
3866  // buyer creates their offer. Note: a buy offer can never
+
3867  // offer zero.
+
3868  uint256 const buyOfferIndex =
+
3869  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
3870  env(token::createOffer(buyer, nftID, XRP(1)), token::owner(minter));
+
3871  env.close();
+
3872 
+
3873  auto const minterBalance = env.balance(minter);
+
3874  auto const buyerBalance = env.balance(buyer);
+
3875  auto const brokerBalance = env.balance(broker);
+
3876  auto const issuerBalance = env.balance(issuer);
+
3877 
+
3878  // Broker charges no brokerFee.
+
3879  env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex));
+
3880  env.close();
3881 
-
3882  // o Seller is selling for zero XRP.
-
3883  // o Broker charges 0.5 XRP.
-
3884  // o 50% transfer fee.
-
3885  //
-
3886  // Since minter is selling for zero the currency must be XRP.
-
3887  {
-
3888  checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__);
-
3889 
-
3890  uint256 const nftID = mintNFT(maxTransferFee);
-
3891 
-
3892  // minter creates their offer.
-
3893  uint256 const minterOfferIndex =
-
3894  keylet::nftoffer(minter, env.seq(minter)).key;
-
3895  env(token::createOffer(minter, nftID, XRP(0)),
-
3896  txflags(tfSellNFToken));
-
3897  env.close();
-
3898 
-
3899  // buyer creates their offer. Note: a buy offer can never
-
3900  // offer zero.
-
3901  uint256 const buyOfferIndex =
-
3902  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
3903  env(token::createOffer(buyer, nftID, XRP(1)), token::owner(minter));
-
3904  env.close();
-
3905 
-
3906  auto const minterBalance = env.balance(minter);
-
3907  auto const buyerBalance = env.balance(buyer);
-
3908  auto const brokerBalance = env.balance(broker);
-
3909  auto const issuerBalance = env.balance(issuer);
+
3882  // Note that minter's XRP balance goes up even though they
+
3883  // requested XRP(0).
+
3884  BEAST_EXPECT(env.balance(minter) == minterBalance + XRP(0.5));
+
3885  BEAST_EXPECT(env.balance(buyer) == buyerBalance - XRP(1));
+
3886  BEAST_EXPECT(env.balance(broker) == brokerBalance - drops(10));
+
3887  BEAST_EXPECT(env.balance(issuer) == issuerBalance + XRP(0.5));
+
3888 
+
3889  // Burn the NFT so the next test starts with a clean state.
+
3890  env(token::burn(buyer, nftID));
+
3891  env.close();
+
3892  }
+
3893 
+
3894  // o Seller is selling for zero XRP.
+
3895  // o Broker charges 0.5 XRP.
+
3896  // o 50% transfer fee.
+
3897  //
+
3898  // Since minter is selling for zero the currency must be XRP.
+
3899  {
+
3900  checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__);
+
3901 
+
3902  uint256 const nftID = mintNFT(maxTransferFee);
+
3903 
+
3904  // minter creates their offer.
+
3905  uint256 const minterOfferIndex =
+
3906  keylet::nftoffer(minter, env.seq(minter)).key;
+
3907  env(token::createOffer(minter, nftID, XRP(0)),
+
3908  txflags(tfSellNFToken));
+
3909  env.close();
3910 
-
3911  // Broker charges a 0.75 XRP brokerFee.
-
3912  env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
-
3913  token::brokerFee(XRP(0.75)));
-
3914  env.close();
-
3915 
-
3916  // Note that, with a 50% transfer fee, issuer gets 1/2 of what's
-
3917  // left _after_ broker takes their fee. minter gets the remainder
-
3918  // after both broker and minter take their cuts
-
3919  BEAST_EXPECT(env.balance(minter) == minterBalance + XRP(0.125));
-
3920  BEAST_EXPECT(env.balance(buyer) == buyerBalance - XRP(1));
-
3921  BEAST_EXPECT(
-
3922  env.balance(broker) == brokerBalance + XRP(0.75) - drops(10));
-
3923  BEAST_EXPECT(env.balance(issuer) == issuerBalance + XRP(0.125));
-
3924 
-
3925  // Burn the NFT so the next test starts with a clean state.
-
3926  env(token::burn(buyer, nftID));
-
3927  env.close();
-
3928  }
-
3929 
-
3930  // Lambda to set the balance of all passed in accounts to gwXAU(1000).
-
3931  auto setXAUBalance_1000 =
-
3932  [this, &gw, &gwXAU, &env](
-
3933  std::initializer_list<std::reference_wrapper<Account const>>
-
3934  accounts,
-
3935  int line) {
-
3936  for (Account const& acct : accounts)
-
3937  {
-
3938  static const auto xau1000 = gwXAU(1000);
-
3939  auto const balance = env.balance(acct, gwXAU);
-
3940  if (balance < xau1000)
-
3941  {
-
3942  env(pay(gw, acct, xau1000 - balance));
-
3943  env.close();
-
3944  }
-
3945  else if (balance > xau1000)
-
3946  {
-
3947  env(pay(acct, gw, balance - xau1000));
-
3948  env.close();
-
3949  }
-
3950  if (env.balance(acct, gwXAU) != xau1000)
-
3951  {
-
3952  std::stringstream ss;
-
3953  ss << "Unable to set " << acct.human()
-
3954  << " account balance to gwXAU(1000)";
-
3955  this->fail(ss.str(), __FILE__, line);
+
3911  // buyer creates their offer. Note: a buy offer can never
+
3912  // offer zero.
+
3913  uint256 const buyOfferIndex =
+
3914  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
3915  env(token::createOffer(buyer, nftID, XRP(1)), token::owner(minter));
+
3916  env.close();
+
3917 
+
3918  auto const minterBalance = env.balance(minter);
+
3919  auto const buyerBalance = env.balance(buyer);
+
3920  auto const brokerBalance = env.balance(broker);
+
3921  auto const issuerBalance = env.balance(issuer);
+
3922 
+
3923  // Broker charges a 0.75 XRP brokerFee.
+
3924  env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
+
3925  token::brokerFee(XRP(0.75)));
+
3926  env.close();
+
3927 
+
3928  // Note that, with a 50% transfer fee, issuer gets 1/2 of what's
+
3929  // left _after_ broker takes their fee. minter gets the remainder
+
3930  // after both broker and minter take their cuts
+
3931  BEAST_EXPECT(env.balance(minter) == minterBalance + XRP(0.125));
+
3932  BEAST_EXPECT(env.balance(buyer) == buyerBalance - XRP(1));
+
3933  BEAST_EXPECT(
+
3934  env.balance(broker) == brokerBalance + XRP(0.75) - drops(10));
+
3935  BEAST_EXPECT(env.balance(issuer) == issuerBalance + XRP(0.125));
+
3936 
+
3937  // Burn the NFT so the next test starts with a clean state.
+
3938  env(token::burn(buyer, nftID));
+
3939  env.close();
+
3940  }
+
3941 
+
3942  // Lambda to set the balance of all passed in accounts to gwXAU(1000).
+
3943  auto setXAUBalance_1000 =
+
3944  [this, &gw, &gwXAU, &env](
+
3945  std::initializer_list<std::reference_wrapper<Account const>>
+
3946  accounts,
+
3947  int line) {
+
3948  for (Account const& acct : accounts)
+
3949  {
+
3950  static const auto xau1000 = gwXAU(1000);
+
3951  auto const balance = env.balance(acct, gwXAU);
+
3952  if (balance < xau1000)
+
3953  {
+
3954  env(pay(gw, acct, xau1000 - balance));
+
3955  env.close();
3956  }
-
3957  }
-
3958  };
-
3959 
-
3960  // The buyer and seller have identical amounts and there is no
-
3961  // transfer fee.
-
3962  {
-
3963  checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__);
-
3964  setXAUBalance_1000({issuer, minter, buyer, broker}, __LINE__);
-
3965 
-
3966  uint256 const nftID = mintNFT();
-
3967 
-
3968  // minter creates their offer.
-
3969  uint256 const minterOfferIndex =
-
3970  keylet::nftoffer(minter, env.seq(minter)).key;
-
3971  env(token::createOffer(minter, nftID, gwXAU(1000)),
-
3972  txflags(tfSellNFToken));
-
3973  env.close();
-
3974 
-
3975  {
-
3976  // buyer creates an offer for more XAU than they currently own.
-
3977  uint256 const buyOfferIndex =
-
3978  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
3979  env(token::createOffer(buyer, nftID, gwXAU(1001)),
-
3980  token::owner(minter));
-
3981  env.close();
-
3982 
-
3983  // broker attempts to broker the offers but cannot.
-
3984  env(token::brokerOffers(
-
3985  broker, buyOfferIndex, minterOfferIndex),
-
3986  ter(tecINSUFFICIENT_FUNDS));
-
3987  env.close();
-
3988 
-
3989  // Cancel buyer's bad offer so the next test starts in a
-
3990  // clean state.
-
3991  env(token::cancelOffer(buyer, {buyOfferIndex}));
-
3992  env.close();
-
3993  }
-
3994  {
-
3995  // buyer creates an offer for less that what minter is asking.
-
3996  uint256 const buyOfferIndex =
-
3997  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
3998  env(token::createOffer(buyer, nftID, gwXAU(999)),
-
3999  token::owner(minter));
-
4000  env.close();
-
4001 
-
4002  // broker attempts to broker the offers but cannot.
-
4003  env(token::brokerOffers(
-
4004  broker, buyOfferIndex, minterOfferIndex),
-
4005  ter(tecINSUFFICIENT_PAYMENT));
-
4006  env.close();
-
4007 
-
4008  // Cancel buyer's bad offer so the next test starts in a
-
4009  // clean state.
-
4010  env(token::cancelOffer(buyer, {buyOfferIndex}));
-
4011  env.close();
-
4012  }
+
3957  else if (balance > xau1000)
+
3958  {
+
3959  env(pay(acct, gw, balance - xau1000));
+
3960  env.close();
+
3961  }
+
3962  if (env.balance(acct, gwXAU) != xau1000)
+
3963  {
+
3964  std::stringstream ss;
+
3965  ss << "Unable to set " << acct.human()
+
3966  << " account balance to gwXAU(1000)";
+
3967  this->fail(ss.str(), __FILE__, line);
+
3968  }
+
3969  }
+
3970  };
+
3971 
+
3972  // The buyer and seller have identical amounts and there is no
+
3973  // transfer fee.
+
3974  {
+
3975  checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__);
+
3976  setXAUBalance_1000({issuer, minter, buyer, broker}, __LINE__);
+
3977 
+
3978  uint256 const nftID = mintNFT();
+
3979 
+
3980  // minter creates their offer.
+
3981  uint256 const minterOfferIndex =
+
3982  keylet::nftoffer(minter, env.seq(minter)).key;
+
3983  env(token::createOffer(minter, nftID, gwXAU(1000)),
+
3984  txflags(tfSellNFToken));
+
3985  env.close();
+
3986 
+
3987  {
+
3988  // buyer creates an offer for more XAU than they currently own.
+
3989  uint256 const buyOfferIndex =
+
3990  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
3991  env(token::createOffer(buyer, nftID, gwXAU(1001)),
+
3992  token::owner(minter));
+
3993  env.close();
+
3994 
+
3995  // broker attempts to broker the offers but cannot.
+
3996  env(token::brokerOffers(
+
3997  broker, buyOfferIndex, minterOfferIndex),
+
3998  ter(tecINSUFFICIENT_FUNDS));
+
3999  env.close();
+
4000 
+
4001  // Cancel buyer's bad offer so the next test starts in a
+
4002  // clean state.
+
4003  env(token::cancelOffer(buyer, {buyOfferIndex}));
+
4004  env.close();
+
4005  }
+
4006  {
+
4007  // buyer creates an offer for less that what minter is asking.
+
4008  uint256 const buyOfferIndex =
+
4009  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
4010  env(token::createOffer(buyer, nftID, gwXAU(999)),
+
4011  token::owner(minter));
+
4012  env.close();
4013 
-
4014  // buyer creates a large enough offer.
-
4015  uint256 const buyOfferIndex =
-
4016  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
4017  env(token::createOffer(buyer, nftID, gwXAU(1000)),
-
4018  token::owner(minter));
-
4019  env.close();
-
4020 
-
4021  // Broker attempts to charge a brokerFee but cannot.
-
4022  env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
-
4023  token::brokerFee(gwXAU(0.1)),
-
4024  ter(tecINSUFFICIENT_PAYMENT));
-
4025  env.close();
-
4026 
-
4027  // broker charges no brokerFee and succeeds.
-
4028  env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex));
-
4029  env.close();
-
4030 
-
4031  BEAST_EXPECT(ownerCount(env, issuer) == 1);
-
4032  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
4033  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
4034  BEAST_EXPECT(ownerCount(env, broker) == 1);
-
4035  BEAST_EXPECT(env.balance(issuer, gwXAU) == gwXAU(1000));
-
4036  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(2000));
-
4037  BEAST_EXPECT(env.balance(buyer, gwXAU) == gwXAU(0));
-
4038  BEAST_EXPECT(env.balance(broker, gwXAU) == gwXAU(1000));
-
4039 
-
4040  // Burn the NFT so the next test starts with a clean state.
-
4041  env(token::burn(buyer, nftID));
-
4042  env.close();
-
4043  }
-
4044 
-
4045  // seller offers more than buyer is asking.
-
4046  // There are both transfer and broker fees.
-
4047  {
-
4048  checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__);
-
4049  setXAUBalance_1000({issuer, minter, buyer, broker}, __LINE__);
-
4050 
-
4051  uint256 const nftID = mintNFT(maxTransferFee);
-
4052 
-
4053  // minter creates their offer.
-
4054  uint256 const minterOfferIndex =
-
4055  keylet::nftoffer(minter, env.seq(minter)).key;
-
4056  env(token::createOffer(minter, nftID, gwXAU(900)),
-
4057  txflags(tfSellNFToken));
-
4058  env.close();
-
4059  {
-
4060  // buyer creates an offer for more XAU than they currently own.
-
4061  uint256 const buyOfferIndex =
-
4062  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
4063  env(token::createOffer(buyer, nftID, gwXAU(1001)),
-
4064  token::owner(minter));
-
4065  env.close();
-
4066 
-
4067  // broker attempts to broker the offers but cannot.
-
4068  env(token::brokerOffers(
-
4069  broker, buyOfferIndex, minterOfferIndex),
-
4070  ter(tecINSUFFICIENT_FUNDS));
-
4071  env.close();
-
4072 
-
4073  // Cancel buyer's bad offer so the next test starts in a
-
4074  // clean state.
-
4075  env(token::cancelOffer(buyer, {buyOfferIndex}));
-
4076  env.close();
-
4077  }
-
4078  {
-
4079  // buyer creates an offer for less that what minter is asking.
-
4080  uint256 const buyOfferIndex =
-
4081  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
4082  env(token::createOffer(buyer, nftID, gwXAU(899)),
-
4083  token::owner(minter));
-
4084  env.close();
-
4085 
-
4086  // broker attempts to broker the offers but cannot.
-
4087  env(token::brokerOffers(
-
4088  broker, buyOfferIndex, minterOfferIndex),
-
4089  ter(tecINSUFFICIENT_PAYMENT));
-
4090  env.close();
-
4091 
-
4092  // Cancel buyer's bad offer so the next test starts in a
-
4093  // clean state.
-
4094  env(token::cancelOffer(buyer, {buyOfferIndex}));
-
4095  env.close();
-
4096  }
-
4097  // buyer creates a large enough offer.
-
4098  uint256 const buyOfferIndex =
-
4099  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
4100  env(token::createOffer(buyer, nftID, gwXAU(1000)),
-
4101  token::owner(minter));
-
4102  env.close();
+
4014  // broker attempts to broker the offers but cannot.
+
4015  env(token::brokerOffers(
+
4016  broker, buyOfferIndex, minterOfferIndex),
+
4017  ter(tecINSUFFICIENT_PAYMENT));
+
4018  env.close();
+
4019 
+
4020  // Cancel buyer's bad offer so the next test starts in a
+
4021  // clean state.
+
4022  env(token::cancelOffer(buyer, {buyOfferIndex}));
+
4023  env.close();
+
4024  }
+
4025 
+
4026  // buyer creates a large enough offer.
+
4027  uint256 const buyOfferIndex =
+
4028  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
4029  env(token::createOffer(buyer, nftID, gwXAU(1000)),
+
4030  token::owner(minter));
+
4031  env.close();
+
4032 
+
4033  // Broker attempts to charge a brokerFee but cannot.
+
4034  env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
+
4035  token::brokerFee(gwXAU(0.1)),
+
4036  ter(tecINSUFFICIENT_PAYMENT));
+
4037  env.close();
+
4038 
+
4039  // broker charges no brokerFee and succeeds.
+
4040  env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex));
+
4041  env.close();
+
4042 
+
4043  BEAST_EXPECT(ownerCount(env, issuer) == 1);
+
4044  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
4045  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
4046  BEAST_EXPECT(ownerCount(env, broker) == 1);
+
4047  BEAST_EXPECT(env.balance(issuer, gwXAU) == gwXAU(1000));
+
4048  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(2000));
+
4049  BEAST_EXPECT(env.balance(buyer, gwXAU) == gwXAU(0));
+
4050  BEAST_EXPECT(env.balance(broker, gwXAU) == gwXAU(1000));
+
4051 
+
4052  // Burn the NFT so the next test starts with a clean state.
+
4053  env(token::burn(buyer, nftID));
+
4054  env.close();
+
4055  }
+
4056 
+
4057  // seller offers more than buyer is asking.
+
4058  // There are both transfer and broker fees.
+
4059  {
+
4060  checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__);
+
4061  setXAUBalance_1000({issuer, minter, buyer, broker}, __LINE__);
+
4062 
+
4063  uint256 const nftID = mintNFT(maxTransferFee);
+
4064 
+
4065  // minter creates their offer.
+
4066  uint256 const minterOfferIndex =
+
4067  keylet::nftoffer(minter, env.seq(minter)).key;
+
4068  env(token::createOffer(minter, nftID, gwXAU(900)),
+
4069  txflags(tfSellNFToken));
+
4070  env.close();
+
4071  {
+
4072  // buyer creates an offer for more XAU than they currently own.
+
4073  uint256 const buyOfferIndex =
+
4074  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
4075  env(token::createOffer(buyer, nftID, gwXAU(1001)),
+
4076  token::owner(minter));
+
4077  env.close();
+
4078 
+
4079  // broker attempts to broker the offers but cannot.
+
4080  env(token::brokerOffers(
+
4081  broker, buyOfferIndex, minterOfferIndex),
+
4082  ter(tecINSUFFICIENT_FUNDS));
+
4083  env.close();
+
4084 
+
4085  // Cancel buyer's bad offer so the next test starts in a
+
4086  // clean state.
+
4087  env(token::cancelOffer(buyer, {buyOfferIndex}));
+
4088  env.close();
+
4089  }
+
4090  {
+
4091  // buyer creates an offer for less that what minter is asking.
+
4092  uint256 const buyOfferIndex =
+
4093  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
4094  env(token::createOffer(buyer, nftID, gwXAU(899)),
+
4095  token::owner(minter));
+
4096  env.close();
+
4097 
+
4098  // broker attempts to broker the offers but cannot.
+
4099  env(token::brokerOffers(
+
4100  broker, buyOfferIndex, minterOfferIndex),
+
4101  ter(tecINSUFFICIENT_PAYMENT));
+
4102  env.close();
4103 
-
4104  // Broker attempts to charge a brokerFee larger than the
-
4105  // difference between the two offers but cannot.
-
4106  env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
-
4107  token::brokerFee(gwXAU(101)),
-
4108  ter(tecINSUFFICIENT_PAYMENT));
-
4109  env.close();
-
4110 
-
4111  // broker charges the full difference between the two offers and
-
4112  // succeeds.
-
4113  env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
-
4114  token::brokerFee(gwXAU(100)));
-
4115  env.close();
-
4116 
-
4117  BEAST_EXPECT(ownerCount(env, issuer) == 1);
-
4118  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
4119  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
4120  BEAST_EXPECT(ownerCount(env, broker) == 1);
-
4121  BEAST_EXPECT(env.balance(issuer, gwXAU) == gwXAU(1450));
-
4122  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(1450));
-
4123  BEAST_EXPECT(env.balance(buyer, gwXAU) == gwXAU(0));
-
4124  BEAST_EXPECT(env.balance(broker, gwXAU) == gwXAU(1100));
-
4125 
-
4126  // Burn the NFT so the next test starts with a clean state.
-
4127  env(token::burn(buyer, nftID));
-
4128  env.close();
-
4129  }
-
4130  // seller offers more than buyer is asking.
-
4131  // There are both transfer and broker fees, but broker takes less than
-
4132  // the maximum.
-
4133  {
-
4134  checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__);
-
4135  setXAUBalance_1000({issuer, minter, buyer, broker}, __LINE__);
-
4136 
-
4137  uint256 const nftID = mintNFT(maxTransferFee / 2); // 25%
-
4138 
-
4139  // minter creates their offer.
-
4140  uint256 const minterOfferIndex =
-
4141  keylet::nftoffer(minter, env.seq(minter)).key;
-
4142  env(token::createOffer(minter, nftID, gwXAU(900)),
-
4143  txflags(tfSellNFToken));
-
4144  env.close();
-
4145 
-
4146  // buyer creates a large enough offer.
-
4147  uint256 const buyOfferIndex =
-
4148  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
4149  env(token::createOffer(buyer, nftID, gwXAU(1000)),
-
4150  token::owner(minter));
-
4151  env.close();
-
4152 
-
4153  // broker charges half difference between the two offers and
-
4154  // succeeds. 25% of the remaining difference goes to issuer.
-
4155  // The rest goes to minter.
-
4156  env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
-
4157  token::brokerFee(gwXAU(50)));
-
4158  env.close();
-
4159 
-
4160  BEAST_EXPECT(ownerCount(env, issuer) == 1);
-
4161  BEAST_EXPECT(ownerCount(env, minter) == 1);
-
4162  BEAST_EXPECT(ownerCount(env, buyer) == 2);
-
4163  BEAST_EXPECT(ownerCount(env, broker) == 1);
-
4164  BEAST_EXPECT(env.balance(issuer, gwXAU) == gwXAU(1237.5));
-
4165  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(1712.5));
-
4166  BEAST_EXPECT(env.balance(buyer, gwXAU) == gwXAU(0));
-
4167  BEAST_EXPECT(env.balance(broker, gwXAU) == gwXAU(1050));
-
4168 
-
4169  // Burn the NFT so the next test starts with a clean state.
-
4170  env(token::burn(buyer, nftID));
-
4171  env.close();
-
4172  }
-
4173  }
-
4174 
-
4175  void
-
4176  testNFTokenOfferOwner(FeatureBitset features)
-
4177  {
-
4178  // Verify the Owner field of an offer behaves as expected.
-
4179  testcase("NFToken offer owner");
+
4104  // Cancel buyer's bad offer so the next test starts in a
+
4105  // clean state.
+
4106  env(token::cancelOffer(buyer, {buyOfferIndex}));
+
4107  env.close();
+
4108  }
+
4109  // buyer creates a large enough offer.
+
4110  uint256 const buyOfferIndex =
+
4111  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
4112  env(token::createOffer(buyer, nftID, gwXAU(1000)),
+
4113  token::owner(minter));
+
4114  env.close();
+
4115 
+
4116  // Broker attempts to charge a brokerFee larger than the
+
4117  // difference between the two offers but cannot.
+
4118  env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
+
4119  token::brokerFee(gwXAU(101)),
+
4120  ter(tecINSUFFICIENT_PAYMENT));
+
4121  env.close();
+
4122 
+
4123  // broker charges the full difference between the two offers and
+
4124  // succeeds.
+
4125  env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
+
4126  token::brokerFee(gwXAU(100)));
+
4127  env.close();
+
4128 
+
4129  BEAST_EXPECT(ownerCount(env, issuer) == 1);
+
4130  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
4131  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
4132  BEAST_EXPECT(ownerCount(env, broker) == 1);
+
4133  BEAST_EXPECT(env.balance(issuer, gwXAU) == gwXAU(1450));
+
4134  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(1450));
+
4135  BEAST_EXPECT(env.balance(buyer, gwXAU) == gwXAU(0));
+
4136  BEAST_EXPECT(env.balance(broker, gwXAU) == gwXAU(1100));
+
4137 
+
4138  // Burn the NFT so the next test starts with a clean state.
+
4139  env(token::burn(buyer, nftID));
+
4140  env.close();
+
4141  }
+
4142  // seller offers more than buyer is asking.
+
4143  // There are both transfer and broker fees, but broker takes less than
+
4144  // the maximum.
+
4145  {
+
4146  checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__);
+
4147  setXAUBalance_1000({issuer, minter, buyer, broker}, __LINE__);
+
4148 
+
4149  uint256 const nftID = mintNFT(maxTransferFee / 2); // 25%
+
4150 
+
4151  // minter creates their offer.
+
4152  uint256 const minterOfferIndex =
+
4153  keylet::nftoffer(minter, env.seq(minter)).key;
+
4154  env(token::createOffer(minter, nftID, gwXAU(900)),
+
4155  txflags(tfSellNFToken));
+
4156  env.close();
+
4157 
+
4158  // buyer creates a large enough offer.
+
4159  uint256 const buyOfferIndex =
+
4160  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
4161  env(token::createOffer(buyer, nftID, gwXAU(1000)),
+
4162  token::owner(minter));
+
4163  env.close();
+
4164 
+
4165  // broker charges half difference between the two offers and
+
4166  // succeeds. 25% of the remaining difference goes to issuer.
+
4167  // The rest goes to minter.
+
4168  env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
+
4169  token::brokerFee(gwXAU(50)));
+
4170  env.close();
+
4171 
+
4172  BEAST_EXPECT(ownerCount(env, issuer) == 1);
+
4173  BEAST_EXPECT(ownerCount(env, minter) == 1);
+
4174  BEAST_EXPECT(ownerCount(env, buyer) == 2);
+
4175  BEAST_EXPECT(ownerCount(env, broker) == 1);
+
4176  BEAST_EXPECT(env.balance(issuer, gwXAU) == gwXAU(1237.5));
+
4177  BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(1712.5));
+
4178  BEAST_EXPECT(env.balance(buyer, gwXAU) == gwXAU(0));
+
4179  BEAST_EXPECT(env.balance(broker, gwXAU) == gwXAU(1050));
4180 
-
4181  using namespace test::jtx;
-
4182 
-
4183  Env env{*this, features};
-
4184 
-
4185  Account const issuer{"issuer"};
-
4186  Account const buyer1{"buyer1"};
-
4187  Account const buyer2{"buyer2"};
-
4188  env.fund(XRP(10000), issuer, buyer1, buyer2);
-
4189  env.close();
-
4190 
-
4191  // issuer creates an NFT.
-
4192  uint256 const nftId{token::getNextID(env, issuer, 0u, tfTransferable)};
-
4193  env(token::mint(issuer, 0u), txflags(tfTransferable));
-
4194  env.close();
-
4195 
-
4196  // Prove that issuer now owns nftId.
-
4197  BEAST_EXPECT(nftCount(env, issuer) == 1);
-
4198  BEAST_EXPECT(nftCount(env, buyer1) == 0);
-
4199  BEAST_EXPECT(nftCount(env, buyer2) == 0);
-
4200 
-
4201  // Both buyer1 and buyer2 create buy offers for nftId.
-
4202  uint256 const buyer1OfferIndex =
-
4203  keylet::nftoffer(buyer1, env.seq(buyer1)).key;
-
4204  env(token::createOffer(buyer1, nftId, XRP(100)), token::owner(issuer));
-
4205  uint256 const buyer2OfferIndex =
-
4206  keylet::nftoffer(buyer2, env.seq(buyer2)).key;
-
4207  env(token::createOffer(buyer2, nftId, XRP(100)), token::owner(issuer));
-
4208  env.close();
-
4209 
-
4210  // Lambda that counts the number of buy offers for a given NFT.
-
4211  auto nftBuyOfferCount = [&env](uint256 const& nftId) -> std::size_t {
-
4212  // We know that in this case not very many offers will be
-
4213  // returned, so we skip the marker stuff.
-
4214  Json::Value params;
-
4215  params[jss::nft_id] = to_string(nftId);
-
4216  Json::Value buyOffers =
-
4217  env.rpc("json", "nft_buy_offers", to_string(params));
-
4218 
-
4219  if (buyOffers.isMember(jss::result) &&
-
4220  buyOffers[jss::result].isMember(jss::offers))
-
4221  return buyOffers[jss::result][jss::offers].size();
-
4222 
-
4223  return 0;
-
4224  };
-
4225 
-
4226  // Show there are two buy offers for nftId.
-
4227  BEAST_EXPECT(nftBuyOfferCount(nftId) == 2);
-
4228 
-
4229  // issuer accepts buyer1's offer.
-
4230  env(token::acceptBuyOffer(issuer, buyer1OfferIndex));
-
4231  env.close();
-
4232 
-
4233  // Prove that buyer1 now owns nftId.
-
4234  BEAST_EXPECT(nftCount(env, issuer) == 0);
-
4235  BEAST_EXPECT(nftCount(env, buyer1) == 1);
-
4236  BEAST_EXPECT(nftCount(env, buyer2) == 0);
+
4181  // Burn the NFT so the next test starts with a clean state.
+
4182  env(token::burn(buyer, nftID));
+
4183  env.close();
+
4184  }
+
4185  }
+
4186 
+
4187  void
+
4188  testNFTokenOfferOwner(FeatureBitset features)
+
4189  {
+
4190  // Verify the Owner field of an offer behaves as expected.
+
4191  testcase("NFToken offer owner");
+
4192 
+
4193  using namespace test::jtx;
+
4194 
+
4195  Env env{*this, features};
+
4196 
+
4197  Account const issuer{"issuer"};
+
4198  Account const buyer1{"buyer1"};
+
4199  Account const buyer2{"buyer2"};
+
4200  env.fund(XRP(10000), issuer, buyer1, buyer2);
+
4201  env.close();
+
4202 
+
4203  // issuer creates an NFT.
+
4204  uint256 const nftId{token::getNextID(env, issuer, 0u, tfTransferable)};
+
4205  env(token::mint(issuer, 0u), txflags(tfTransferable));
+
4206  env.close();
+
4207 
+
4208  // Prove that issuer now owns nftId.
+
4209  BEAST_EXPECT(nftCount(env, issuer) == 1);
+
4210  BEAST_EXPECT(nftCount(env, buyer1) == 0);
+
4211  BEAST_EXPECT(nftCount(env, buyer2) == 0);
+
4212 
+
4213  // Both buyer1 and buyer2 create buy offers for nftId.
+
4214  uint256 const buyer1OfferIndex =
+
4215  keylet::nftoffer(buyer1, env.seq(buyer1)).key;
+
4216  env(token::createOffer(buyer1, nftId, XRP(100)), token::owner(issuer));
+
4217  uint256 const buyer2OfferIndex =
+
4218  keylet::nftoffer(buyer2, env.seq(buyer2)).key;
+
4219  env(token::createOffer(buyer2, nftId, XRP(100)), token::owner(issuer));
+
4220  env.close();
+
4221 
+
4222  // Lambda that counts the number of buy offers for a given NFT.
+
4223  auto nftBuyOfferCount = [&env](uint256 const& nftId) -> std::size_t {
+
4224  // We know that in this case not very many offers will be
+
4225  // returned, so we skip the marker stuff.
+
4226  Json::Value params;
+
4227  params[jss::nft_id] = to_string(nftId);
+
4228  Json::Value buyOffers =
+
4229  env.rpc("json", "nft_buy_offers", to_string(params));
+
4230 
+
4231  if (buyOffers.isMember(jss::result) &&
+
4232  buyOffers[jss::result].isMember(jss::offers))
+
4233  return buyOffers[jss::result][jss::offers].size();
+
4234 
+
4235  return 0;
+
4236  };
4237 
-
4238  // buyer1's offer was consumed, but buyer2's offer is still in the
-
4239  // ledger.
-
4240  BEAST_EXPECT(nftBuyOfferCount(nftId) == 1);
-
4241 
-
4242  // buyer1 can now accept buyer2's offer, even though buyer2's
-
4243  // NFTokenCreateOffer transaction specified the NFT Owner as issuer.
-
4244  env(token::acceptBuyOffer(buyer1, buyer2OfferIndex));
-
4245  env.close();
-
4246 
-
4247  // Prove that buyer2 now owns nftId.
-
4248  BEAST_EXPECT(nftCount(env, issuer) == 0);
-
4249  BEAST_EXPECT(nftCount(env, buyer1) == 0);
-
4250  BEAST_EXPECT(nftCount(env, buyer2) == 1);
-
4251 
-
4252  // All of the NFTokenOffers are now consumed.
-
4253  BEAST_EXPECT(nftBuyOfferCount(nftId) == 0);
-
4254  }
-
4255 
-
4256  void
-
4257  testNFTokenWithTickets(FeatureBitset features)
-
4258  {
-
4259  // Make sure all NFToken transactions work with tickets.
-
4260  testcase("NFToken transactions with tickets");
-
4261 
-
4262  using namespace test::jtx;
+
4238  // Show there are two buy offers for nftId.
+
4239  BEAST_EXPECT(nftBuyOfferCount(nftId) == 2);
+
4240 
+
4241  // issuer accepts buyer1's offer.
+
4242  env(token::acceptBuyOffer(issuer, buyer1OfferIndex));
+
4243  env.close();
+
4244 
+
4245  // Prove that buyer1 now owns nftId.
+
4246  BEAST_EXPECT(nftCount(env, issuer) == 0);
+
4247  BEAST_EXPECT(nftCount(env, buyer1) == 1);
+
4248  BEAST_EXPECT(nftCount(env, buyer2) == 0);
+
4249 
+
4250  // buyer1's offer was consumed, but buyer2's offer is still in the
+
4251  // ledger.
+
4252  BEAST_EXPECT(nftBuyOfferCount(nftId) == 1);
+
4253 
+
4254  // buyer1 can now accept buyer2's offer, even though buyer2's
+
4255  // NFTokenCreateOffer transaction specified the NFT Owner as issuer.
+
4256  env(token::acceptBuyOffer(buyer1, buyer2OfferIndex));
+
4257  env.close();
+
4258 
+
4259  // Prove that buyer2 now owns nftId.
+
4260  BEAST_EXPECT(nftCount(env, issuer) == 0);
+
4261  BEAST_EXPECT(nftCount(env, buyer1) == 0);
+
4262  BEAST_EXPECT(nftCount(env, buyer2) == 1);
4263 
-
4264  Env env{*this, features};
-
4265 
-
4266  Account const issuer{"issuer"};
-
4267  Account const buyer{"buyer"};
-
4268  env.fund(XRP(10000), issuer, buyer);
-
4269  env.close();
-
4270 
-
4271  // issuer and buyer grab enough tickets for all of the following
-
4272  // transactions. Note that once the tickets are acquired issuer's
-
4273  // and buyer's account sequence numbers should not advance.
-
4274  std::uint32_t issuerTicketSeq{env.seq(issuer) + 1};
-
4275  env(ticket::create(issuer, 10));
-
4276  env.close();
-
4277  std::uint32_t const issuerSeq{env.seq(issuer)};
-
4278  BEAST_EXPECT(ticketCount(env, issuer) == 10);
-
4279 
-
4280  std::uint32_t buyerTicketSeq{env.seq(buyer) + 1};
-
4281  env(ticket::create(buyer, 10));
-
4282  env.close();
-
4283  std::uint32_t const buyerSeq{env.seq(buyer)};
-
4284  BEAST_EXPECT(ticketCount(env, buyer) == 10);
-
4285 
-
4286  // NFTokenMint
-
4287  BEAST_EXPECT(ownerCount(env, issuer) == 10);
-
4288  uint256 const nftId{token::getNextID(env, issuer, 0u, tfTransferable)};
-
4289  env(token::mint(issuer, 0u),
-
4290  txflags(tfTransferable),
-
4291  ticket::use(issuerTicketSeq++));
-
4292  env.close();
-
4293  BEAST_EXPECT(ownerCount(env, issuer) == 10);
-
4294  BEAST_EXPECT(ticketCount(env, issuer) == 9);
-
4295 
-
4296  // NFTokenCreateOffer
-
4297  BEAST_EXPECT(ownerCount(env, buyer) == 10);
-
4298  uint256 const offerIndex0 = keylet::nftoffer(buyer, buyerTicketSeq).key;
-
4299  env(token::createOffer(buyer, nftId, XRP(1)),
-
4300  token::owner(issuer),
-
4301  ticket::use(buyerTicketSeq++));
-
4302  env.close();
-
4303  BEAST_EXPECT(ownerCount(env, buyer) == 10);
-
4304  BEAST_EXPECT(ticketCount(env, buyer) == 9);
-
4305 
-
4306  // NFTokenCancelOffer
-
4307  env(token::cancelOffer(buyer, {offerIndex0}),
-
4308  ticket::use(buyerTicketSeq++));
-
4309  env.close();
-
4310  BEAST_EXPECT(ownerCount(env, buyer) == 8);
-
4311  BEAST_EXPECT(ticketCount(env, buyer) == 8);
-
4312 
-
4313  // NFTokenCreateOffer. buyer tries again.
-
4314  uint256 const offerIndex1 = keylet::nftoffer(buyer, buyerTicketSeq).key;
-
4315  env(token::createOffer(buyer, nftId, XRP(2)),
-
4316  token::owner(issuer),
-
4317  ticket::use(buyerTicketSeq++));
-
4318  env.close();
-
4319  BEAST_EXPECT(ownerCount(env, buyer) == 8);
-
4320  BEAST_EXPECT(ticketCount(env, buyer) == 7);
-
4321 
-
4322  // NFTokenAcceptOffer. issuer accepts buyer's offer.
-
4323  env(token::acceptBuyOffer(issuer, offerIndex1),
-
4324  ticket::use(issuerTicketSeq++));
-
4325  env.close();
-
4326  BEAST_EXPECT(ownerCount(env, issuer) == 8);
-
4327  BEAST_EXPECT(ownerCount(env, buyer) == 8);
-
4328  BEAST_EXPECT(ticketCount(env, issuer) == 8);
-
4329 
-
4330  // NFTokenBurn. buyer burns the token they just bought.
-
4331  env(token::burn(buyer, nftId), ticket::use(buyerTicketSeq++));
-
4332  env.close();
-
4333  BEAST_EXPECT(ownerCount(env, issuer) == 8);
-
4334  BEAST_EXPECT(ownerCount(env, buyer) == 6);
-
4335  BEAST_EXPECT(ticketCount(env, buyer) == 6);
-
4336 
-
4337  // Verify that the account sequence numbers did not advance.
-
4338  BEAST_EXPECT(env.seq(issuer) == issuerSeq);
-
4339  BEAST_EXPECT(env.seq(buyer) == buyerSeq);
-
4340  }
+
4264  // All of the NFTokenOffers are now consumed.
+
4265  BEAST_EXPECT(nftBuyOfferCount(nftId) == 0);
+
4266  }
+
4267 
+
4268  void
+
4269  testNFTokenWithTickets(FeatureBitset features)
+
4270  {
+
4271  // Make sure all NFToken transactions work with tickets.
+
4272  testcase("NFToken transactions with tickets");
+
4273 
+
4274  using namespace test::jtx;
+
4275 
+
4276  Env env{*this, features};
+
4277 
+
4278  Account const issuer{"issuer"};
+
4279  Account const buyer{"buyer"};
+
4280  env.fund(XRP(10000), issuer, buyer);
+
4281  env.close();
+
4282 
+
4283  // issuer and buyer grab enough tickets for all of the following
+
4284  // transactions. Note that once the tickets are acquired issuer's
+
4285  // and buyer's account sequence numbers should not advance.
+
4286  std::uint32_t issuerTicketSeq{env.seq(issuer) + 1};
+
4287  env(ticket::create(issuer, 10));
+
4288  env.close();
+
4289  std::uint32_t const issuerSeq{env.seq(issuer)};
+
4290  BEAST_EXPECT(ticketCount(env, issuer) == 10);
+
4291 
+
4292  std::uint32_t buyerTicketSeq{env.seq(buyer) + 1};
+
4293  env(ticket::create(buyer, 10));
+
4294  env.close();
+
4295  std::uint32_t const buyerSeq{env.seq(buyer)};
+
4296  BEAST_EXPECT(ticketCount(env, buyer) == 10);
+
4297 
+
4298  // NFTokenMint
+
4299  BEAST_EXPECT(ownerCount(env, issuer) == 10);
+
4300  uint256 const nftId{token::getNextID(env, issuer, 0u, tfTransferable)};
+
4301  env(token::mint(issuer, 0u),
+
4302  txflags(tfTransferable),
+
4303  ticket::use(issuerTicketSeq++));
+
4304  env.close();
+
4305  BEAST_EXPECT(ownerCount(env, issuer) == 10);
+
4306  BEAST_EXPECT(ticketCount(env, issuer) == 9);
+
4307 
+
4308  // NFTokenCreateOffer
+
4309  BEAST_EXPECT(ownerCount(env, buyer) == 10);
+
4310  uint256 const offerIndex0 = keylet::nftoffer(buyer, buyerTicketSeq).key;
+
4311  env(token::createOffer(buyer, nftId, XRP(1)),
+
4312  token::owner(issuer),
+
4313  ticket::use(buyerTicketSeq++));
+
4314  env.close();
+
4315  BEAST_EXPECT(ownerCount(env, buyer) == 10);
+
4316  BEAST_EXPECT(ticketCount(env, buyer) == 9);
+
4317 
+
4318  // NFTokenCancelOffer
+
4319  env(token::cancelOffer(buyer, {offerIndex0}),
+
4320  ticket::use(buyerTicketSeq++));
+
4321  env.close();
+
4322  BEAST_EXPECT(ownerCount(env, buyer) == 8);
+
4323  BEAST_EXPECT(ticketCount(env, buyer) == 8);
+
4324 
+
4325  // NFTokenCreateOffer. buyer tries again.
+
4326  uint256 const offerIndex1 = keylet::nftoffer(buyer, buyerTicketSeq).key;
+
4327  env(token::createOffer(buyer, nftId, XRP(2)),
+
4328  token::owner(issuer),
+
4329  ticket::use(buyerTicketSeq++));
+
4330  env.close();
+
4331  BEAST_EXPECT(ownerCount(env, buyer) == 8);
+
4332  BEAST_EXPECT(ticketCount(env, buyer) == 7);
+
4333 
+
4334  // NFTokenAcceptOffer. issuer accepts buyer's offer.
+
4335  env(token::acceptBuyOffer(issuer, offerIndex1),
+
4336  ticket::use(issuerTicketSeq++));
+
4337  env.close();
+
4338  BEAST_EXPECT(ownerCount(env, issuer) == 8);
+
4339  BEAST_EXPECT(ownerCount(env, buyer) == 8);
+
4340  BEAST_EXPECT(ticketCount(env, issuer) == 8);
4341 
-
4342  void
-
4343  testNFTokenDeleteAccount(FeatureBitset features)
-
4344  {
-
4345  // Account deletion rules with NFTs:
-
4346  // 1. An account holding one or more NFT offers may be deleted.
-
4347  // 2. An NFT issuer with any NFTs they have issued still in the
-
4348  // ledger may not be deleted.
-
4349  // 3. An account holding one or more NFTs may not be deleted.
-
4350  testcase("NFToken delete account");
-
4351 
-
4352  using namespace test::jtx;
+
4342  // NFTokenBurn. buyer burns the token they just bought.
+
4343  env(token::burn(buyer, nftId), ticket::use(buyerTicketSeq++));
+
4344  env.close();
+
4345  BEAST_EXPECT(ownerCount(env, issuer) == 8);
+
4346  BEAST_EXPECT(ownerCount(env, buyer) == 6);
+
4347  BEAST_EXPECT(ticketCount(env, buyer) == 6);
+
4348 
+
4349  // Verify that the account sequence numbers did not advance.
+
4350  BEAST_EXPECT(env.seq(issuer) == issuerSeq);
+
4351  BEAST_EXPECT(env.seq(buyer) == buyerSeq);
+
4352  }
4353 
-
4354  Env env{*this, features};
-
4355 
-
4356  Account const issuer{"issuer"};
-
4357  Account const minter{"minter"};
-
4358  Account const becky{"becky"};
-
4359  Account const carla{"carla"};
-
4360  Account const daria{"daria"};
-
4361 
-
4362  env.fund(XRP(10000), issuer, minter, becky, carla, daria);
-
4363  env.close();
-
4364 
-
4365  // Allow enough ledgers to pass so any of these accounts can be deleted.
-
4366  for (int i = 0; i < 300; ++i)
-
4367  env.close();
-
4368 
-
4369  env(token::setMinter(issuer, minter));
-
4370  env.close();
-
4371 
-
4372  uint256 const nftId{token::getNextID(env, issuer, 0u, tfTransferable)};
-
4373  env(token::mint(minter, 0u),
-
4374  token::issuer(issuer),
-
4375  txflags(tfTransferable));
-
4376  env.close();
-
4377 
-
4378  // At the momement issuer and minter cannot delete themselves.
-
4379  // o issuer has an issued NFT in the ledger.
-
4380  // o minter owns an NFT.
-
4381  env(acctdelete(issuer, daria), fee(XRP(50)), ter(tecHAS_OBLIGATIONS));
-
4382  env(acctdelete(minter, daria), fee(XRP(50)), ter(tecHAS_OBLIGATIONS));
-
4383  env.close();
-
4384 
-
4385  // Let enough ledgers pass so the account delete transactions are
-
4386  // not retried.
-
4387  for (int i = 0; i < 15; ++i)
-
4388  env.close();
+
4354  void
+
4355  testNFTokenDeleteAccount(FeatureBitset features)
+
4356  {
+
4357  // Account deletion rules with NFTs:
+
4358  // 1. An account holding one or more NFT offers may be deleted.
+
4359  // 2. An NFT issuer with any NFTs they have issued still in the
+
4360  // ledger may not be deleted.
+
4361  // 3. An account holding one or more NFTs may not be deleted.
+
4362  testcase("NFToken delete account");
+
4363 
+
4364  using namespace test::jtx;
+
4365 
+
4366  Env env{*this, features};
+
4367 
+
4368  Account const issuer{"issuer"};
+
4369  Account const minter{"minter"};
+
4370  Account const becky{"becky"};
+
4371  Account const carla{"carla"};
+
4372  Account const daria{"daria"};
+
4373 
+
4374  env.fund(XRP(10000), issuer, minter, becky, carla, daria);
+
4375  env.close();
+
4376 
+
4377  // Allow enough ledgers to pass so any of these accounts can be deleted.
+
4378  for (int i = 0; i < 300; ++i)
+
4379  env.close();
+
4380 
+
4381  env(token::setMinter(issuer, minter));
+
4382  env.close();
+
4383 
+
4384  uint256 const nftId{token::getNextID(env, issuer, 0u, tfTransferable)};
+
4385  env(token::mint(minter, 0u),
+
4386  token::issuer(issuer),
+
4387  txflags(tfTransferable));
+
4388  env.close();
4389 
-
4390  // becky and carla create offers for minter's NFT.
-
4391  env(token::createOffer(becky, nftId, XRP(2)), token::owner(minter));
-
4392  env.close();
-
4393 
-
4394  uint256 const carlaOfferIndex =
-
4395  keylet::nftoffer(carla, env.seq(carla)).key;
-
4396  env(token::createOffer(carla, nftId, XRP(3)), token::owner(minter));
-
4397  env.close();
-
4398 
-
4399  // It should be possible for becky to delete herself, even though
-
4400  // becky has an active NFT offer.
-
4401  env(acctdelete(becky, daria), fee(XRP(50)));
-
4402  env.close();
-
4403 
-
4404  // minter accepts carla's offer.
-
4405  env(token::acceptBuyOffer(minter, carlaOfferIndex));
-
4406  env.close();
-
4407 
-
4408  // Now it should be possible for minter to delete themselves since
-
4409  // they no longer own an NFT.
-
4410  env(acctdelete(minter, daria), fee(XRP(50)));
-
4411  env.close();
-
4412 
-
4413  // 1. issuer cannot delete themselves because they issued an NFT that
-
4414  // is still in the ledger.
-
4415  // 2. carla owns an NFT, so she cannot delete herself.
-
4416  env(acctdelete(issuer, daria), fee(XRP(50)), ter(tecHAS_OBLIGATIONS));
-
4417  env(acctdelete(carla, daria), fee(XRP(50)), ter(tecHAS_OBLIGATIONS));
+
4390  // At the momement issuer and minter cannot delete themselves.
+
4391  // o issuer has an issued NFT in the ledger.
+
4392  // o minter owns an NFT.
+
4393  env(acctdelete(issuer, daria), fee(XRP(50)), ter(tecHAS_OBLIGATIONS));
+
4394  env(acctdelete(minter, daria), fee(XRP(50)), ter(tecHAS_OBLIGATIONS));
+
4395  env.close();
+
4396 
+
4397  // Let enough ledgers pass so the account delete transactions are
+
4398  // not retried.
+
4399  for (int i = 0; i < 15; ++i)
+
4400  env.close();
+
4401 
+
4402  // becky and carla create offers for minter's NFT.
+
4403  env(token::createOffer(becky, nftId, XRP(2)), token::owner(minter));
+
4404  env.close();
+
4405 
+
4406  uint256 const carlaOfferIndex =
+
4407  keylet::nftoffer(carla, env.seq(carla)).key;
+
4408  env(token::createOffer(carla, nftId, XRP(3)), token::owner(minter));
+
4409  env.close();
+
4410 
+
4411  // It should be possible for becky to delete herself, even though
+
4412  // becky has an active NFT offer.
+
4413  env(acctdelete(becky, daria), fee(XRP(50)));
+
4414  env.close();
+
4415 
+
4416  // minter accepts carla's offer.
+
4417  env(token::acceptBuyOffer(minter, carlaOfferIndex));
4418  env.close();
4419 
-
4420  // Let enough ledgers pass so the account delete transactions are
-
4421  // not retried.
-
4422  for (int i = 0; i < 15; ++i)
-
4423  env.close();
+
4420  // Now it should be possible for minter to delete themselves since
+
4421  // they no longer own an NFT.
+
4422  env(acctdelete(minter, daria), fee(XRP(50)));
+
4423  env.close();
4424 
-
4425  // carla burns her NFT. Since issuer's NFT is no longer in the
-
4426  // ledger, both issuer and carla can delete themselves.
-
4427  env(token::burn(carla, nftId));
-
4428  env.close();
-
4429 
-
4430  env(acctdelete(issuer, daria), fee(XRP(50)));
-
4431  env(acctdelete(carla, daria), fee(XRP(50)));
-
4432  env.close();
-
4433  }
-
4434 
-
4435  void
-
4436  testNftXxxOffers(FeatureBitset features)
-
4437  {
-
4438  testcase("nft_buy_offers and nft_sell_offers");
-
4439 
-
4440  // The default limit on returned NFToken offers is 250, so we need
-
4441  // to produce more than 250 offers of each kind in order to exercise
-
4442  // the marker.
-
4443 
-
4444  // Fortunately there's nothing in the rules that says an account
-
4445  // can't hold more than one offer for the same NFT. So we only
-
4446  // need two accounts to generate the necessary offers.
-
4447  using namespace test::jtx;
-
4448 
-
4449  Env env{*this, features};
-
4450 
-
4451  Account const issuer{"issuer"};
-
4452  Account const buyer{"buyer"};
-
4453 
-
4454  // A lot of offers requires a lot for reserve.
-
4455  env.fund(XRP(1000000), issuer, buyer);
-
4456  env.close();
-
4457 
-
4458  // Create an NFT that we'll make offers for.
-
4459  uint256 const nftID{token::getNextID(env, issuer, 0u, tfTransferable)};
-
4460  env(token::mint(issuer, 0), txflags(tfTransferable));
-
4461  env.close();
+
4425  // 1. issuer cannot delete themselves because they issued an NFT that
+
4426  // is still in the ledger.
+
4427  // 2. carla owns an NFT, so she cannot delete herself.
+
4428  env(acctdelete(issuer, daria), fee(XRP(50)), ter(tecHAS_OBLIGATIONS));
+
4429  env(acctdelete(carla, daria), fee(XRP(50)), ter(tecHAS_OBLIGATIONS));
+
4430  env.close();
+
4431 
+
4432  // Let enough ledgers pass so the account delete transactions are
+
4433  // not retried.
+
4434  for (int i = 0; i < 15; ++i)
+
4435  env.close();
+
4436 
+
4437  // carla burns her NFT. Since issuer's NFT is no longer in the
+
4438  // ledger, both issuer and carla can delete themselves.
+
4439  env(token::burn(carla, nftId));
+
4440  env.close();
+
4441 
+
4442  env(acctdelete(issuer, daria), fee(XRP(50)));
+
4443  env(acctdelete(carla, daria), fee(XRP(50)));
+
4444  env.close();
+
4445  }
+
4446 
+
4447  void
+
4448  testNftXxxOffers(FeatureBitset features)
+
4449  {
+
4450  testcase("nft_buy_offers and nft_sell_offers");
+
4451 
+
4452  // The default limit on returned NFToken offers is 250, so we need
+
4453  // to produce more than 250 offers of each kind in order to exercise
+
4454  // the marker.
+
4455 
+
4456  // Fortunately there's nothing in the rules that says an account
+
4457  // can't hold more than one offer for the same NFT. So we only
+
4458  // need two accounts to generate the necessary offers.
+
4459  using namespace test::jtx;
+
4460 
+
4461  Env env{*this, features};
4462 
-
4463  // A lambda that validates nft_XXX_offers query responses.
-
4464  auto checkOffers = [this, &env, &nftID](
-
4465  char const* request,
-
4466  int expectCount,
-
4467  int expectMarkerCount,
-
4468  int line) {
-
4469  int markerCount = 0;
-
4470  Json::Value allOffers(Json::arrayValue);
-
4471  std::string marker;
-
4472 
-
4473  // The do/while collects results until no marker is returned.
-
4474  do
-
4475  {
-
4476  Json::Value nftOffers = [&env, &nftID, &request, &marker]() {
-
4477  Json::Value params;
-
4478  params[jss::nft_id] = to_string(nftID);
-
4479 
-
4480  if (!marker.empty())
-
4481  params[jss::marker] = marker;
-
4482  return env.rpc("json", request, to_string(params));
-
4483  }();
+
4463  Account const issuer{"issuer"};
+
4464  Account const buyer{"buyer"};
+
4465 
+
4466  // A lot of offers requires a lot for reserve.
+
4467  env.fund(XRP(1000000), issuer, buyer);
+
4468  env.close();
+
4469 
+
4470  // Create an NFT that we'll make offers for.
+
4471  uint256 const nftID{token::getNextID(env, issuer, 0u, tfTransferable)};
+
4472  env(token::mint(issuer, 0), txflags(tfTransferable));
+
4473  env.close();
+
4474 
+
4475  // A lambda that validates nft_XXX_offers query responses.
+
4476  auto checkOffers = [this, &env, &nftID](
+
4477  char const* request,
+
4478  int expectCount,
+
4479  int expectMarkerCount,
+
4480  int line) {
+
4481  int markerCount = 0;
+
4482  Json::Value allOffers(Json::arrayValue);
+
4483  std::string marker;
4484 
-
4485  // If there are no offers for the NFT we get an error
-
4486  if (expectCount == 0)
-
4487  {
-
4488  if (expect(
-
4489  nftOffers.isMember(jss::result),
-
4490  "expected \"result\"",
-
4491  __FILE__,
-
4492  line))
-
4493  {
-
4494  if (expect(
-
4495  nftOffers[jss::result].isMember(jss::error),
-
4496  "expected \"error\"",
-
4497  __FILE__,
-
4498  line))
-
4499  {
-
4500  expect(
-
4501  nftOffers[jss::result][jss::error].asString() ==
-
4502  "objectNotFound",
-
4503  "expected \"objectNotFound\"",
-
4504  __FILE__,
-
4505  line);
-
4506  }
-
4507  }
-
4508  break;
-
4509  }
-
4510 
-
4511  marker.clear();
-
4512  if (expect(
-
4513  nftOffers.isMember(jss::result),
-
4514  "expected \"result\"",
-
4515  __FILE__,
-
4516  line))
-
4517  {
-
4518  Json::Value& result = nftOffers[jss::result];
-
4519 
-
4520  if (result.isMember(jss::marker))
-
4521  {
-
4522  ++markerCount;
-
4523  marker = result[jss::marker].asString();
-
4524  }
-
4525 
-
4526  if (expect(
-
4527  result.isMember(jss::offers),
-
4528  "expected \"offers\"",
-
4529  __FILE__,
-
4530  line))
-
4531  {
-
4532  Json::Value& someOffers = result[jss::offers];
-
4533  for (std::size_t i = 0; i < someOffers.size(); ++i)
-
4534  allOffers.append(someOffers[i]);
-
4535  }
-
4536  }
-
4537  } while (!marker.empty());
-
4538 
-
4539  // Verify the contents of allOffers makes sense.
-
4540  expect(
-
4541  allOffers.size() == expectCount,
-
4542  "Unexpected returned offer count",
-
4543  __FILE__,
-
4544  line);
-
4545  expect(
-
4546  markerCount == expectMarkerCount,
-
4547  "Unexpected marker count",
-
4548  __FILE__,
-
4549  line);
-
4550  std::optional<int> globalFlags;
-
4551  std::set<std::string> offerIndexes;
-
4552  std::set<std::string> amounts;
-
4553  for (Json::Value const& offer : allOffers)
-
4554  {
-
4555  // The flags on all found offers should be the same.
-
4556  if (!globalFlags)
-
4557  globalFlags = offer[jss::flags].asInt();
-
4558 
-
4559  expect(
-
4560  *globalFlags == offer[jss::flags].asInt(),
-
4561  "Inconsistent flags returned",
-
4562  __FILE__,
-
4563  line);
-
4564 
-
4565  // The test conditions should produce unique indexes and
-
4566  // amounts for all offers.
-
4567  offerIndexes.insert(offer[jss::nft_offer_index].asString());
-
4568  amounts.insert(offer[jss::amount].asString());
-
4569  }
+
4485  // The do/while collects results until no marker is returned.
+
4486  do
+
4487  {
+
4488  Json::Value nftOffers = [&env, &nftID, &request, &marker]() {
+
4489  Json::Value params;
+
4490  params[jss::nft_id] = to_string(nftID);
+
4491 
+
4492  if (!marker.empty())
+
4493  params[jss::marker] = marker;
+
4494  return env.rpc("json", request, to_string(params));
+
4495  }();
+
4496 
+
4497  // If there are no offers for the NFT we get an error
+
4498  if (expectCount == 0)
+
4499  {
+
4500  if (expect(
+
4501  nftOffers.isMember(jss::result),
+
4502  "expected \"result\"",
+
4503  __FILE__,
+
4504  line))
+
4505  {
+
4506  if (expect(
+
4507  nftOffers[jss::result].isMember(jss::error),
+
4508  "expected \"error\"",
+
4509  __FILE__,
+
4510  line))
+
4511  {
+
4512  expect(
+
4513  nftOffers[jss::result][jss::error].asString() ==
+
4514  "objectNotFound",
+
4515  "expected \"objectNotFound\"",
+
4516  __FILE__,
+
4517  line);
+
4518  }
+
4519  }
+
4520  break;
+
4521  }
+
4522 
+
4523  marker.clear();
+
4524  if (expect(
+
4525  nftOffers.isMember(jss::result),
+
4526  "expected \"result\"",
+
4527  __FILE__,
+
4528  line))
+
4529  {
+
4530  Json::Value& result = nftOffers[jss::result];
+
4531 
+
4532  if (result.isMember(jss::marker))
+
4533  {
+
4534  ++markerCount;
+
4535  marker = result[jss::marker].asString();
+
4536  }
+
4537 
+
4538  if (expect(
+
4539  result.isMember(jss::offers),
+
4540  "expected \"offers\"",
+
4541  __FILE__,
+
4542  line))
+
4543  {
+
4544  Json::Value& someOffers = result[jss::offers];
+
4545  for (std::size_t i = 0; i < someOffers.size(); ++i)
+
4546  allOffers.append(someOffers[i]);
+
4547  }
+
4548  }
+
4549  } while (!marker.empty());
+
4550 
+
4551  // Verify the contents of allOffers makes sense.
+
4552  expect(
+
4553  allOffers.size() == expectCount,
+
4554  "Unexpected returned offer count",
+
4555  __FILE__,
+
4556  line);
+
4557  expect(
+
4558  markerCount == expectMarkerCount,
+
4559  "Unexpected marker count",
+
4560  __FILE__,
+
4561  line);
+
4562  std::optional<int> globalFlags;
+
4563  std::set<std::string> offerIndexes;
+
4564  std::set<std::string> amounts;
+
4565  for (Json::Value const& offer : allOffers)
+
4566  {
+
4567  // The flags on all found offers should be the same.
+
4568  if (!globalFlags)
+
4569  globalFlags = offer[jss::flags].asInt();
4570 
-
4571  expect(
-
4572  offerIndexes.size() == expectCount,
-
4573  "Duplicate indexes returned?",
-
4574  __FILE__,
-
4575  line);
-
4576  expect(
-
4577  amounts.size() == expectCount,
-
4578  "Duplicate amounts returned?",
-
4579  __FILE__,
-
4580  line);
-
4581  };
+
4571  expect(
+
4572  *globalFlags == offer[jss::flags].asInt(),
+
4573  "Inconsistent flags returned",
+
4574  __FILE__,
+
4575  line);
+
4576 
+
4577  // The test conditions should produce unique indexes and
+
4578  // amounts for all offers.
+
4579  offerIndexes.insert(offer[jss::nft_offer_index].asString());
+
4580  amounts.insert(offer[jss::amount].asString());
+
4581  }
4582 
-
4583  // There are no sell offers.
-
4584  checkOffers("nft_sell_offers", 0, false, __LINE__);
-
4585 
-
4586  // A lambda that generates sell offers.
-
4587  STAmount sellPrice = XRP(0);
-
4588  auto makeSellOffers =
-
4589  [&env, &issuer, &nftID, &sellPrice](STAmount const& limit) {
-
4590  // Save a little test time by not closing too often.
-
4591  int offerCount = 0;
-
4592  while (sellPrice < limit)
-
4593  {
-
4594  sellPrice += XRP(1);
-
4595  env(token::createOffer(issuer, nftID, sellPrice),
-
4596  txflags(tfSellNFToken));
-
4597  if (++offerCount % 10 == 0)
-
4598  env.close();
-
4599  }
-
4600  env.close();
-
4601  };
-
4602 
-
4603  // There is one sell offer.
-
4604  makeSellOffers(XRP(1));
-
4605  checkOffers("nft_sell_offers", 1, 0, __LINE__);
-
4606 
-
4607  // There are 250 sell offers.
-
4608  makeSellOffers(XRP(250));
-
4609  checkOffers("nft_sell_offers", 250, 0, __LINE__);
-
4610 
-
4611  // There are 251 sell offers.
-
4612  makeSellOffers(XRP(251));
-
4613  checkOffers("nft_sell_offers", 251, 1, __LINE__);
+
4583  expect(
+
4584  offerIndexes.size() == expectCount,
+
4585  "Duplicate indexes returned?",
+
4586  __FILE__,
+
4587  line);
+
4588  expect(
+
4589  amounts.size() == expectCount,
+
4590  "Duplicate amounts returned?",
+
4591  __FILE__,
+
4592  line);
+
4593  };
+
4594 
+
4595  // There are no sell offers.
+
4596  checkOffers("nft_sell_offers", 0, false, __LINE__);
+
4597 
+
4598  // A lambda that generates sell offers.
+
4599  STAmount sellPrice = XRP(0);
+
4600  auto makeSellOffers =
+
4601  [&env, &issuer, &nftID, &sellPrice](STAmount const& limit) {
+
4602  // Save a little test time by not closing too often.
+
4603  int offerCount = 0;
+
4604  while (sellPrice < limit)
+
4605  {
+
4606  sellPrice += XRP(1);
+
4607  env(token::createOffer(issuer, nftID, sellPrice),
+
4608  txflags(tfSellNFToken));
+
4609  if (++offerCount % 10 == 0)
+
4610  env.close();
+
4611  }
+
4612  env.close();
+
4613  };
4614 
-
4615  // There are 500 sell offers.
-
4616  makeSellOffers(XRP(500));
-
4617  checkOffers("nft_sell_offers", 500, 1, __LINE__);
+
4615  // There is one sell offer.
+
4616  makeSellOffers(XRP(1));
+
4617  checkOffers("nft_sell_offers", 1, 0, __LINE__);
4618 
-
4619  // There are 501 sell offers.
-
4620  makeSellOffers(XRP(501));
-
4621  checkOffers("nft_sell_offers", 501, 2, __LINE__);
+
4619  // There are 250 sell offers.
+
4620  makeSellOffers(XRP(250));
+
4621  checkOffers("nft_sell_offers", 250, 0, __LINE__);
4622 
-
4623  // There are no buy offers.
-
4624  checkOffers("nft_buy_offers", 0, 0, __LINE__);
-
4625 
-
4626  // A lambda that generates buy offers.
-
4627  STAmount buyPrice = XRP(0);
-
4628  auto makeBuyOffers =
-
4629  [&env, &buyer, &issuer, &nftID, &buyPrice](STAmount const& limit) {
-
4630  // Save a little test time by not closing too often.
-
4631  int offerCount = 0;
-
4632  while (buyPrice < limit)
-
4633  {
-
4634  buyPrice += XRP(1);
-
4635  env(token::createOffer(buyer, nftID, buyPrice),
-
4636  token::owner(issuer));
-
4637  if (++offerCount % 10 == 0)
-
4638  env.close();
-
4639  }
-
4640  env.close();
-
4641  };
-
4642 
-
4643  // There is one buy offer;
-
4644  makeBuyOffers(XRP(1));
-
4645  checkOffers("nft_buy_offers", 1, 0, __LINE__);
-
4646 
-
4647  // There are 250 buy offers.
-
4648  makeBuyOffers(XRP(250));
-
4649  checkOffers("nft_buy_offers", 250, 0, __LINE__);
-
4650 
-
4651  // There are 251 buy offers.
-
4652  makeBuyOffers(XRP(251));
-
4653  checkOffers("nft_buy_offers", 251, 1, __LINE__);
+
4623  // There are 251 sell offers.
+
4624  makeSellOffers(XRP(251));
+
4625  checkOffers("nft_sell_offers", 251, 1, __LINE__);
+
4626 
+
4627  // There are 500 sell offers.
+
4628  makeSellOffers(XRP(500));
+
4629  checkOffers("nft_sell_offers", 500, 1, __LINE__);
+
4630 
+
4631  // There are 501 sell offers.
+
4632  makeSellOffers(XRP(501));
+
4633  checkOffers("nft_sell_offers", 501, 2, __LINE__);
+
4634 
+
4635  // There are no buy offers.
+
4636  checkOffers("nft_buy_offers", 0, 0, __LINE__);
+
4637 
+
4638  // A lambda that generates buy offers.
+
4639  STAmount buyPrice = XRP(0);
+
4640  auto makeBuyOffers =
+
4641  [&env, &buyer, &issuer, &nftID, &buyPrice](STAmount const& limit) {
+
4642  // Save a little test time by not closing too often.
+
4643  int offerCount = 0;
+
4644  while (buyPrice < limit)
+
4645  {
+
4646  buyPrice += XRP(1);
+
4647  env(token::createOffer(buyer, nftID, buyPrice),
+
4648  token::owner(issuer));
+
4649  if (++offerCount % 10 == 0)
+
4650  env.close();
+
4651  }
+
4652  env.close();
+
4653  };
4654 
-
4655  // There are 500 buy offers.
-
4656  makeBuyOffers(XRP(500));
-
4657  checkOffers("nft_buy_offers", 500, 1, __LINE__);
+
4655  // There is one buy offer;
+
4656  makeBuyOffers(XRP(1));
+
4657  checkOffers("nft_buy_offers", 1, 0, __LINE__);
4658 
-
4659  // There are 501 buy offers.
-
4660  makeBuyOffers(XRP(501));
-
4661  checkOffers("nft_buy_offers", 501, 2, __LINE__);
-
4662  }
-
4663 
-
4664  void
-
4665  testFixNFTokenNegOffer(FeatureBitset features)
-
4666  {
-
4667  // Exercise changes introduced by fixNFTokenNegOffer.
-
4668  using namespace test::jtx;
-
4669 
-
4670  testcase("fixNFTokenNegOffer");
-
4671 
-
4672  Account const issuer{"issuer"};
-
4673  Account const buyer{"buyer"};
-
4674  Account const gw{"gw"};
-
4675  IOU const gwXAU(gw["XAU"]);
-
4676 
-
4677  // Test both with and without fixNFTokenNegOffer
-
4678  for (auto const& tweakedFeatures :
-
4679  {features - fixNFTokenNegOffer - featureNonFungibleTokensV1_1,
-
4680  features | fixNFTokenNegOffer})
-
4681  {
-
4682  // There was a bug in the initial NFT implementation that
-
4683  // allowed offers to be placed with negative amounts. Verify
-
4684  // that fixNFTokenNegOffer addresses the problem.
-
4685  Env env{*this, tweakedFeatures};
-
4686 
-
4687  env.fund(XRP(1000000), issuer, buyer, gw);
-
4688  env.close();
-
4689 
-
4690  env(trust(issuer, gwXAU(2000)));
-
4691  env(trust(buyer, gwXAU(2000)));
-
4692  env.close();
-
4693 
-
4694  env(pay(gw, issuer, gwXAU(1000)));
-
4695  env(pay(gw, buyer, gwXAU(1000)));
-
4696  env.close();
-
4697 
-
4698  // Create an NFT that we'll make XRP offers for.
-
4699  uint256 const nftID0{
-
4700  token::getNextID(env, issuer, 0u, tfTransferable)};
-
4701  env(token::mint(issuer, 0), txflags(tfTransferable));
-
4702  env.close();
-
4703 
-
4704  // Create an NFT that we'll make IOU offers for.
-
4705  uint256 const nftID1{
-
4706  token::getNextID(env, issuer, 1u, tfTransferable)};
-
4707  env(token::mint(issuer, 1), txflags(tfTransferable));
+
4659  // There are 250 buy offers.
+
4660  makeBuyOffers(XRP(250));
+
4661  checkOffers("nft_buy_offers", 250, 0, __LINE__);
+
4662 
+
4663  // There are 251 buy offers.
+
4664  makeBuyOffers(XRP(251));
+
4665  checkOffers("nft_buy_offers", 251, 1, __LINE__);
+
4666 
+
4667  // There are 500 buy offers.
+
4668  makeBuyOffers(XRP(500));
+
4669  checkOffers("nft_buy_offers", 500, 1, __LINE__);
+
4670 
+
4671  // There are 501 buy offers.
+
4672  makeBuyOffers(XRP(501));
+
4673  checkOffers("nft_buy_offers", 501, 2, __LINE__);
+
4674  }
+
4675 
+
4676  void
+
4677  testFixNFTokenNegOffer(FeatureBitset features)
+
4678  {
+
4679  // Exercise changes introduced by fixNFTokenNegOffer.
+
4680  using namespace test::jtx;
+
4681 
+
4682  testcase("fixNFTokenNegOffer");
+
4683 
+
4684  Account const issuer{"issuer"};
+
4685  Account const buyer{"buyer"};
+
4686  Account const gw{"gw"};
+
4687  IOU const gwXAU(gw["XAU"]);
+
4688 
+
4689  // Test both with and without fixNFTokenNegOffer
+
4690  for (auto const& tweakedFeatures :
+
4691  {features - fixNFTokenNegOffer - featureNonFungibleTokensV1_1,
+
4692  features | fixNFTokenNegOffer})
+
4693  {
+
4694  // There was a bug in the initial NFT implementation that
+
4695  // allowed offers to be placed with negative amounts. Verify
+
4696  // that fixNFTokenNegOffer addresses the problem.
+
4697  Env env{*this, tweakedFeatures};
+
4698 
+
4699  env.fund(XRP(1000000), issuer, buyer, gw);
+
4700  env.close();
+
4701 
+
4702  env(trust(issuer, gwXAU(2000)));
+
4703  env(trust(buyer, gwXAU(2000)));
+
4704  env.close();
+
4705 
+
4706  env(pay(gw, issuer, gwXAU(1000)));
+
4707  env(pay(gw, buyer, gwXAU(1000)));
4708  env.close();
4709 
-
4710  TER const offerCreateTER = tweakedFeatures[fixNFTokenNegOffer]
-
4711  ? static_cast<TER>(temBAD_AMOUNT)
-
4712  : static_cast<TER>(tesSUCCESS);
-
4713 
-
4714  // Make offers with negative amounts for the NFTs
-
4715  uint256 const sellNegXrpOfferIndex =
-
4716  keylet::nftoffer(issuer, env.seq(issuer)).key;
-
4717  env(token::createOffer(issuer, nftID0, XRP(-2)),
-
4718  txflags(tfSellNFToken),
-
4719  ter(offerCreateTER));
+
4710  // Create an NFT that we'll make XRP offers for.
+
4711  uint256 const nftID0{
+
4712  token::getNextID(env, issuer, 0u, tfTransferable)};
+
4713  env(token::mint(issuer, 0), txflags(tfTransferable));
+
4714  env.close();
+
4715 
+
4716  // Create an NFT that we'll make IOU offers for.
+
4717  uint256 const nftID1{
+
4718  token::getNextID(env, issuer, 1u, tfTransferable)};
+
4719  env(token::mint(issuer, 1), txflags(tfTransferable));
4720  env.close();
4721 
-
4722  uint256 const sellNegIouOfferIndex =
-
4723  keylet::nftoffer(issuer, env.seq(issuer)).key;
-
4724  env(token::createOffer(issuer, nftID1, gwXAU(-2)),
-
4725  txflags(tfSellNFToken),
-
4726  ter(offerCreateTER));
-
4727  env.close();
-
4728 
-
4729  uint256 const buyNegXrpOfferIndex =
-
4730  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
4731  env(token::createOffer(buyer, nftID0, XRP(-1)),
-
4732  token::owner(issuer),
-
4733  ter(offerCreateTER));
-
4734  env.close();
-
4735 
-
4736  uint256 const buyNegIouOfferIndex =
-
4737  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
4738  env(token::createOffer(buyer, nftID1, gwXAU(-1)),
-
4739  token::owner(issuer),
-
4740  ter(offerCreateTER));
-
4741  env.close();
-
4742 
-
4743  {
-
4744  // Now try to accept the offers.
-
4745  // 1. If fixNFTokenNegOffer is NOT enabled get tecINTERNAL.
-
4746  // 2. If fixNFTokenNegOffer IS enabled get tecOBJECT_NOT_FOUND.
-
4747  TER const offerAcceptTER = tweakedFeatures[fixNFTokenNegOffer]
-
4748  ? static_cast<TER>(tecOBJECT_NOT_FOUND)
-
4749  : static_cast<TER>(tecINTERNAL);
-
4750 
-
4751  // Sell offers.
-
4752  env(token::acceptSellOffer(buyer, sellNegXrpOfferIndex),
-
4753  ter(offerAcceptTER));
-
4754  env.close();
-
4755  env(token::acceptSellOffer(buyer, sellNegIouOfferIndex),
-
4756  ter(offerAcceptTER));
-
4757  env.close();
-
4758 
-
4759  // Buy offers.
-
4760  env(token::acceptBuyOffer(issuer, buyNegXrpOfferIndex),
-
4761  ter(offerAcceptTER));
-
4762  env.close();
-
4763  env(token::acceptBuyOffer(issuer, buyNegIouOfferIndex),
-
4764  ter(offerAcceptTER));
-
4765  env.close();
-
4766  }
-
4767  {
-
4768  // 1. If fixNFTokenNegOffer is NOT enabled get tecSUCCESS.
-
4769  // 2. If fixNFTokenNegOffer IS enabled get tecOBJECT_NOT_FOUND.
-
4770  TER const offerAcceptTER = tweakedFeatures[fixNFTokenNegOffer]
-
4771  ? static_cast<TER>(tecOBJECT_NOT_FOUND)
-
4772  : static_cast<TER>(tesSUCCESS);
-
4773 
-
4774  // Brokered offers.
-
4775  env(token::brokerOffers(
-
4776  gw, buyNegXrpOfferIndex, sellNegXrpOfferIndex),
-
4777  ter(offerAcceptTER));
-
4778  env.close();
-
4779  env(token::brokerOffers(
-
4780  gw, buyNegIouOfferIndex, sellNegIouOfferIndex),
-
4781  ter(offerAcceptTER));
-
4782  env.close();
-
4783  }
-
4784  }
+
4722  TER const offerCreateTER = tweakedFeatures[fixNFTokenNegOffer]
+
4723  ? static_cast<TER>(temBAD_AMOUNT)
+
4724  : static_cast<TER>(tesSUCCESS);
+
4725 
+
4726  // Make offers with negative amounts for the NFTs
+
4727  uint256 const sellNegXrpOfferIndex =
+
4728  keylet::nftoffer(issuer, env.seq(issuer)).key;
+
4729  env(token::createOffer(issuer, nftID0, XRP(-2)),
+
4730  txflags(tfSellNFToken),
+
4731  ter(offerCreateTER));
+
4732  env.close();
+
4733 
+
4734  uint256 const sellNegIouOfferIndex =
+
4735  keylet::nftoffer(issuer, env.seq(issuer)).key;
+
4736  env(token::createOffer(issuer, nftID1, gwXAU(-2)),
+
4737  txflags(tfSellNFToken),
+
4738  ter(offerCreateTER));
+
4739  env.close();
+
4740 
+
4741  uint256 const buyNegXrpOfferIndex =
+
4742  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
4743  env(token::createOffer(buyer, nftID0, XRP(-1)),
+
4744  token::owner(issuer),
+
4745  ter(offerCreateTER));
+
4746  env.close();
+
4747 
+
4748  uint256 const buyNegIouOfferIndex =
+
4749  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
4750  env(token::createOffer(buyer, nftID1, gwXAU(-1)),
+
4751  token::owner(issuer),
+
4752  ter(offerCreateTER));
+
4753  env.close();
+
4754 
+
4755  {
+
4756  // Now try to accept the offers.
+
4757  // 1. If fixNFTokenNegOffer is NOT enabled get tecINTERNAL.
+
4758  // 2. If fixNFTokenNegOffer IS enabled get tecOBJECT_NOT_FOUND.
+
4759  TER const offerAcceptTER = tweakedFeatures[fixNFTokenNegOffer]
+
4760  ? static_cast<TER>(tecOBJECT_NOT_FOUND)
+
4761  : static_cast<TER>(tecINTERNAL);
+
4762 
+
4763  // Sell offers.
+
4764  env(token::acceptSellOffer(buyer, sellNegXrpOfferIndex),
+
4765  ter(offerAcceptTER));
+
4766  env.close();
+
4767  env(token::acceptSellOffer(buyer, sellNegIouOfferIndex),
+
4768  ter(offerAcceptTER));
+
4769  env.close();
+
4770 
+
4771  // Buy offers.
+
4772  env(token::acceptBuyOffer(issuer, buyNegXrpOfferIndex),
+
4773  ter(offerAcceptTER));
+
4774  env.close();
+
4775  env(token::acceptBuyOffer(issuer, buyNegIouOfferIndex),
+
4776  ter(offerAcceptTER));
+
4777  env.close();
+
4778  }
+
4779  {
+
4780  // 1. If fixNFTokenNegOffer is NOT enabled get tecSUCCESS.
+
4781  // 2. If fixNFTokenNegOffer IS enabled get tecOBJECT_NOT_FOUND.
+
4782  TER const offerAcceptTER = tweakedFeatures[fixNFTokenNegOffer]
+
4783  ? static_cast<TER>(tecOBJECT_NOT_FOUND)
+
4784  : static_cast<TER>(tesSUCCESS);
4785 
-
4786  // Test what happens if NFTokenOffers are created with negative amounts
-
4787  // and then fixNFTokenNegOffer goes live. What does an acceptOffer do?
-
4788  {
-
4789  Env env{
-
4790  *this,
-
4791  features - fixNFTokenNegOffer - featureNonFungibleTokensV1_1};
-
4792 
-
4793  env.fund(XRP(1000000), issuer, buyer, gw);
-
4794  env.close();
-
4795 
-
4796  env(trust(issuer, gwXAU(2000)));
-
4797  env(trust(buyer, gwXAU(2000)));
-
4798  env.close();
-
4799 
-
4800  env(pay(gw, issuer, gwXAU(1000)));
-
4801  env(pay(gw, buyer, gwXAU(1000)));
-
4802  env.close();
-
4803 
-
4804  // Create an NFT that we'll make XRP offers for.
-
4805  uint256 const nftID0{
-
4806  token::getNextID(env, issuer, 0u, tfTransferable)};
-
4807  env(token::mint(issuer, 0), txflags(tfTransferable));
-
4808  env.close();
-
4809 
-
4810  // Create an NFT that we'll make IOU offers for.
-
4811  uint256 const nftID1{
-
4812  token::getNextID(env, issuer, 1u, tfTransferable)};
-
4813  env(token::mint(issuer, 1), txflags(tfTransferable));
+
4786  // Brokered offers.
+
4787  env(token::brokerOffers(
+
4788  gw, buyNegXrpOfferIndex, sellNegXrpOfferIndex),
+
4789  ter(offerAcceptTER));
+
4790  env.close();
+
4791  env(token::brokerOffers(
+
4792  gw, buyNegIouOfferIndex, sellNegIouOfferIndex),
+
4793  ter(offerAcceptTER));
+
4794  env.close();
+
4795  }
+
4796  }
+
4797 
+
4798  // Test what happens if NFTokenOffers are created with negative amounts
+
4799  // and then fixNFTokenNegOffer goes live. What does an acceptOffer do?
+
4800  {
+
4801  Env env{
+
4802  *this,
+
4803  features - fixNFTokenNegOffer - featureNonFungibleTokensV1_1};
+
4804 
+
4805  env.fund(XRP(1000000), issuer, buyer, gw);
+
4806  env.close();
+
4807 
+
4808  env(trust(issuer, gwXAU(2000)));
+
4809  env(trust(buyer, gwXAU(2000)));
+
4810  env.close();
+
4811 
+
4812  env(pay(gw, issuer, gwXAU(1000)));
+
4813  env(pay(gw, buyer, gwXAU(1000)));
4814  env.close();
4815 
-
4816  // Make offers with negative amounts for the NFTs
-
4817  uint256 const sellNegXrpOfferIndex =
-
4818  keylet::nftoffer(issuer, env.seq(issuer)).key;
-
4819  env(token::createOffer(issuer, nftID0, XRP(-2)),
-
4820  txflags(tfSellNFToken));
-
4821  env.close();
-
4822 
-
4823  uint256 const sellNegIouOfferIndex =
-
4824  keylet::nftoffer(issuer, env.seq(issuer)).key;
-
4825  env(token::createOffer(issuer, nftID1, gwXAU(-2)),
-
4826  txflags(tfSellNFToken));
-
4827  env.close();
-
4828 
-
4829  uint256 const buyNegXrpOfferIndex =
-
4830  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
4831  env(token::createOffer(buyer, nftID0, XRP(-1)),
-
4832  token::owner(issuer));
+
4816  // Create an NFT that we'll make XRP offers for.
+
4817  uint256 const nftID0{
+
4818  token::getNextID(env, issuer, 0u, tfTransferable)};
+
4819  env(token::mint(issuer, 0), txflags(tfTransferable));
+
4820  env.close();
+
4821 
+
4822  // Create an NFT that we'll make IOU offers for.
+
4823  uint256 const nftID1{
+
4824  token::getNextID(env, issuer, 1u, tfTransferable)};
+
4825  env(token::mint(issuer, 1), txflags(tfTransferable));
+
4826  env.close();
+
4827 
+
4828  // Make offers with negative amounts for the NFTs
+
4829  uint256 const sellNegXrpOfferIndex =
+
4830  keylet::nftoffer(issuer, env.seq(issuer)).key;
+
4831  env(token::createOffer(issuer, nftID0, XRP(-2)),
+
4832  txflags(tfSellNFToken));
4833  env.close();
4834 
-
4835  uint256 const buyNegIouOfferIndex =
-
4836  keylet::nftoffer(buyer, env.seq(buyer)).key;
-
4837  env(token::createOffer(buyer, nftID1, gwXAU(-1)),
-
4838  token::owner(issuer));
+
4835  uint256 const sellNegIouOfferIndex =
+
4836  keylet::nftoffer(issuer, env.seq(issuer)).key;
+
4837  env(token::createOffer(issuer, nftID1, gwXAU(-2)),
+
4838  txflags(tfSellNFToken));
4839  env.close();
4840 
-
4841  // Now the amendment passes.
-
4842  env.enableFeature(fixNFTokenNegOffer);
-
4843  env.close();
-
4844 
-
4845  // All attempts to accept the offers with negative amounts
-
4846  // should fail with temBAD_OFFER.
-
4847  env(token::acceptSellOffer(buyer, sellNegXrpOfferIndex),
-
4848  ter(temBAD_OFFER));
-
4849  env.close();
-
4850  env(token::acceptSellOffer(buyer, sellNegIouOfferIndex),
-
4851  ter(temBAD_OFFER));
-
4852  env.close();
-
4853 
-
4854  // Buy offers.
-
4855  env(token::acceptBuyOffer(issuer, buyNegXrpOfferIndex),
-
4856  ter(temBAD_OFFER));
-
4857  env.close();
-
4858  env(token::acceptBuyOffer(issuer, buyNegIouOfferIndex),
-
4859  ter(temBAD_OFFER));
-
4860  env.close();
-
4861 
-
4862  // Brokered offers.
-
4863  env(token::brokerOffers(
-
4864  gw, buyNegXrpOfferIndex, sellNegXrpOfferIndex),
-
4865  ter(temBAD_OFFER));
-
4866  env.close();
-
4867  env(token::brokerOffers(
-
4868  gw, buyNegIouOfferIndex, sellNegIouOfferIndex),
-
4869  ter(temBAD_OFFER));
-
4870  env.close();
-
4871  }
-
4872 
-
4873  // Test buy offers with a destination with and without
-
4874  // fixNFTokenNegOffer.
-
4875  for (auto const& tweakedFeatures :
-
4876  {features - fixNFTokenNegOffer - featureNonFungibleTokensV1_1,
-
4877  features | fixNFTokenNegOffer})
-
4878  {
-
4879  Env env{*this, tweakedFeatures};
-
4880 
-
4881  env.fund(XRP(1000000), issuer, buyer);
-
4882 
-
4883  // Create an NFT that we'll make offers for.
-
4884  uint256 const nftID{
-
4885  token::getNextID(env, issuer, 0u, tfTransferable)};
-
4886  env(token::mint(issuer, 0), txflags(tfTransferable));
-
4887  env.close();
-
4888 
-
4889  TER const offerCreateTER = tweakedFeatures[fixNFTokenNegOffer]
-
4890  ? static_cast<TER>(tesSUCCESS)
-
4891  : static_cast<TER>(temMALFORMED);
+
4841  uint256 const buyNegXrpOfferIndex =
+
4842  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
4843  env(token::createOffer(buyer, nftID0, XRP(-1)),
+
4844  token::owner(issuer));
+
4845  env.close();
+
4846 
+
4847  uint256 const buyNegIouOfferIndex =
+
4848  keylet::nftoffer(buyer, env.seq(buyer)).key;
+
4849  env(token::createOffer(buyer, nftID1, gwXAU(-1)),
+
4850  token::owner(issuer));
+
4851  env.close();
+
4852 
+
4853  // Now the amendment passes.
+
4854  env.enableFeature(fixNFTokenNegOffer);
+
4855  env.close();
+
4856 
+
4857  // All attempts to accept the offers with negative amounts
+
4858  // should fail with temBAD_OFFER.
+
4859  env(token::acceptSellOffer(buyer, sellNegXrpOfferIndex),
+
4860  ter(temBAD_OFFER));
+
4861  env.close();
+
4862  env(token::acceptSellOffer(buyer, sellNegIouOfferIndex),
+
4863  ter(temBAD_OFFER));
+
4864  env.close();
+
4865 
+
4866  // Buy offers.
+
4867  env(token::acceptBuyOffer(issuer, buyNegXrpOfferIndex),
+
4868  ter(temBAD_OFFER));
+
4869  env.close();
+
4870  env(token::acceptBuyOffer(issuer, buyNegIouOfferIndex),
+
4871  ter(temBAD_OFFER));
+
4872  env.close();
+
4873 
+
4874  // Brokered offers.
+
4875  env(token::brokerOffers(
+
4876  gw, buyNegXrpOfferIndex, sellNegXrpOfferIndex),
+
4877  ter(temBAD_OFFER));
+
4878  env.close();
+
4879  env(token::brokerOffers(
+
4880  gw, buyNegIouOfferIndex, sellNegIouOfferIndex),
+
4881  ter(temBAD_OFFER));
+
4882  env.close();
+
4883  }
+
4884 
+
4885  // Test buy offers with a destination with and without
+
4886  // fixNFTokenNegOffer.
+
4887  for (auto const& tweakedFeatures :
+
4888  {features - fixNFTokenNegOffer - featureNonFungibleTokensV1_1,
+
4889  features | fixNFTokenNegOffer})
+
4890  {
+
4891  Env env{*this, tweakedFeatures};
4892 
-
4893  env(token::createOffer(buyer, nftID, drops(1)),
-
4894  token::owner(issuer),
-
4895  token::destination(issuer),
-
4896  ter(offerCreateTER));
-
4897  env.close();
-
4898  }
-
4899  }
+
4893  env.fund(XRP(1000000), issuer, buyer);
+
4894 
+
4895  // Create an NFT that we'll make offers for.
+
4896  uint256 const nftID{
+
4897  token::getNextID(env, issuer, 0u, tfTransferable)};
+
4898  env(token::mint(issuer, 0), txflags(tfTransferable));
+
4899  env.close();
4900 
-
4901  void
-
4902  testWithFeats(FeatureBitset features)
-
4903  {
-
4904  testEnabled(features);
-
4905  testMintReserve(features);
-
4906  testMintMaxTokens(features);
-
4907  testMintInvalid(features);
-
4908  testBurnInvalid(features);
-
4909  testCreateOfferInvalid(features);
-
4910  testCancelOfferInvalid(features);
-
4911  testAcceptOfferInvalid(features);
-
4912  testMintFlagBurnable(features);
-
4913  testMintFlagOnlyXRP(features);
-
4914  testMintFlagCreateTrustLine(features);
-
4915  testMintFlagTransferable(features);
-
4916  testMintTransferFee(features);
-
4917  testMintTaxon(features);
-
4918  testMintURI(features);
-
4919  testCreateOfferDestination(features);
-
4920  testCreateOfferExpiration(features);
-
4921  testCancelOffers(features);
-
4922  testCancelTooManyOffers(features);
-
4923  testBrokeredAccept(features);
-
4924  testNFTokenOfferOwner(features);
-
4925  testNFTokenWithTickets(features);
-
4926  testNFTokenDeleteAccount(features);
-
4927  testNftXxxOffers(features);
-
4928  testFixNFTokenNegOffer(features);
-
4929  }
-
4930 
-
4931 public:
-
4932  void
-
4933  run() override
-
4934  {
-
4935  using namespace test::jtx;
-
4936  FeatureBitset const all{supported_amendments()};
-
4937  FeatureBitset const fixNFTDir{fixNFTokenDirV1};
-
4938 
-
4939  testWithFeats(all - fixNFTDir);
-
4940  testWithFeats(all);
+
4901  TER const offerCreateTER = tweakedFeatures[fixNFTokenNegOffer]
+
4902  ? static_cast<TER>(tesSUCCESS)
+
4903  : static_cast<TER>(temMALFORMED);
+
4904 
+
4905  env(token::createOffer(buyer, nftID, drops(1)),
+
4906  token::owner(issuer),
+
4907  token::destination(issuer),
+
4908  ter(offerCreateTER));
+
4909  env.close();
+
4910  }
+
4911  }
+
4912 
+
4913  void
+
4914  testWithFeats(FeatureBitset features)
+
4915  {
+
4916  testEnabled(features);
+
4917  testMintReserve(features);
+
4918  testMintMaxTokens(features);
+
4919  testMintInvalid(features);
+
4920  testBurnInvalid(features);
+
4921  testCreateOfferInvalid(features);
+
4922  testCancelOfferInvalid(features);
+
4923  testAcceptOfferInvalid(features);
+
4924  testMintFlagBurnable(features);
+
4925  testMintFlagOnlyXRP(features);
+
4926  testMintFlagCreateTrustLine(features);
+
4927  testMintFlagTransferable(features);
+
4928  testMintTransferFee(features);
+
4929  testMintTaxon(features);
+
4930  testMintURI(features);
+
4931  testCreateOfferDestination(features);
+
4932  testCreateOfferExpiration(features);
+
4933  testCancelOffers(features);
+
4934  testCancelTooManyOffers(features);
+
4935  testBrokeredAccept(features);
+
4936  testNFTokenOfferOwner(features);
+
4937  testNFTokenWithTickets(features);
+
4938  testNFTokenDeleteAccount(features);
+
4939  testNftXxxOffers(features);
+
4940  testFixNFTokenNegOffer(features);
4941  }
-
4942 };
-
4943 
-
4944 BEAST_DEFINE_TESTSUITE_PRIO(NFToken, tx, ripple, 2);
-
4945 
-
4946 } // namespace ripple
+
4942 
+
4943 public:
+
4944  void
+
4945  run() override
+
4946  {
+
4947  using namespace test::jtx;
+
4948  FeatureBitset const all{supported_amendments()};
+
4949  FeatureBitset const fixNFTDir{fixNFTokenDirV1};
+
4950 
+
4951  testWithFeats(all - fixNFTDir);
+
4952  testWithFeats(all);
+
4953  }
+
4954 };
+
4955 
+
4956 BEAST_DEFINE_TESTSUITE_PRIO(NFToken, tx, ripple, 2);
+
4957 
+
4958 } // namespace ripple
-
ripple::NFToken_test::testNFTokenDeleteAccount
void testNFTokenDeleteAccount(FeatureBitset features)
Definition: NFToken_test.cpp:4343
+
ripple::NFToken_test::testNFTokenDeleteAccount
void testNFTokenDeleteAccount(FeatureBitset features)
Definition: NFToken_test.cpp:4355
ripple::tecUNFUNDED_OFFER
@ tecUNFUNDED_OFFER
Definition: TER.h:248
ripple::maxTransferFee
constexpr std::uint16_t maxTransferFee
The maximum token transfer fee allowed.
Definition: Protocol.h:81
ripple::sfOwnerCount
const SF_UINT32 sfOwnerCount
@@ -5025,7 +5037,7 @@ $(function() {
ripple::NFToken_test::testBurnInvalid
void testBurnInvalid(FeatureBitset features)
Definition: NFToken_test.cpp:576
ripple::tecOBJECT_NOT_FOUND
@ tecOBJECT_NOT_FOUND
Definition: TER.h:290
ripple::tecFROZEN
@ tecFROZEN
Definition: TER.h:267
-
ripple::NFToken_test::testMintFlagBurnable
void testMintFlagBurnable(FeatureBitset features)
Definition: NFToken_test.cpp:1358
+
ripple::NFToken_test::testMintFlagBurnable
void testMintFlagBurnable(FeatureBitset features)
Definition: NFToken_test.cpp:1370
ripple::NFToken_test::testCreateOfferInvalid
void testCreateOfferInvalid(FeatureBitset features)
Definition: NFToken_test.cpp:636
ripple::tfTransferable
constexpr const std::uint32_t tfTransferable
Definition: TxFlags.h:121
ripple::fixNFTokenNegOffer
const uint256 fixNFTokenNegOffer
@@ -5034,8 +5046,8 @@ $(function() {
ripple::temBAD_OFFER
@ temBAD_OFFER
Definition: TER.h:90
ripple::STAmount::cMinValue
static const std::uint64_t cMinValue
Definition: STAmount.h:65
ripple::NFToken_test::testMintReserve
void testMintReserve(FeatureBitset features)
Definition: NFToken_test.cpp:204
-
ripple::NFToken_test::testCreateOfferExpiration
void testCreateOfferExpiration(FeatureBitset features)
Definition: NFToken_test.cpp:2967
-
ripple::NFToken_test::testNFTokenOfferOwner
void testNFTokenOfferOwner(FeatureBitset features)
Definition: NFToken_test.cpp:4176
+
ripple::NFToken_test::testCreateOfferExpiration
void testCreateOfferExpiration(FeatureBitset features)
Definition: NFToken_test.cpp:2979
+
ripple::NFToken_test::testNFTokenOfferOwner
void testNFTokenOfferOwner(FeatureBitset features)
Definition: NFToken_test.cpp:4188
ripple::sfNFTokenOffers
const SF_VECTOR256 sfNFTokenOffers
Json::arrayValue
@ arrayValue
array value (ordered list)
Definition: json_value.h:42
ripple::tecINSUFFICIENT_FUNDS
@ tecINSUFFICIENT_FUNDS
Definition: TER.h:289
@@ -5049,38 +5061,38 @@ $(function() {
ripple::keylet::nftoffer
Keylet nftoffer(AccountID const &owner, std::uint32_t seq)
An offer from an account to buy or sell an NFT.
Definition: Indexes.cpp:355
ripple::test::jtx::Account::human
std::string const & human() const
Returns the human readable public key.
Definition: Account.h:113
-
ripple::NFToken_test::testCancelTooManyOffers
void testCancelTooManyOffers(FeatureBitset features)
Definition: NFToken_test.cpp:3555
+
ripple::NFToken_test::testCancelTooManyOffers
void testCancelTooManyOffers(FeatureBitset features)
Definition: NFToken_test.cpp:3567
ripple::STAmount::cMinOffset
static const int cMinOffset
Definition: STAmount.h:61
ripple::NFToken_test::ownerCount
static std::uint32_t ownerCount(test::jtx::Env const &env, test::jtx::Account const &acct)
Definition: NFToken_test.cpp:34
ripple::tecCANT_ACCEPT_OWN_NFTOKEN_OFFER
@ tecCANT_ACCEPT_OWN_NFTOKEN_OFFER
Definition: TER.h:288
ripple::nft::toTaxon
Taxon toTaxon(std::uint32_t i)
Definition: NFTokenUtils.h:40
ripple::BEAST_DEFINE_TESTSUITE_PRIO
BEAST_DEFINE_TESTSUITE_PRIO(NFToken, tx, ripple, 2)
-
ripple::NFToken_test::testMintFlagOnlyXRP
void testMintFlagOnlyXRP(FeatureBitset features)
Definition: NFToken_test.cpp:1476
+
ripple::NFToken_test::testMintFlagOnlyXRP
void testMintFlagOnlyXRP(FeatureBitset features)
Definition: NFToken_test.cpp:1488
ripple::NFToken_test::testAcceptOfferInvalid
void testAcceptOfferInvalid(FeatureBitset features)
Definition: NFToken_test.cpp:1006
ripple::SField::jsonName
const Json::StaticString jsonName
Definition: SField.h:136
std::sort
T sort(T... args)
std::string::clear
T clear(T... args)
ripple::NFToken_test::ticketCount
static std::uint32_t ticketCount(test::jtx::Env const &env, test::jtx::Account const &acct)
Definition: NFToken_test.cpp:75
std::string::push_back
T push_back(T... args)
-
ripple::NFToken_test::testCancelOffers
void testCancelOffers(FeatureBitset features)
Definition: NFToken_test.cpp:3441
+
ripple::NFToken_test::testCancelOffers
void testCancelOffers(FeatureBitset features)
Definition: NFToken_test.cpp:3453
ripple::Keylet::key
uint256 key
Definition: Keylet.h:40
ripple::base_uint< 256 >
-
ripple::NFToken_test::testWithFeats
void testWithFeats(FeatureBitset features)
Definition: NFToken_test.cpp:4902
+
ripple::NFToken_test::testWithFeats
void testWithFeats(FeatureBitset features)
Definition: NFToken_test.cpp:4914
ripple::temINVALID_FLAG
@ temINVALID_FLAG
Definition: TER.h:106
ripple::tecNFTOKEN_OFFER_TYPE_MISMATCH
@ tecNFTOKEN_OFFER_TYPE_MISMATCH
Definition: TER.h:287
Json::Value::append
Value & append(const Value &value)
Append value to array at the end.
Definition: json_value.cpp:882
-
ripple::NFToken_test::testFixNFTokenNegOffer
void testFixNFTokenNegOffer(FeatureBitset features)
Definition: NFToken_test.cpp:4665
+
ripple::NFToken_test::testFixNFTokenNegOffer
void testFixNFTokenNegOffer(FeatureBitset features)
Definition: NFToken_test.cpp:4677
ripple::rand_int
std::enable_if_t< std::is_integral< Integral >::value &&detail::is_engine< Engine >::value, Integral > rand_int(Engine &engine, Integral min, Integral max)
Return a uniformly distributed random integer.
Definition: ripple/basics/random.h:115
ripple::tfBurnable
constexpr const std::uint32_t tfBurnable
Definition: TxFlags.h:118
ripple::keylet::account
Keylet account(AccountID const &id) noexcept
AccountID root.
Definition: Indexes.cpp:133
ripple::tefNFTOKEN_IS_NOT_TRANSFERABLE
@ tefNFTOKEN_IS_NOT_TRANSFERABLE
Definition: TER.h:165
ripple::sfNFTokenMinter
const SF_ACCOUNT sfNFTokenMinter
-
ripple::NFToken_test::run
void run() override
Definition: NFToken_test.cpp:4933
+
ripple::NFToken_test::run
void run() override
Definition: NFToken_test.cpp:4945
-
ripple::NFToken_test::testNftXxxOffers
void testNftXxxOffers(FeatureBitset features)
Definition: NFToken_test.cpp:4436
+
ripple::NFToken_test::testNftXxxOffers
void testNftXxxOffers(FeatureBitset features)
Definition: NFToken_test.cpp:4448
ripple::NFToken_test::mintedCount
static std::uint32_t mintedCount(test::jtx::Env const &env, test::jtx::Account const &issuer)
Definition: NFToken_test.cpp:44
-
ripple::NFToken_test::testMintTaxon
void testMintTaxon(FeatureBitset features)
Definition: NFToken_test.cpp:2483
+
ripple::NFToken_test::testMintTaxon
void testMintTaxon(FeatureBitset features)
Definition: NFToken_test.cpp:2495
ripple::TER
TERSubset< CanCvtToTER > TER
Definition: TER.h:565
std::to_string
T to_string(T... args)
ripple::rand_byte
std::enable_if_t<(std::is_same< Byte, unsigned char >::value||std::is_same< Byte, std::uint8_t >::value) &&detail::is_engine< Engine >::value, Byte > rand_byte(Engine &engine)
Return a random byte.
Definition: ripple/basics/random.h:173
@@ -5098,11 +5110,11 @@ $(function() {
ripple::NFToken_test
Definition: NFToken_test.cpp:30
ripple::NFToken_test::burnedCount
static std::uint32_t burnedCount(test::jtx::Env const &env, test::jtx::Account const &issuer)
Definition: NFToken_test.cpp:54
-
ripple::NFToken_test::testMintTransferFee
void testMintTransferFee(FeatureBitset features)
Definition: NFToken_test.cpp:2052
+
ripple::NFToken_test::testMintTransferFee
void testMintTransferFee(FeatureBitset features)
Definition: NFToken_test.cpp:2064
ripple::fixNFTokenDirV1
const uint256 fixNFTokenDirV1
ripple::temBAD_FEE
@ temBAD_FEE
Definition: TER.h:87
ripple::maxTokenURILength
constexpr std::size_t maxTokenURILength
The maximum length of a URI inside an NFT.
Definition: Protocol.h:84
-
ripple::NFToken_test::testMintFlagTransferable
void testMintFlagTransferable(FeatureBitset features)
Definition: NFToken_test.cpp:1762
+
ripple::NFToken_test::testMintFlagTransferable
void testMintFlagTransferable(FeatureBitset features)
Definition: NFToken_test.cpp:1774
ripple::sfURI
const SF_VL sfURI
ripple::NFToken_test::testCancelOfferInvalid
void testCancelOfferInvalid(FeatureBitset features)
Definition: NFToken_test.cpp:886
std::vector::emplace_back
T emplace_back(T... args)
@@ -5111,7 +5123,7 @@ $(function() {
Json::Value::removeMember
Value removeMember(const char *key)
Remove and return the named member.
Definition: json_value.cpp:907
ripple::tecNFTOKEN_BUY_SELL_MISMATCH
@ tecNFTOKEN_BUY_SELL_MISMATCH
Definition: TER.h:286
ripple::tecINSUFFICIENT_PAYMENT
@ tecINSUFFICIENT_PAYMENT
Definition: TER.h:291
-
ripple::NFToken_test::testBrokeredAccept
void testBrokeredAccept(FeatureBitset features)
Definition: NFToken_test.cpp:3674
+
ripple::NFToken_test::testBrokeredAccept
void testBrokeredAccept(FeatureBitset features)
Definition: NFToken_test.cpp:3686
ripple::tfSetFreeze
constexpr std::uint32_t tfSetFreeze
Definition: TxFlags.h:102
ripple::tecNO_LINE
@ tecNO_LINE
Definition: TER.h:265
ripple::tecEXPIRED
@ tecEXPIRED
Definition: TER.h:278
@@ -5126,10 +5138,10 @@ $(function() {
ripple::tecNO_PERMISSION
@ tecNO_PERMISSION
Definition: TER.h:269
ripple::NFToken_test::testEnabled
void testEnabled(FeatureBitset features)
Definition: NFToken_test.cpp:91
-
ripple::NFToken_test::testMintFlagCreateTrustLine
void testMintFlagCreateTrustLine(FeatureBitset features)
Definition: NFToken_test.cpp:1570
+
ripple::NFToken_test::testMintFlagCreateTrustLine
void testMintFlagCreateTrustLine(FeatureBitset features)
Definition: NFToken_test.cpp:1582
ripple::tecINSUFFICIENT_RESERVE
@ tecINSUFFICIENT_RESERVE
Definition: TER.h:271
std::string::empty
T empty(T... args)
-
ripple::NFToken_test::testNFTokenWithTickets
void testNFTokenWithTickets(FeatureBitset features)
Definition: NFToken_test.cpp:4257
+
ripple::NFToken_test::testNFTokenWithTickets
void testNFTokenWithTickets(FeatureBitset features)
Definition: NFToken_test.cpp:4269
ripple::OpenView::read
std::shared_ptr< SLE const > read(Keylet const &k) const override
Return the state item associated with a key.
Definition: OpenView.cpp:171
ripple::tfTrustLine
constexpr const std::uint32_t tfTrustLine
Definition: TxFlags.h:120
@@ -5149,9 +5161,9 @@ $(function() {
ripple::sfBurnedNFTokens
const SF_UINT32 sfBurnedNFTokens
ripple::keylet::check
Keylet check(AccountID const &id, std::uint32_t seq) noexcept
A Check.
Definition: Indexes.cpp:281
ripple::nft::getTaxon
Taxon getTaxon(uint256 const &id)
Definition: NFTokenUtils.h:164
-
ripple::NFToken_test::testMintURI
void testMintURI(FeatureBitset features)
Definition: NFToken_test.cpp:2556
+
ripple::NFToken_test::testMintURI
void testMintURI(FeatureBitset features)
Definition: NFToken_test.cpp:2568
ripple::tesSUCCESS
@ tesSUCCESS
Definition: TER.h:219
-
ripple::NFToken_test::testCreateOfferDestination
void testCreateOfferDestination(FeatureBitset features)
Definition: NFToken_test.cpp:2666
+
ripple::NFToken_test::testCreateOfferDestination
void testCreateOfferDestination(FeatureBitset features)
Definition: NFToken_test.cpp:2678
ripple::temBAD_NFTOKEN_TRANSFER_FEE
@ temBAD_NFTOKEN_TRANSFER_FEE
Definition: TER.h:122
ripple::sfNFTokenSellOffer
const SF_UINT256 sfNFTokenSellOffer
diff --git a/STTx_8cpp_source.html b/STTx_8cpp_source.html index b24c5765bb..c97e450420 100644 --- a/STTx_8cpp_source.html +++ b/STTx_8cpp_source.html @@ -688,7 +688,7 @@ $(function() {
ripple::isPseudoTx
bool isPseudoTx(STObject const &tx)
Check whether a transaction is a pseudo-transaction.
Definition: STTx.cpp:559
ripple::getSigningData
static Blob getSigningData(STTx const &that)
Definition: STTx.cpp:155
ripple::ttUNL_MODIFY
@ ttUNL_MODIFY
This system-generated transaction type is used to update the network's negative UNL.
Definition: TxFormats.h:158
- +
ripple::sfMemos
const SField sfMemos
ripple::passesLocalChecks
bool passesLocalChecks(STObject const &st, std::string &reason)
Definition: STTx.cpp:530
ripple::STBase::emplace
static STBase * emplace(std::size_t n, void *buf, T &&val)
Definition: STBase.h:165
diff --git a/STTx_8h_source.html b/STTx_8h_source.html index 722e7968e5..1495daddf9 100644 --- a/STTx_8h_source.html +++ b/STTx_8h_source.html @@ -271,7 +271,7 @@ $(function() {
ripple::base_uint< 256 >
ripple::isPseudoTx
bool isPseudoTx(STObject const &tx)
Check whether a transaction is a pseudo-transaction.
Definition: STTx.cpp:559
- +
ripple::txnSqlUnknown
@ txnSqlUnknown
Definition: STTx.h:42
ripple::featureExpandedSignerList
const uint256 featureExpandedSignerList
ripple::passesLocalChecks
bool passesLocalChecks(STObject const &st, std::string &reason)
Definition: STTx.cpp:530
diff --git a/SignerEntries_8h_source.html b/SignerEntries_8h_source.html index c70cb6d754..6ca9b1a2eb 100644 --- a/SignerEntries_8h_source.html +++ b/SignerEntries_8h_source.html @@ -157,7 +157,7 @@ $(function() {
ripple::base_uint< 160, detail::AccountIDTag >
- +
ripple::SignerEntries::SignerEntry::operator==
friend bool operator==(SignerEntry const &lhs, SignerEntry const &rhs)
Definition: SignerEntries.h:65
diff --git a/base__uint_8h_source.html b/base__uint_8h_source.html index 41cd73cb71..c620b0ee8c 100644 --- a/base__uint_8h_source.html +++ b/base__uint_8h_source.html @@ -778,7 +778,7 @@ $(function() {
ripple::base_uint::operator|=
base_uint & operator|=(const base_uint &b)
Definition: base_uint.h:387
ripple::base_uint::VoidHelper::VoidHelper
VoidHelper()=default
- +
ripple::operator+
const base_uint< Bits, Tag > operator+(base_uint< Bits, Tag > const &a, base_uint< Bits, Tag > const &b)
Definition: base_uint.h:649
ripple::base_uint::bytes
static constexpr std::size_t bytes
Definition: base_uint.h:104
ripple::base_uint::data_
std::array< std::uint32_t, WIDTH > data_
Definition: base_uint.h:96
diff --git a/classripple_1_1Expected-members.html b/classripple_1_1Expected-members.html index 4a88977058..d153058cb1 100644 --- a/classripple_1_1Expected-members.html +++ b/classripple_1_1Expected-members.html @@ -75,8 +75,8 @@ $(function() { Base typedefripple::Expected< T, E >private error() constripple::Expected< T, E > error()ripple::Expected< T, E > - Expected(U r)ripple::Expected< T, E > - Expected(Unexpected< U > e)ripple::Expected< T, E > + Expected(U &&r)ripple::Expected< T, E > + Expected(Unexpected< U > e)ripple::Expected< T, E > has_value() constripple::Expected< T, E > operator bool() constripple::Expected< T, E >explicit operator*()ripple::Expected< T, E > diff --git a/classripple_1_1Expected.html b/classripple_1_1Expected.html index 0506653ced..fbbad69856 100644 --- a/classripple_1_1Expected.html +++ b/classripple_1_1Expected.html @@ -94,12 +94,12 @@ Collaboration diagram for ripple::Expected< T, E >: - - - - - - + + + + + + @@ -131,7 +131,7 @@ Private Types class ripple::Expected< T, E > -

Definition at line 129 of file Expected.h.

+

Definition at line 132 of file Expected.h.

Member Typedef Documentation

◆ Base

@@ -155,28 +155,28 @@ template<class T , class E >

Public Member Functions

template<typename U , typename = std::enable_if_t<std::is_convertible_v<U, T>>>
constexpr Expected (U r)
 
template<typename U , typename = std::enable_if_t<std::is_convertible_v<U, E>>>
constexpr Expected (Unexpected< U > e)
 
template<typename U >
requires constexpr std::convertible_to< U, T > Expected (U &&r)
 
template<typename U >
requires std::convertible_to< U, E > &&!std constexpr ::is_reference_v< U > Expected (Unexpected< U > e)
 
constexpr bool has_value () const
 
constexpr T const & value () const
-

Definition at line 132 of file Expected.h.

+

Definition at line 135 of file Expected.h.

Constructor & Destructor Documentation

- -

◆ Expected() [1/2]

+ +

◆ Expected() [1/2]

template<class T , class E >
-template<typename U , typename = std::enable_if_t<std::is_convertible_v<U, T>>>
+template<typename U >
- + - + @@ -188,25 +188,25 @@ template<typename U , typename = std::enable_if_t<std::is_convertible_v&l
constexpr ripple::Expected< T, E >::Expected requires constexpr std::convertible_to<U, T> ripple::Expected< T, E >::Expected (U U &&  r)
-

Definition at line 138 of file Expected.h.

+

Definition at line 139 of file Expected.h.

- -

◆ Expected() [2/2]

+ +

◆ Expected() [2/2]

template<class T , class E >
-template<typename U , typename = std::enable_if_t<std::is_convertible_v<U, E>>>
+template<typename U >
- + @@ -220,7 +220,7 @@ template<typename U , typename = std::enable_if_t<std::is_convertible_v&l
constexpr ripple::Expected< T, E >::Expected requires std::convertible_to<U, E>&& !std constexpr ::is_reference_v<U> ripple::Expected< T, E >::Expected ( Unexpected< U >  e)
-

Definition at line 145 of file Expected.h.

+

Definition at line 146 of file Expected.h.

@@ -250,7 +250,7 @@ template<class T , class E >
-

Definition at line 149 of file Expected.h.

+

Definition at line 151 of file Expected.h.

@@ -279,7 +279,7 @@ template<class T , class E >
-

Definition at line 154 of file Expected.h.

+

Definition at line 156 of file Expected.h.

@@ -308,7 +308,7 @@ template<class T , class E >
-

Definition at line 159 of file Expected.h.

+

Definition at line 161 of file Expected.h.

@@ -337,7 +337,7 @@ template<class T , class E >
-

Definition at line 164 of file Expected.h.

+

Definition at line 166 of file Expected.h.

@@ -366,7 +366,7 @@ template<class T , class E >
-

Definition at line 169 of file Expected.h.

+

Definition at line 171 of file Expected.h.

@@ -395,7 +395,7 @@ template<class T , class E >
-

Definition at line 174 of file Expected.h.

+

Definition at line 176 of file Expected.h.

@@ -424,7 +424,7 @@ template<class T , class E >
-

Definition at line 182 of file Expected.h.

+

Definition at line 184 of file Expected.h.

@@ -453,7 +453,7 @@ template<class T , class E >
-

Definition at line 187 of file Expected.h.

+

Definition at line 189 of file Expected.h.

@@ -482,7 +482,7 @@ template<class T , class E >
-

Definition at line 192 of file Expected.h.

+

Definition at line 194 of file Expected.h.

@@ -511,7 +511,7 @@ template<class T , class E >
-

Definition at line 197 of file Expected.h.

+

Definition at line 199 of file Expected.h.

diff --git a/classripple_1_1Expected_3_01void_00_01E_01_4-members.html b/classripple_1_1Expected_3_01void_00_01E_01_4-members.html index 655844b939..e5488ee167 100644 --- a/classripple_1_1Expected_3_01void_00_01E_01_4-members.html +++ b/classripple_1_1Expected_3_01void_00_01E_01_4-members.html @@ -76,7 +76,7 @@ $(function() { error() constripple::Expected< void, E > error()ripple::Expected< void, E > Expected()ripple::Expected< void, E > - Expected(Unexpected< U > e)ripple::Expected< void, E > + Expected(Unexpected< U > e)ripple::Expected< void, E > operator bool() constripple::Expected< void, E >explicit diff --git a/classripple_1_1Expected_3_01void_00_01E_01_4.html b/classripple_1_1Expected_3_01void_00_01E_01_4.html index e2ed277a8e..c28018e925 100644 --- a/classripple_1_1Expected_3_01void_00_01E_01_4.html +++ b/classripple_1_1Expected_3_01void_00_01E_01_4.html @@ -96,9 +96,9 @@ Collaboration diagram for ripple::Expected< void, E >: Public Member Functions constexpr Expected ()   -template<typename U , typename = std::enable_if_t<std::is_convertible_v<U, E>>> -constexpr Expected (Unexpected< U > e) -  +template<typename U > +requires std::convertible_to< U, E > &&!std constexpr ::is_reference_v< U > Expected (Unexpected< U > e) +  constexpr E const & error () const   constexpr E & error () @@ -116,7 +116,7 @@ Private Types class ripple::Expected< void, E > -

Definition at line 206 of file Expected.h.

+

Definition at line 208 of file Expected.h.

Member Typedef Documentation

◆ Base

@@ -140,7 +140,7 @@ template<class E >
-

Definition at line 209 of file Expected.h.

+

Definition at line 211 of file Expected.h.

@@ -170,25 +170,25 @@ template<class E >
-

Definition at line 214 of file Expected.h.

+

Definition at line 216 of file Expected.h.

- -

◆ Expected() [2/2]

+ +

◆ Expected() [2/2]

template<class E >
-template<typename U , typename = std::enable_if_t<std::is_convertible_v<U, E>>>
+template<typename U >
- + @@ -202,7 +202,7 @@ template<typename U , typename = std::enable_if_t<std::is_convertible_v&l
constexpr ripple::Expected< void, E >::Expected requires std::convertible_to<U, E>&& !std constexpr ::is_reference_v<U> ripple::Expected< void, E >::Expected ( Unexpected< U >  e)
-

Definition at line 221 of file Expected.h.

+

Definition at line 222 of file Expected.h.

@@ -232,7 +232,7 @@ template<class E >
-

Definition at line 225 of file Expected.h.

+

Definition at line 227 of file Expected.h.

@@ -261,7 +261,7 @@ template<class E >
-

Definition at line 230 of file Expected.h.

+

Definition at line 232 of file Expected.h.

@@ -290,7 +290,7 @@ template<class E >
-

Definition at line 235 of file Expected.h.

+

Definition at line 237 of file Expected.h.

diff --git a/classripple_1_1NFTokenAcceptOffer.html b/classripple_1_1NFTokenAcceptOffer.html index 6adc05aeb2..0246ec44f0 100644 --- a/classripple_1_1NFTokenAcceptOffer.html +++ b/classripple_1_1NFTokenAcceptOffer.html @@ -345,7 +345,7 @@ Static Private Member Functions
-

Definition at line 221 of file NFTokenAcceptOffer.cpp.

+

Definition at line 224 of file NFTokenAcceptOffer.cpp.

@@ -373,7 +373,7 @@ Static Private Member Functions
-

Definition at line 234 of file NFTokenAcceptOffer.cpp.

+

Definition at line 237 of file NFTokenAcceptOffer.cpp.

@@ -494,7 +494,7 @@ Static Private Member Functions

Implements ripple::Transactor.

-

Definition at line 279 of file NFTokenAcceptOffer.cpp.

+

Definition at line 282 of file NFTokenAcceptOffer.cpp.

diff --git a/classripple_1_1NFToken__test.html b/classripple_1_1NFToken__test.html index ad3ec3da78..3f43e36c08 100644 --- a/classripple_1_1NFToken__test.html +++ b/classripple_1_1NFToken__test.html @@ -638,7 +638,7 @@ Static Private Member Functions
-

Definition at line 1358 of file NFToken_test.cpp.

+

Definition at line 1370 of file NFToken_test.cpp.

@@ -666,7 +666,7 @@ Static Private Member Functions
-

Definition at line 1476 of file NFToken_test.cpp.

+

Definition at line 1488 of file NFToken_test.cpp.

@@ -694,7 +694,7 @@ Static Private Member Functions
-

Definition at line 1570 of file NFToken_test.cpp.

+

Definition at line 1582 of file NFToken_test.cpp.

@@ -722,7 +722,7 @@ Static Private Member Functions
-

Definition at line 1762 of file NFToken_test.cpp.

+

Definition at line 1774 of file NFToken_test.cpp.

@@ -750,7 +750,7 @@ Static Private Member Functions
-

Definition at line 2052 of file NFToken_test.cpp.

+

Definition at line 2064 of file NFToken_test.cpp.

@@ -778,7 +778,7 @@ Static Private Member Functions
-

Definition at line 2483 of file NFToken_test.cpp.

+

Definition at line 2495 of file NFToken_test.cpp.

@@ -806,7 +806,7 @@ Static Private Member Functions
-

Definition at line 2556 of file NFToken_test.cpp.

+

Definition at line 2568 of file NFToken_test.cpp.

@@ -834,7 +834,7 @@ Static Private Member Functions
-

Definition at line 2666 of file NFToken_test.cpp.

+

Definition at line 2678 of file NFToken_test.cpp.

@@ -862,7 +862,7 @@ Static Private Member Functions
-

Definition at line 2967 of file NFToken_test.cpp.

+

Definition at line 2979 of file NFToken_test.cpp.

@@ -890,7 +890,7 @@ Static Private Member Functions
-

Definition at line 3441 of file NFToken_test.cpp.

+

Definition at line 3453 of file NFToken_test.cpp.

@@ -918,7 +918,7 @@ Static Private Member Functions
-

Definition at line 3555 of file NFToken_test.cpp.

+

Definition at line 3567 of file NFToken_test.cpp.

@@ -946,7 +946,7 @@ Static Private Member Functions
-

Definition at line 3674 of file NFToken_test.cpp.

+

Definition at line 3686 of file NFToken_test.cpp.

@@ -974,7 +974,7 @@ Static Private Member Functions
-

Definition at line 4176 of file NFToken_test.cpp.

+

Definition at line 4188 of file NFToken_test.cpp.

@@ -1002,7 +1002,7 @@ Static Private Member Functions
-

Definition at line 4257 of file NFToken_test.cpp.

+

Definition at line 4269 of file NFToken_test.cpp.

@@ -1030,7 +1030,7 @@ Static Private Member Functions
-

Definition at line 4343 of file NFToken_test.cpp.

+

Definition at line 4355 of file NFToken_test.cpp.

@@ -1058,7 +1058,7 @@ Static Private Member Functions
-

Definition at line 4436 of file NFToken_test.cpp.

+

Definition at line 4448 of file NFToken_test.cpp.

@@ -1086,7 +1086,7 @@ Static Private Member Functions
-

Definition at line 4665 of file NFToken_test.cpp.

+

Definition at line 4677 of file NFToken_test.cpp.

@@ -1114,7 +1114,7 @@ Static Private Member Functions
-

Definition at line 4902 of file NFToken_test.cpp.

+

Definition at line 4914 of file NFToken_test.cpp.

@@ -1141,7 +1141,7 @@ Static Private Member Functions
-

Definition at line 4933 of file NFToken_test.cpp.

+

Definition at line 4945 of file NFToken_test.cpp.

diff --git a/classripple_1_1Unexpected.html b/classripple_1_1Unexpected.html index a646f0dba3..f7aeaf4831 100644 --- a/classripple_1_1Unexpected.html +++ b/classripple_1_1Unexpected.html @@ -101,7 +101,7 @@ Private Attributes class ripple::Unexpected< E > -

Definition at line 80 of file Expected.h.

+

Definition at line 83 of file Expected.h.

Constructor & Destructor Documentation

◆ Unexpected() [1/3]

@@ -156,7 +156,7 @@ template<class E >
-

Definition at line 87 of file Expected.h.

+

Definition at line 90 of file Expected.h.

@@ -186,7 +186,7 @@ template<class E >
-

Definition at line 91 of file Expected.h.

+

Definition at line 94 of file Expected.h.

@@ -216,7 +216,7 @@ template<class E >
-

Definition at line 96 of file Expected.h.

+

Definition at line 99 of file Expected.h.

@@ -245,7 +245,7 @@ template<class E >
-

Definition at line 102 of file Expected.h.

+

Definition at line 105 of file Expected.h.

@@ -274,7 +274,7 @@ template<class E >
-

Definition at line 108 of file Expected.h.

+

Definition at line 111 of file Expected.h.

@@ -303,7 +303,7 @@ template<class E >
-

Definition at line 114 of file Expected.h.

+

Definition at line 117 of file Expected.h.

@@ -330,7 +330,7 @@ template<class E >
-

Definition at line 120 of file Expected.h.

+

Definition at line 123 of file Expected.h.

diff --git a/functions_e.html b/functions_e.html index 0fe9156784..7ab579a278 100644 --- a/functions_e.html +++ b/functions_e.html @@ -635,8 +635,8 @@ $(function() { : ripple::JobQueue::Coro
  • Expected() -: ripple::Expected< T, E > -, ripple::Expected< void, E > +: ripple::Expected< T, E > +, ripple::Expected< void, E >
  • expectedRefreshMin : ripple::test::ValidatorSite_test::FetchListConfig diff --git a/functions_func_e.html b/functions_func_e.html index dddc94a0a3..4db44f9c1e 100644 --- a/functions_func_e.html +++ b/functions_func_e.html @@ -400,7 +400,7 @@ $(function() { : ripple::JobQueue::Coro
  • Expected() -: ripple::Expected< T, E > +: ripple::Expected< T, E > , ripple::Expected< void, E >
  • expectEq() diff --git a/md____w_rippled_rippled_README.html b/md____w_rippled_rippled_README.html index 3fe68a8ffd..c6c40b6d3b 100644 --- a/md____w_rippled_rippled_README.html +++ b/md____w_rippled_rippled_README.html @@ -117,6 +117,7 @@ See Also
  • XRP Ledger Dev Portal
  • Setup and Installation
  • Source Documentation (Doxygen)
    • +
  • Mailing List for Release Announcements
  • Learn more about the XRP Ledger (YouTube)
    • diff --git a/namespaceripple_1_1BuildInfo.html b/namespaceripple_1_1BuildInfo.html index 47133125d3..41c459c660 100644 --- a/namespaceripple_1_1BuildInfo.html +++ b/namespaceripple_1_1BuildInfo.html @@ -99,7 +99,7 @@ Functions - + @@ -281,7 +281,7 @@ N: 6-bit rc/beta number (1-63)

    Variables

    char const *const versionString = "1.10.0-b2"
    char const *const versionString = "1.10.0-rc1"
     
    static constexpr std::uint64_t implementationVersionIdentifier
     
    - +
    char const* const ripple::BuildInfo::versionString = "1.10.0-b2"char const* const ripple::BuildInfo::versionString = "1.10.0-rc1"
    diff --git a/search/all_5.js b/search/all_5.js index 7f042c1b10..367a08de59 100644 --- a/search/all_5.js +++ b/search/all_5.js @@ -238,7 +238,7 @@ var searchData= ['expect_5fsame_2581',['expect_same',['../classbeast_1_1Zero__test.html#a03f47635595efc4ac20770d6b66905ca',1,'beast::Zero_test']]], ['expectcollectionequals_2582',['expectCollectionEquals',['../classripple_1_1TestSuite.html#a145b152bd85f30c3adaebd344b1c850c',1,'ripple::TestSuite']]], ['expectearlyexit_2583',['expectEarlyExit',['../classripple_1_1JobQueue_1_1Coro.html#a764e7597e4d15e282f3d87d1364c577f',1,'ripple::JobQueue::Coro']]], - ['expected_2584',['Expected',['../classripple_1_1Expected.html',1,'ripple::Expected< T, E >'],['../classripple_1_1Expected.html#a72a359e42b44e6f71ce8cff078fea297',1,'ripple::Expected::Expected(U r)'],['../classripple_1_1Expected.html#ac153efeed3368ae4e4b29be584561b99',1,'ripple::Expected::Expected(Unexpected< U > e)'],['../classripple_1_1Expected_3_01void_00_01E_01_4.html#ac09eba67ca2af549969bdcaeedfb36c4',1,'ripple::Expected< void, E >::Expected()'],['../classripple_1_1Expected_3_01void_00_01E_01_4.html#a57630fe9c888c781402ebdc8731a3c7e',1,'ripple::Expected< void, E >::Expected(Unexpected< U > e)']]], + ['expected_2584',['Expected',['../classripple_1_1Expected.html',1,'ripple::Expected< T, E >'],['../classripple_1_1Expected.html#a9fc739c0940d5a91504161560c043eb0',1,'ripple::Expected::Expected(U &&r)'],['../classripple_1_1Expected.html#ae55b179b30376177ae33ef15745e2892',1,'ripple::Expected::Expected(Unexpected< U > e)'],['../classripple_1_1Expected_3_01void_00_01E_01_4.html#ac09eba67ca2af549969bdcaeedfb36c4',1,'ripple::Expected< void, E >::Expected()'],['../classripple_1_1Expected_3_01void_00_01E_01_4.html#a04d189412bde856d118e39554c8a0c6c',1,'ripple::Expected< void, E >::Expected(Unexpected< U > e)']]], ['expected_3c_20void_2c_20e_20_3e_2585',['Expected< void, E >',['../classripple_1_1Expected_3_01void_00_01E_01_4.html',1,'ripple']]], ['expected_5ffield_5ferror_2586',['expected_field_error',['../namespaceripple_1_1RPC.html#aa63398ec847d01de9d9af3598e3e2325',1,'ripple::RPC::expected_field_error(std::string const &name, std::string const &type)'],['../namespaceripple_1_1RPC.html#a0c4faf6372ccec80555e46ecdda67b20',1,'ripple::RPC::expected_field_error(Json::StaticString name, std::string const &type)']]], ['expected_5ffield_5fmessage_2587',['expected_field_message',['../namespaceripple_1_1RPC.html#a7bad76b302b3dcc91dd60c10830d0968',1,'ripple::RPC::expected_field_message(std::string const &name, std::string const &type)'],['../namespaceripple_1_1RPC.html#af31a2771190b89eb9b9c04e4038b9cac',1,'ripple::RPC::expected_field_message(Json::StaticString name, std::string const &type)']]], diff --git a/search/functions_5.js b/search/functions_5.js index c9ddb752af..43b23a9169 100644 --- a/search/functions_5.js +++ b/search/functions_5.js @@ -117,7 +117,7 @@ var searchData= ['expect_5fsame_16993',['expect_same',['../classbeast_1_1Zero__test.html#a03f47635595efc4ac20770d6b66905ca',1,'beast::Zero_test']]], ['expectcollectionequals_16994',['expectCollectionEquals',['../classripple_1_1TestSuite.html#a145b152bd85f30c3adaebd344b1c850c',1,'ripple::TestSuite']]], ['expectearlyexit_16995',['expectEarlyExit',['../classripple_1_1JobQueue_1_1Coro.html#a764e7597e4d15e282f3d87d1364c577f',1,'ripple::JobQueue::Coro']]], - ['expected_16996',['Expected',['../classripple_1_1Expected.html#a72a359e42b44e6f71ce8cff078fea297',1,'ripple::Expected::Expected(U r)'],['../classripple_1_1Expected.html#ac153efeed3368ae4e4b29be584561b99',1,'ripple::Expected::Expected(Unexpected< U > e)'],['../classripple_1_1Expected_3_01void_00_01E_01_4.html#ac09eba67ca2af549969bdcaeedfb36c4',1,'ripple::Expected< void, E >::Expected()'],['../classripple_1_1Expected_3_01void_00_01E_01_4.html#a57630fe9c888c781402ebdc8731a3c7e',1,'ripple::Expected< void, E >::Expected(Unexpected< U > e)']]], + ['expected_16996',['Expected',['../classripple_1_1Expected.html#a9fc739c0940d5a91504161560c043eb0',1,'ripple::Expected::Expected(U &&r)'],['../classripple_1_1Expected.html#ae55b179b30376177ae33ef15745e2892',1,'ripple::Expected::Expected(Unexpected< U > e)'],['../classripple_1_1Expected_3_01void_00_01E_01_4.html#ac09eba67ca2af549969bdcaeedfb36c4',1,'ripple::Expected< void, E >::Expected()'],['../classripple_1_1Expected_3_01void_00_01E_01_4.html#a04d189412bde856d118e39554c8a0c6c',1,'ripple::Expected< void, E >::Expected(Unexpected< U > e)']]], ['expected_5ffield_5ferror_16997',['expected_field_error',['../namespaceripple_1_1RPC.html#aa63398ec847d01de9d9af3598e3e2325',1,'ripple::RPC::expected_field_error(std::string const &name, std::string const &type)'],['../namespaceripple_1_1RPC.html#a0c4faf6372ccec80555e46ecdda67b20',1,'ripple::RPC::expected_field_error(Json::StaticString name, std::string const &type)']]], ['expected_5ffield_5fmessage_16998',['expected_field_message',['../namespaceripple_1_1RPC.html#a7bad76b302b3dcc91dd60c10830d0968',1,'ripple::RPC::expected_field_message(std::string const &name, std::string const &type)'],['../namespaceripple_1_1RPC.html#af31a2771190b89eb9b9c04e4038b9cac',1,'ripple::RPC::expected_field_message(Json::StaticString name, std::string const &type)']]], ['expecteq_16999',['expectEq',['../structripple_1_1SeqProxy__test.html#a4db5076aeadc765e5bcc18d4c7e85d38',1,'ripple::SeqProxy_test']]], diff --git a/structripple_1_1bad__expected__access.html b/structripple_1_1bad__expected__access.html index f245f28137..9fa69801b9 100644 --- a/structripple_1_1bad__expected__access.html +++ b/structripple_1_1bad__expected__access.html @@ -106,7 +106,7 @@ Public Member Functions

    See: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p0323r10.html

    The implementation is entirely based on boost::outcome_v2::result.

    -

    Definition at line 38 of file Expected.h.

    +

    Definition at line 41 of file Expected.h.

    Constructor & Destructor Documentation

    ◆ bad_expected_access()

    @@ -123,7 +123,7 @@ Public Member Functions
    -

    Definition at line 40 of file Expected.h.

    +

    Definition at line 43 of file Expected.h.

    diff --git a/structripple_1_1detail_1_1throw__policy.html b/structripple_1_1detail_1_1throw__policy.html index 1c33ccd2a1..440f90cd1e 100644 --- a/structripple_1_1detail_1_1throw__policy.html +++ b/structripple_1_1detail_1_1throw__policy.html @@ -105,7 +105,7 @@ Static Public Member Functions

    Detailed Description

    -

    Definition at line 48 of file Expected.h.

    +

    Definition at line 51 of file Expected.h.

    Member Function Documentation

    ◆ wide_value_check()

    @@ -133,7 +133,7 @@ template<class Impl >
    -

    Definition at line 52 of file Expected.h.

    +

    Definition at line 55 of file Expected.h.

    @@ -163,7 +163,7 @@ template<class Impl >
    -

    Definition at line 60 of file Expected.h.

    +

    Definition at line 63 of file Expected.h.

    @@ -193,7 +193,7 @@ template<class Impl >
    -

    Definition at line 68 of file Expected.h.

    +

    Definition at line 71 of file Expected.h.