rippled
NFTokenDir_test.cpp
1 //------------------------------------------------------------------------------
2 /*
3  This file is part of rippled: https://github.com/ripple/rippled
4  Copyright (c) 2022 Ripple Labs Inc.
5 
6  Permission to use, copy, modify, and/or distribute this software for any
7  purpose with or without fee is hereby granted, provided that the above
8  copyright notice and this permission notice appear in all copies.
9 
10  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13  ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18 //==============================================================================
19 
20 #include <ripple/app/tx/impl/details/NFTokenUtils.h>
21 #include <ripple/protocol/Feature.h>
22 #include <ripple/protocol/jss.h>
23 #include <ripple/protocol/nftPageMask.h>
24 #include <test/jtx.h>
25 
26 #include <initializer_list>
27 
28 namespace ripple {
29 
30 class NFTokenDir_test : public beast::unit_test::suite
31 {
32  // printNFTPages is a helper function that may be used for debugging.
33  //
34  // It uses the ledger RPC command to show the NFT pages in the ledger.
35  // This parameter controls how noisy the output is.
36  enum Volume : bool {
37  quiet = false,
38  noisy = true,
39  };
40 
41  void
42  printNFTPages(test::jtx::Env& env, Volume vol)
43  {
44  Json::Value jvParams;
45  jvParams[jss::ledger_index] = "current";
46  jvParams[jss::binary] = false;
47  {
48  Json::Value jrr = env.rpc(
49  "json",
50  "ledger_data",
51  boost::lexical_cast<std::string>(jvParams));
52 
53  // Iterate the state and print all NFTokenPages.
54  if (!jrr.isMember(jss::result) ||
55  !jrr[jss::result].isMember(jss::state))
56  {
57  std::cout << "No ledger state found!" << std::endl;
58  return;
59  }
60  Json::Value& state = jrr[jss::result][jss::state];
61  if (!state.isArray())
62  {
63  std::cout << "Ledger state is not array!" << std::endl;
64  return;
65  }
66  for (Json::UInt i = 0; i < state.size(); ++i)
67  {
68  if (state[i].isMember(sfNFTokens.jsonName) &&
69  state[i][sfNFTokens.jsonName].isArray())
70  {
71  std::uint32_t tokenCount =
72  state[i][sfNFTokens.jsonName].size();
73  std::cout << tokenCount << " NFtokens in page "
74  << state[i][jss::index].asString() << std::endl;
75 
76  if (vol == noisy)
77  {
78  std::cout << state[i].toStyledString() << std::endl;
79  }
80  else
81  {
82  if (tokenCount > 0)
83  std::cout << "first: "
84  << state[i][sfNFTokens.jsonName][0u]
85  .toStyledString()
86  << std::endl;
87  if (tokenCount > 1)
88  std::cout
89  << "last: "
90  << state[i][sfNFTokens.jsonName][tokenCount - 1]
91  .toStyledString()
92  << std::endl;
93  }
94  }
95  }
96  }
97  }
98 
99  void
100  testConsecutiveNFTs(FeatureBitset features)
101  {
102  // It should be possible to store many consecutive NFTs.
103  testcase("Sequential NFTs");
104 
105  using namespace test::jtx;
106  Env env{*this, features};
107 
108  // A single minter tends not to mint numerically sequential NFTokens
109  // because the taxon cipher mixes things up. We can override the
110  // cipher, however, and mint many sequential NFTokens with no gaps
111  // between them.
112  //
113  // Here we'll simply mint 100 sequential NFTs. Then we'll create
114  // offers for them to verify that the ledger can find them.
115 
116  Account const issuer{"issuer"};
117  Account const buyer{"buyer"};
118  env.fund(XRP(10000), buyer, issuer);
119  env.close();
120 
121  // Mint 100 sequential NFTs. Tweak the taxon so zero is always stored.
122  // That's what makes them sequential.
123  constexpr std::size_t nftCount = 100;
124  std::vector<uint256> nftIDs;
125  nftIDs.reserve(nftCount);
126  for (int i = 0; i < nftCount; ++i)
127  {
128  std::uint32_t taxon =
129  toUInt32(nft::cipheredTaxon(i, nft::toTaxon(0)));
130  nftIDs.emplace_back(
131  token::getNextID(env, issuer, taxon, tfTransferable));
132  env(token::mint(issuer, taxon), txflags(tfTransferable));
133  env.close();
134  }
135 
136  // Create an offer for each of the NFTs. This verifies that the ledger
137  // can find all of the minted NFTs.
138  std::vector<uint256> offers;
139  for (uint256 const& nftID : nftIDs)
140  {
141  offers.emplace_back(keylet::nftoffer(issuer, env.seq(issuer)).key);
142  env(token::createOffer(issuer, nftID, XRP(0)),
143  txflags((tfSellNFToken)));
144  env.close();
145  }
146 
147  // Buyer accepts all of the offers in reverse order.
148  std::reverse(offers.begin(), offers.end());
149  for (uint256 const& offer : offers)
150  {
151  env(token::acceptSellOffer(buyer, offer));
152  env.close();
153  }
154  }
155 
156  void
157  testLopsidedSplits(FeatureBitset features)
158  {
159  // All NFT IDs with the same low 96 bits must stay on the same NFT page.
160  testcase("Lopsided splits");
161 
162  using namespace test::jtx;
163 
164  // When a single NFT page exceeds 32 entries, the code is inclined
165  // to split that page into two equal pieces. That's fine, but
166  // the code also needs to keep NFTs with identical low 96-bits on
167  // the same page.
168  //
169  // Here we synthesize cases where there are several NFTs with
170  // identical 96-low-bits in the middle of a page. When that page
171  // is split because it overflows, we need to see that the NFTs
172  // with identical 96-low-bits are all kept on the same page.
173 
174  // Lambda that exercises the lopsided splits.
175  auto exerciseLopsided =
176  [this,
177  &features](std::initializer_list<std::string_view const> seeds) {
178  Env env{*this, features};
179 
180  // Eventually all of the NFTokens will be owned by buyer.
181  Account const buyer{"buyer"};
182  env.fund(XRP(10000), buyer);
183  env.close();
184 
185  // Create accounts for all of the seeds and fund those accounts.
186  std::vector<Account> accounts;
187  accounts.reserve(seeds.size());
188  for (std::string_view const& seed : seeds)
189  {
190  Account const& account = accounts.emplace_back(
191  Account::base58Seed, std::string(seed));
192  env.fund(XRP(10000), account);
193 
194  // Do not close the ledger inside the loop. If
195  // fixNFTokenRemint is enabled and accounts are initialized
196  // at different ledgers, they will have different account
197  // sequences. That would cause the accounts to have
198  // different NFTokenID sequence numbers.
199  }
200  env.close();
201 
202  // All of the accounts create one NFT and and offer that NFT to
203  // buyer.
204  std::vector<uint256> nftIDs;
205  std::vector<uint256> offers;
206  offers.reserve(accounts.size());
207  for (Account const& account : accounts)
208  {
209  // Mint the NFT.
210  uint256 const& nftID = nftIDs.emplace_back(
211  token::getNextID(env, account, 0, tfTransferable));
212  env(token::mint(account, 0), txflags(tfTransferable));
213  env.close();
214 
215  // Create an offer to give the NFT to buyer for free.
216  offers.emplace_back(
217  keylet::nftoffer(account, env.seq(account)).key);
218  env(token::createOffer(account, nftID, XRP(0)),
219  token::destination(buyer),
220  txflags((tfSellNFToken)));
221  }
222  env.close();
223 
224  // buyer accepts all of the offers.
225  for (uint256 const& offer : offers)
226  {
227  env(token::acceptSellOffer(buyer, offer));
228  env.close();
229  }
230 
231  // This can be a good time to look at the NFT pages.
232  // printNFTPages(env, noisy);
233 
234  // Verify that all NFTs are owned by buyer and findable in the
235  // ledger by having buyer create sell offers for all of their
236  // NFTs. Attempting to sell an offer that the ledger can't find
237  // generates a non-tesSUCCESS error code.
238  for (uint256 const& nftID : nftIDs)
239  {
240  uint256 const offerID =
241  keylet::nftoffer(buyer, env.seq(buyer)).key;
242  env(token::createOffer(buyer, nftID, XRP(100)),
243  txflags(tfSellNFToken));
244  env.close();
245 
246  env(token::cancelOffer(buyer, {offerID}));
247  }
248 
249  // Verify that all the NFTs are owned by buyer.
250  Json::Value buyerNFTs = [&env, &buyer]() {
251  Json::Value params;
252  params[jss::account] = buyer.human();
253  params[jss::type] = "state";
254  return env.rpc("json", "account_nfts", to_string(params));
255  }();
256 
257  BEAST_EXPECT(
258  buyerNFTs[jss::result][jss::account_nfts].size() ==
259  nftIDs.size());
260  for (Json::Value const& ownedNFT :
261  buyerNFTs[jss::result][jss::account_nfts])
262  {
263  uint256 ownedID;
264  BEAST_EXPECT(ownedID.parseHex(
265  ownedNFT[sfNFTokenID.jsonName].asString()));
266  auto const foundIter =
267  std::find(nftIDs.begin(), nftIDs.end(), ownedID);
268 
269  // Assuming we find the NFT, erase it so we know it's been
270  // found and can't be found again.
271  if (BEAST_EXPECT(foundIter != nftIDs.end()))
272  nftIDs.erase(foundIter);
273  }
274 
275  // All NFTs should now be accounted for, so nftIDs should be
276  // empty.
277  BEAST_EXPECT(nftIDs.empty());
278  };
279 
280  // These seeds cause a lopsided split where the new NFT is added
281  // to the upper page.
282  static std::initializer_list<std::string_view const> const
283  splitAndAddToHi{
284  "sp6JS7f14BuwFY8Mw5p3b8jjQBBTK", // 0. 0x1d2932ea
285  "sp6JS7f14BuwFY8Mw6F7X3EiGKazu", // 1. 0x1d2932ea
286  "sp6JS7f14BuwFY8Mw6FxjntJJfKXq", // 2. 0x1d2932ea
287  "sp6JS7f14BuwFY8Mw6eSF1ydEozJg", // 3. 0x1d2932ea
288  "sp6JS7f14BuwFY8Mw6koPB91um2ej", // 4. 0x1d2932ea
289  "sp6JS7f14BuwFY8Mw6m6D64iwquSe", // 5. 0x1d2932ea
290 
291  "sp6JS7f14BuwFY8Mw5rC43sN4adC2", // 6. 0x208dbc24
292  "sp6JS7f14BuwFY8Mw65L9DDQqgebz", // 7. 0x208dbc24
293  "sp6JS7f14BuwFY8Mw65nKvU8pPQNn", // 8. 0x208dbc24
294  "sp6JS7f14BuwFY8Mw6bxZLyTrdipw", // 9. 0x208dbc24
295  "sp6JS7f14BuwFY8Mw6d5abucntSoX", // 10. 0x208dbc24
296  "sp6JS7f14BuwFY8Mw6qXK5awrRRP8", // 11. 0x208dbc24
297 
298  // These eight need to be kept together by the implementation.
299  "sp6JS7f14BuwFY8Mw66EBtMxoMcCa", // 12. 0x309b67ed
300  "sp6JS7f14BuwFY8Mw66dGfE9jVfGv", // 13. 0x309b67ed
301  "sp6JS7f14BuwFY8Mw6APdZa7PH566", // 14. 0x309b67ed
302  "sp6JS7f14BuwFY8Mw6C3QX5CZyET5", // 15. 0x309b67ed
303  "sp6JS7f14BuwFY8Mw6CSysFf8GvaR", // 16. 0x309b67ed
304  "sp6JS7f14BuwFY8Mw6c7QSDmoAeRV", // 17. 0x309b67ed
305  "sp6JS7f14BuwFY8Mw6mvonveaZhW7", // 18. 0x309b67ed
306  "sp6JS7f14BuwFY8Mw6vtHHG7dYcXi", // 19. 0x309b67ed
307 
308  "sp6JS7f14BuwFY8Mw66yppUNxESaw", // 20. 0x40d4b96f
309  "sp6JS7f14BuwFY8Mw6ATYQvobXiDT", // 21. 0x40d4b96f
310  "sp6JS7f14BuwFY8Mw6bis8D1Wa9Uy", // 22. 0x40d4b96f
311  "sp6JS7f14BuwFY8Mw6cTiGCWA8Wfa", // 23. 0x40d4b96f
312  "sp6JS7f14BuwFY8Mw6eAy2fpXmyYf", // 24. 0x40d4b96f
313  "sp6JS7f14BuwFY8Mw6icn58TRs8YG", // 25. 0x40d4b96f
314 
315  "sp6JS7f14BuwFY8Mw68tj2eQEWoJt", // 26. 0x503b6ba9
316  "sp6JS7f14BuwFY8Mw6AjnAinNnMHT", // 27. 0x503b6ba9
317  "sp6JS7f14BuwFY8Mw6CKDUwB4LrhL", // 28. 0x503b6ba9
318  "sp6JS7f14BuwFY8Mw6d2yPszEFA6J", // 29. 0x503b6ba9
319  "sp6JS7f14BuwFY8Mw6jcBQBH3PfnB", // 30. 0x503b6ba9
320  "sp6JS7f14BuwFY8Mw6qxx19KSnN1w", // 31. 0x503b6ba9
321 
322  // Adding this NFT splits the page. It is added to the upper
323  // page.
324  "sp6JS7f14BuwFY8Mw6ut1hFrqWoY5", // 32. 0x503b6ba9
325  };
326 
327  // These seeds cause a lopsided split where the new NFT is added
328  // to the lower page.
329  static std::initializer_list<std::string_view const> const
330  splitAndAddToLo{
331  "sp6JS7f14BuwFY8Mw5p3b8jjQBBTK", // 0. 0x1d2932ea
332  "sp6JS7f14BuwFY8Mw6F7X3EiGKazu", // 1. 0x1d2932ea
333  "sp6JS7f14BuwFY8Mw6FxjntJJfKXq", // 2. 0x1d2932ea
334  "sp6JS7f14BuwFY8Mw6eSF1ydEozJg", // 3. 0x1d2932ea
335  "sp6JS7f14BuwFY8Mw6koPB91um2ej", // 4. 0x1d2932ea
336  "sp6JS7f14BuwFY8Mw6m6D64iwquSe", // 5. 0x1d2932ea
337 
338  "sp6JS7f14BuwFY8Mw5rC43sN4adC2", // 6. 0x208dbc24
339  "sp6JS7f14BuwFY8Mw65L9DDQqgebz", // 7. 0x208dbc24
340  "sp6JS7f14BuwFY8Mw65nKvU8pPQNn", // 8. 0x208dbc24
341  "sp6JS7f14BuwFY8Mw6bxZLyTrdipw", // 9. 0x208dbc24
342  "sp6JS7f14BuwFY8Mw6d5abucntSoX", // 10. 0x208dbc24
343  "sp6JS7f14BuwFY8Mw6qXK5awrRRP8", // 11. 0x208dbc24
344 
345  // These eight need to be kept together by the implementation.
346  "sp6JS7f14BuwFY8Mw66EBtMxoMcCa", // 12. 0x309b67ed
347  "sp6JS7f14BuwFY8Mw66dGfE9jVfGv", // 13. 0x309b67ed
348  "sp6JS7f14BuwFY8Mw6APdZa7PH566", // 14. 0x309b67ed
349  "sp6JS7f14BuwFY8Mw6C3QX5CZyET5", // 15. 0x309b67ed
350  "sp6JS7f14BuwFY8Mw6CSysFf8GvaR", // 16. 0x309b67ed
351  "sp6JS7f14BuwFY8Mw6c7QSDmoAeRV", // 17. 0x309b67ed
352  "sp6JS7f14BuwFY8Mw6mvonveaZhW7", // 18. 0x309b67ed
353  "sp6JS7f14BuwFY8Mw6vtHHG7dYcXi", // 19. 0x309b67ed
354 
355  "sp6JS7f14BuwFY8Mw66yppUNxESaw", // 20. 0x40d4b96f
356  "sp6JS7f14BuwFY8Mw6ATYQvobXiDT", // 21. 0x40d4b96f
357  "sp6JS7f14BuwFY8Mw6bis8D1Wa9Uy", // 22. 0x40d4b96f
358  "sp6JS7f14BuwFY8Mw6cTiGCWA8Wfa", // 23. 0x40d4b96f
359  "sp6JS7f14BuwFY8Mw6eAy2fpXmyYf", // 24. 0x40d4b96f
360  "sp6JS7f14BuwFY8Mw6icn58TRs8YG", // 25. 0x40d4b96f
361 
362  "sp6JS7f14BuwFY8Mw68tj2eQEWoJt", // 26. 0x503b6ba9
363  "sp6JS7f14BuwFY8Mw6AjnAinNnMHT", // 27. 0x503b6ba9
364  "sp6JS7f14BuwFY8Mw6CKDUwB4LrhL", // 28. 0x503b6ba9
365  "sp6JS7f14BuwFY8Mw6d2yPszEFA6J", // 29. 0x503b6ba9
366  "sp6JS7f14BuwFY8Mw6jcBQBH3PfnB", // 30. 0x503b6ba9
367  "sp6JS7f14BuwFY8Mw6qxx19KSnN1w", // 31. 0x503b6ba9
368 
369  // Adding this NFT splits the page. It is added to the lower
370  // page.
371  "sp6JS7f14BuwFY8Mw6xCigaMwC6Dp", // 32. 0x309b67ed
372  };
373 
374  // Run the test cases.
375  exerciseLopsided(splitAndAddToHi);
376  exerciseLopsided(splitAndAddToLo);
377  }
378 
379  void
380  testFixNFTokenDirV1(FeatureBitset features)
381  {
382  // Exercise a fix for an off-by-one in the creation of an NFTokenPage
383  // index.
384  testcase("fixNFTokenDirV1");
385 
386  using namespace test::jtx;
387 
388  // When a single NFT page exceeds 32 entries, the code is inclined
389  // to split that page into two equal pieces. The new page is lower
390  // than the original. There was an off-by-one in the selection of
391  // the index for the new page. This test recreates the problem.
392 
393  // Lambda that exercises the split.
394  auto exerciseFixNFTokenDirV1 =
395  [this,
396  &features](std::initializer_list<std::string_view const> seeds) {
397  Env env{
398  *this,
399  envconfig(),
400  features,
401  nullptr,
402  beast::severities::kDisabled};
403 
404  // Eventually all of the NFTokens will be owned by buyer.
405  Account const buyer{"buyer"};
406  env.fund(XRP(10000), buyer);
407  env.close();
408 
409  // Create accounts for all of the seeds and fund those accounts.
410  std::vector<Account> accounts;
411  accounts.reserve(seeds.size());
412  for (std::string_view const& seed : seeds)
413  {
414  Account const& account = accounts.emplace_back(
415  Account::base58Seed, std::string(seed));
416  env.fund(XRP(10000), account);
417 
418  // Do not close the ledger inside the loop. If
419  // fixNFTokenRemint is enabled and accounts are initialized
420  // at different ledgers, they will have different account
421  // sequences. That would cause the accounts to have
422  // different NFTokenID sequence numbers.
423  }
424  env.close();
425 
426  // All of the accounts create one NFT and and offer that NFT to
427  // buyer.
428  std::vector<uint256> nftIDs;
429  std::vector<uint256> offers;
430  offers.reserve(accounts.size());
431  for (Account const& account : accounts)
432  {
433  // Mint the NFT.
434  uint256 const& nftID = nftIDs.emplace_back(
435  token::getNextID(env, account, 0, tfTransferable));
436  env(token::mint(account, 0), txflags(tfTransferable));
437  env.close();
438 
439  // Create an offer to give the NFT to buyer for free.
440  offers.emplace_back(
441  keylet::nftoffer(account, env.seq(account)).key);
442  env(token::createOffer(account, nftID, XRP(0)),
443  token::destination(buyer),
444  txflags((tfSellNFToken)));
445  }
446  env.close();
447 
448  // buyer accepts all of the but the last. The last offer
449  // causes the page to split.
450  for (std::size_t i = 0; i < offers.size() - 1; ++i)
451  {
452  env(token::acceptSellOffer(buyer, offers[i]));
453  env.close();
454  }
455 
456  // Here is the last offer. Without the fix accepting this
457  // offer causes tecINVARIANT_FAILED. With the fix the offer
458  // accept succeeds.
459  if (!features[fixNFTokenDirV1])
460  {
461  env(token::acceptSellOffer(buyer, offers.back()),
462  ter(tecINVARIANT_FAILED));
463  env.close();
464  return;
465  }
466  env(token::acceptSellOffer(buyer, offers.back()));
467  env.close();
468 
469  // This can be a good time to look at the NFT pages.
470  // printNFTPages(env, noisy);
471 
472  // Verify that all NFTs are owned by buyer and findable in the
473  // ledger by having buyer create sell offers for all of their
474  // NFTs. Attempting to sell an offer that the ledger can't find
475  // generates a non-tesSUCCESS error code.
476  for (uint256 const& nftID : nftIDs)
477  {
478  uint256 const offerID =
479  keylet::nftoffer(buyer, env.seq(buyer)).key;
480  env(token::createOffer(buyer, nftID, XRP(100)),
481  txflags(tfSellNFToken));
482  env.close();
483 
484  env(token::cancelOffer(buyer, {offerID}));
485  }
486 
487  // Verify that all the NFTs are owned by buyer.
488  Json::Value buyerNFTs = [&env, &buyer]() {
489  Json::Value params;
490  params[jss::account] = buyer.human();
491  params[jss::type] = "state";
492  return env.rpc("json", "account_nfts", to_string(params));
493  }();
494 
495  BEAST_EXPECT(
496  buyerNFTs[jss::result][jss::account_nfts].size() ==
497  nftIDs.size());
498  for (Json::Value const& ownedNFT :
499  buyerNFTs[jss::result][jss::account_nfts])
500  {
501  uint256 ownedID;
502  BEAST_EXPECT(ownedID.parseHex(
503  ownedNFT[sfNFTokenID.jsonName].asString()));
504  auto const foundIter =
505  std::find(nftIDs.begin(), nftIDs.end(), ownedID);
506 
507  // Assuming we find the NFT, erase it so we know it's been
508  // found and can't be found again.
509  if (BEAST_EXPECT(foundIter != nftIDs.end()))
510  nftIDs.erase(foundIter);
511  }
512 
513  // All NFTs should now be accounted for, so nftIDs should be
514  // empty.
515  BEAST_EXPECT(nftIDs.empty());
516  };
517 
518  // These seeds fill the last 17 entries of the initial page with
519  // equivalent NFTs. The split should keep these together.
520  static std::initializer_list<std::string_view const> const seventeenHi{
521  // These 16 need to be kept together by the implementation.
522  "sp6JS7f14BuwFY8Mw5EYu5z86hKDL", // 0. 0x399187e9
523  "sp6JS7f14BuwFY8Mw5PUAMwc5ygd7", // 1. 0x399187e9
524  "sp6JS7f14BuwFY8Mw5R3xUBcLSeTs", // 2. 0x399187e9
525  "sp6JS7f14BuwFY8Mw5W6oS5sdC3oF", // 3. 0x399187e9
526  "sp6JS7f14BuwFY8Mw5pYc3D9iuLcw", // 4. 0x399187e9
527  "sp6JS7f14BuwFY8Mw5pfGVnhcdp3b", // 5. 0x399187e9
528  "sp6JS7f14BuwFY8Mw6jS6RdEqXqrN", // 6. 0x399187e9
529  "sp6JS7f14BuwFY8Mw6krt6AKbvRXW", // 7. 0x399187e9
530  "sp6JS7f14BuwFY8Mw6mnVBQq7cAN2", // 8. 0x399187e9
531  "sp6JS7f14BuwFY8Mw8ECJxPjmkufQ", // 9. 0x399187e9
532  "sp6JS7f14BuwFY8Mw8asgzcceGWYm", // 10. 0x399187e9
533  "sp6JS7f14BuwFY8MwF6J3FXnPCgL8", // 11. 0x399187e9
534  "sp6JS7f14BuwFY8MwFEud2w5czv5q", // 12. 0x399187e9
535  "sp6JS7f14BuwFY8MwFNxKVqJnx8P5", // 13. 0x399187e9
536  "sp6JS7f14BuwFY8MwFnTCXg3eRidL", // 14. 0x399187e9
537  "sp6JS7f14BuwFY8Mwj47hv1vrDge6", // 15. 0x399187e9
538 
539  // These 17 need to be kept together by the implementation.
540  "sp6JS7f14BuwFY8MwjJCwYr9zSfAv", // 16. 0xabb11898
541  "sp6JS7f14BuwFY8MwjYa5yLkgCLuT", // 17. 0xabb11898
542  "sp6JS7f14BuwFY8MwjenxuJ3TH2Bc", // 18. 0xabb11898
543  "sp6JS7f14BuwFY8MwjriN7Ui11NzB", // 19. 0xabb11898
544  "sp6JS7f14BuwFY8Mwk3AuoJNSEo34", // 20. 0xabb11898
545  "sp6JS7f14BuwFY8MwkT36hnRv8hTo", // 21. 0xabb11898
546  "sp6JS7f14BuwFY8MwkTQixEXfi1Cr", // 22. 0xabb11898
547  "sp6JS7f14BuwFY8MwkYJaZM1yTJBF", // 23. 0xabb11898
548  "sp6JS7f14BuwFY8Mwkc4k1uo85qp2", // 24. 0xabb11898
549  "sp6JS7f14BuwFY8Mwkf7cFhF1uuxx", // 25. 0xabb11898
550  "sp6JS7f14BuwFY8MwmCK2un99wb4e", // 26. 0xabb11898
551  "sp6JS7f14BuwFY8MwmETztNHYu2Bx", // 27. 0xabb11898
552  "sp6JS7f14BuwFY8MwmJws9UwRASfR", // 28. 0xabb11898
553  "sp6JS7f14BuwFY8MwoH5PQkGK8tEb", // 29. 0xabb11898
554  "sp6JS7f14BuwFY8MwoVXtP2yCzjJV", // 30. 0xabb11898
555  "sp6JS7f14BuwFY8MwobxRXA9vsTeX", // 31. 0xabb11898
556  "sp6JS7f14BuwFY8Mwos3pc5Gb3ihU", // 32. 0xabb11898
557  };
558 
559  // These seeds fill the first entries of the initial page with
560  // equivalent NFTs. The split should keep these together.
561  static std::initializer_list<std::string_view const> const seventeenLo{
562  // These 17 need to be kept together by the implementation.
563  "sp6JS7f14BuwFY8Mw5EYu5z86hKDL", // 0. 0x399187e9
564  "sp6JS7f14BuwFY8Mw5PUAMwc5ygd7", // 1. 0x399187e9
565  "sp6JS7f14BuwFY8Mw5R3xUBcLSeTs", // 2. 0x399187e9
566  "sp6JS7f14BuwFY8Mw5W6oS5sdC3oF", // 3. 0x399187e9
567  "sp6JS7f14BuwFY8Mw5pYc3D9iuLcw", // 4. 0x399187e9
568  "sp6JS7f14BuwFY8Mw5pfGVnhcdp3b", // 5. 0x399187e9
569  "sp6JS7f14BuwFY8Mw6jS6RdEqXqrN", // 6. 0x399187e9
570  "sp6JS7f14BuwFY8Mw6krt6AKbvRXW", // 7. 0x399187e9
571  "sp6JS7f14BuwFY8Mw6mnVBQq7cAN2", // 8. 0x399187e9
572  "sp6JS7f14BuwFY8Mw8ECJxPjmkufQ", // 9. 0x399187e9
573  "sp6JS7f14BuwFY8Mw8asgzcceGWYm", // 10. 0x399187e9
574  "sp6JS7f14BuwFY8MwF6J3FXnPCgL8", // 11. 0x399187e9
575  "sp6JS7f14BuwFY8MwFEud2w5czv5q", // 12. 0x399187e9
576  "sp6JS7f14BuwFY8MwFNxKVqJnx8P5", // 13. 0x399187e9
577  "sp6JS7f14BuwFY8MwFnTCXg3eRidL", // 14. 0x399187e9
578  "sp6JS7f14BuwFY8Mwj47hv1vrDge6", // 15. 0x399187e9
579  "sp6JS7f14BuwFY8Mwj6TYekeeyukh", // 16. 0x399187e9
580 
581  // These 16 need to be kept together by the implementation.
582  "sp6JS7f14BuwFY8MwjYa5yLkgCLuT", // 17. 0xabb11898
583  "sp6JS7f14BuwFY8MwjenxuJ3TH2Bc", // 18. 0xabb11898
584  "sp6JS7f14BuwFY8MwjriN7Ui11NzB", // 19. 0xabb11898
585  "sp6JS7f14BuwFY8Mwk3AuoJNSEo34", // 20. 0xabb11898
586  "sp6JS7f14BuwFY8MwkT36hnRv8hTo", // 21. 0xabb11898
587  "sp6JS7f14BuwFY8MwkTQixEXfi1Cr", // 22. 0xabb11898
588  "sp6JS7f14BuwFY8MwkYJaZM1yTJBF", // 23. 0xabb11898
589  "sp6JS7f14BuwFY8Mwkc4k1uo85qp2", // 24. 0xabb11898
590  "sp6JS7f14BuwFY8Mwkf7cFhF1uuxx", // 25. 0xabb11898
591  "sp6JS7f14BuwFY8MwmCK2un99wb4e", // 26. 0xabb11898
592  "sp6JS7f14BuwFY8MwmETztNHYu2Bx", // 27. 0xabb11898
593  "sp6JS7f14BuwFY8MwmJws9UwRASfR", // 28. 0xabb11898
594  "sp6JS7f14BuwFY8MwoH5PQkGK8tEb", // 29. 0xabb11898
595  "sp6JS7f14BuwFY8MwoVXtP2yCzjJV", // 30. 0xabb11898
596  "sp6JS7f14BuwFY8MwobxRXA9vsTeX", // 31. 0xabb11898
597  "sp6JS7f14BuwFY8Mwos3pc5Gb3ihU", // 32. 0xabb11898
598  };
599 
600  // Run the test cases.
601  exerciseFixNFTokenDirV1(seventeenHi);
602  exerciseFixNFTokenDirV1(seventeenLo);
603  }
604 
605  void
606  testTooManyEquivalent(FeatureBitset features)
607  {
608  // Exercise the case where 33 NFTs with identical sort
609  // characteristics are owned by the same account.
610  testcase("NFToken too many same");
611 
612  using namespace test::jtx;
613 
614  Env env{*this, features};
615 
616  // Eventually all of the NFTokens will be owned by buyer.
617  Account const buyer{"buyer"};
618  env.fund(XRP(10000), buyer);
619  env.close();
620 
621  // Here are 33 seeds that produce identical low 32-bits in their
622  // corresponding AccountIDs.
623  static std::initializer_list<std::string_view const> const seeds{
624  "sp6JS7f14BuwFY8Mw5FnqmbciPvH6", // 0. 0x9a8ebed3
625  "sp6JS7f14BuwFY8Mw5MBGbyMSsXLp", // 1. 0x9a8ebed3
626  "sp6JS7f14BuwFY8Mw5S4PnDyBdKKm", // 2. 0x9a8ebed3
627  "sp6JS7f14BuwFY8Mw6kcXpM2enE35", // 3. 0x9a8ebed3
628  "sp6JS7f14BuwFY8Mw6tuuSMMwyJ44", // 4. 0x9a8ebed3
629  "sp6JS7f14BuwFY8Mw8E8JWLQ1P8pt", // 5. 0x9a8ebed3
630  "sp6JS7f14BuwFY8Mw8WwdgWkCHhEx", // 6. 0x9a8ebed3
631  "sp6JS7f14BuwFY8Mw8XDUYvU6oGhQ", // 7. 0x9a8ebed3
632  "sp6JS7f14BuwFY8Mw8ceVGL4M1zLQ", // 8. 0x9a8ebed3
633  "sp6JS7f14BuwFY8Mw8fdSwLCZWDFd", // 9. 0x9a8ebed3
634  "sp6JS7f14BuwFY8Mw8zuF6Fg65i1E", // 10. 0x9a8ebed3
635  "sp6JS7f14BuwFY8MwF2k7bihVfqes", // 11. 0x9a8ebed3
636  "sp6JS7f14BuwFY8MwF6X24WXGn557", // 12. 0x9a8ebed3
637  "sp6JS7f14BuwFY8MwFMpn7strjekg", // 13. 0x9a8ebed3
638  "sp6JS7f14BuwFY8MwFSdy9sYVrwJs", // 14. 0x9a8ebed3
639  "sp6JS7f14BuwFY8MwFdMcLy9UkrXn", // 15. 0x9a8ebed3
640  "sp6JS7f14BuwFY8MwFdbwFm1AAboa", // 16. 0x9a8ebed3
641  "sp6JS7f14BuwFY8MwFdr5AhKThVtU", // 17. 0x9a8ebed3
642  "sp6JS7f14BuwFY8MwjFc3Q9YatvAw", // 18. 0x9a8ebed3
643  "sp6JS7f14BuwFY8MwjRXcNs1ozEXn", // 19. 0x9a8ebed3
644  "sp6JS7f14BuwFY8MwkQGUKL7v1FBt", // 20. 0x9a8ebed3
645  "sp6JS7f14BuwFY8Mwkamsoxx1wECt", // 21. 0x9a8ebed3
646  "sp6JS7f14BuwFY8Mwm3hus1dG6U8y", // 22. 0x9a8ebed3
647  "sp6JS7f14BuwFY8Mwm589M8vMRpXF", // 23. 0x9a8ebed3
648  "sp6JS7f14BuwFY8MwmJTRJ4Fqz1A3", // 24. 0x9a8ebed3
649  "sp6JS7f14BuwFY8MwmRfy8fer4QbL", // 25. 0x9a8ebed3
650  "sp6JS7f14BuwFY8MwmkkFx1HtgWRx", // 26. 0x9a8ebed3
651  "sp6JS7f14BuwFY8MwmwP9JFdKa4PS", // 27. 0x9a8ebed3
652  "sp6JS7f14BuwFY8MwoXWJLB3ciHfo", // 28. 0x9a8ebed3
653  "sp6JS7f14BuwFY8MwoYc1gTtT2mWL", // 29. 0x9a8ebed3
654  "sp6JS7f14BuwFY8MwogXtHH7FNVoo", // 30. 0x9a8ebed3
655  "sp6JS7f14BuwFY8MwoqYoA9P8gf3r", // 31. 0x9a8ebed3
656  "sp6JS7f14BuwFY8MwoujwMJofGnsA", // 32. 0x9a8ebed3
657  };
658 
659  // Create accounts for all of the seeds and fund those accounts.
660  std::vector<Account> accounts;
661  accounts.reserve(seeds.size());
662  for (std::string_view const& seed : seeds)
663  {
664  Account const& account =
665  accounts.emplace_back(Account::base58Seed, std::string(seed));
666  env.fund(XRP(10000), account);
667 
668  // Do not close the ledger inside the loop. If
669  // fixNFTokenRemint is enabled and accounts are initialized
670  // at different ledgers, they will have different account
671  // sequences. That would cause the accounts to have
672  // different NFTokenID sequence numbers.
673  }
674  env.close();
675 
676  // All of the accounts create one NFT and and offer that NFT to buyer.
677  std::vector<uint256> nftIDs;
678  std::vector<uint256> offers;
679  offers.reserve(accounts.size());
680  for (Account const& account : accounts)
681  {
682  // Mint the NFT.
683  uint256 const& nftID = nftIDs.emplace_back(
684  token::getNextID(env, account, 0, tfTransferable));
685  env(token::mint(account, 0), txflags(tfTransferable));
686  env.close();
687 
688  // Create an offer to give the NFT to buyer for free.
689  offers.emplace_back(
690  keylet::nftoffer(account, env.seq(account)).key);
691  env(token::createOffer(account, nftID, XRP(0)),
692  token::destination(buyer),
693  txflags((tfSellNFToken)));
694  }
695  env.close();
696 
697  // Verify that the low 96 bits of all generated NFTs is identical.
698  uint256 const expectLowBits = nftIDs.front() & nft::pageMask;
699  for (uint256 const& nftID : nftIDs)
700  {
701  BEAST_EXPECT(expectLowBits == (nftID & nft::pageMask));
702  }
703 
704  // Remove one NFT and offer from the vectors. This offer is the one
705  // that will overflow the page.
706  nftIDs.pop_back();
707  uint256 const offerForPageOverflow = offers.back();
708  offers.pop_back();
709 
710  // buyer accepts all of the offers but one.
711  for (uint256 const& offer : offers)
712  {
713  env(token::acceptSellOffer(buyer, offer));
714  env.close();
715  }
716 
717  // buyer accepts the last offer which causes a page overflow.
718  env(token::acceptSellOffer(buyer, offerForPageOverflow),
719  ter(tecNO_SUITABLE_NFTOKEN_PAGE));
720 
721  // Verify that all expected NFTs are owned by buyer and findable in
722  // the ledger by having buyer create sell offers for all of their NFTs.
723  // Attempting to sell an offer that the ledger can't find generates
724  // a non-tesSUCCESS error code.
725  for (uint256 const& nftID : nftIDs)
726  {
727  uint256 const offerID = keylet::nftoffer(buyer, env.seq(buyer)).key;
728  env(token::createOffer(buyer, nftID, XRP(100)),
729  txflags(tfSellNFToken));
730  env.close();
731 
732  env(token::cancelOffer(buyer, {offerID}));
733  }
734 
735  // Verify that all the NFTs are owned by buyer.
736  Json::Value buyerNFTs = [&env, &buyer]() {
737  Json::Value params;
738  params[jss::account] = buyer.human();
739  params[jss::type] = "state";
740  return env.rpc("json", "account_nfts", to_string(params));
741  }();
742 
743  BEAST_EXPECT(
744  buyerNFTs[jss::result][jss::account_nfts].size() == nftIDs.size());
745  for (Json::Value const& ownedNFT :
746  buyerNFTs[jss::result][jss::account_nfts])
747  {
748  uint256 ownedID;
749  BEAST_EXPECT(
750  ownedID.parseHex(ownedNFT[sfNFTokenID.jsonName].asString()));
751  auto const foundIter =
752  std::find(nftIDs.begin(), nftIDs.end(), ownedID);
753 
754  // Assuming we find the NFT, erase it so we know it's been found
755  // and can't be found again.
756  if (BEAST_EXPECT(foundIter != nftIDs.end()))
757  nftIDs.erase(foundIter);
758  }
759 
760  // All NFTs should now be accounted for, so nftIDs should be empty.
761  BEAST_EXPECT(nftIDs.empty());
762 
763  // Show that Without fixNFTokenDirV1 no more NFTs can be added to
764  // buyer. Also show that fixNFTokenDirV1 fixes the problem.
765  TER const expect = features[fixNFTokenDirV1]
766  ? static_cast<TER>(tesSUCCESS)
767  : static_cast<TER>(tecNO_SUITABLE_NFTOKEN_PAGE);
768  env(token::mint(buyer, 0), txflags(tfTransferable), ter(expect));
769  env.close();
770  }
771 
772  void
773  testConsecutivePacking(FeatureBitset features)
774  {
775  // We'll make a worst case scenario for NFT packing:
776  //
777  // 1. 33 accounts with identical low-32 bits mint 7 consecutive NFTs.
778  // 2. The taxon is manipulated to always be stored as zero.
779  // 3. A single account buys all 7x32 of the 33 NFTs.
780  //
781  // All of the NFTs should be acquired by the buyer.
782  //
783  // Lastly, none of the remaining NFTs should be acquirable by the
784  // buyer. They would cause page overflow.
785 
786  // This test collapses in a heap if fixNFTokenDirV1 is not enabled.
787  // If it is enabled just return so we skip the test.
788  if (!features[fixNFTokenDirV1])
789  return;
790 
791  testcase("NFToken consecutive packing");
792 
793  using namespace test::jtx;
794 
795  Env env{*this, features};
796 
797  // Eventually all of the NFTokens will be owned by buyer.
798  Account const buyer{"buyer"};
799  env.fund(XRP(10000), buyer);
800  env.close();
801 
802  // Here are 33 seeds that produce identical low 32-bits in their
803  // corresponding AccountIDs.
804  static std::initializer_list<std::string_view const> const seeds{
805  "sp6JS7f14BuwFY8Mw56vZeiBuhePx", // 0. 0x115d0525
806  "sp6JS7f14BuwFY8Mw5BodF9tGuTUe", // 1. 0x115d0525
807  "sp6JS7f14BuwFY8Mw5EnhC1cg84J7", // 2. 0x115d0525
808  "sp6JS7f14BuwFY8Mw5P913Cunr2BK", // 3. 0x115d0525
809  "sp6JS7f14BuwFY8Mw5Pru7eLo1XzT", // 4. 0x115d0525
810  "sp6JS7f14BuwFY8Mw61SLUC8UX2m8", // 5. 0x115d0525
811  "sp6JS7f14BuwFY8Mw6AsBF9TpeMpq", // 6. 0x115d0525
812  "sp6JS7f14BuwFY8Mw84XqrBZkU2vE", // 7. 0x115d0525
813  "sp6JS7f14BuwFY8Mw89oSU6dBk3KB", // 8. 0x115d0525
814  "sp6JS7f14BuwFY8Mw89qUKCyDmyzj", // 9. 0x115d0525
815  "sp6JS7f14BuwFY8Mw8GfqQ9VRZ8tm", // 10. 0x115d0525
816  "sp6JS7f14BuwFY8Mw8LtW3VqrqMks", // 11. 0x115d0525
817  "sp6JS7f14BuwFY8Mw8ZrAkJc2sHew", // 12. 0x115d0525
818  "sp6JS7f14BuwFY8Mw8jpkYSNrD3ah", // 13. 0x115d0525
819  "sp6JS7f14BuwFY8MwF2mshd786m3V", // 14. 0x115d0525
820  "sp6JS7f14BuwFY8MwFHfXq9x5NbPY", // 15. 0x115d0525
821  "sp6JS7f14BuwFY8MwFrjWq5LAB8NT", // 16. 0x115d0525
822  "sp6JS7f14BuwFY8Mwj4asgSh6hQZd", // 17. 0x115d0525
823  "sp6JS7f14BuwFY8Mwj7ipFfqBSRrE", // 18. 0x115d0525
824  "sp6JS7f14BuwFY8MwjHqtcvGav8uW", // 19. 0x115d0525
825  "sp6JS7f14BuwFY8MwjLp4sk5fmzki", // 20. 0x115d0525
826  "sp6JS7f14BuwFY8MwjioHuYb3Ytkx", // 21. 0x115d0525
827  "sp6JS7f14BuwFY8MwkRjHPXWi7fGN", // 22. 0x115d0525
828  "sp6JS7f14BuwFY8MwkdVdPV3LjNN1", // 23. 0x115d0525
829  "sp6JS7f14BuwFY8MwkxUtVY5AXZFk", // 24. 0x115d0525
830  "sp6JS7f14BuwFY8Mwm4jQzdfTbY9F", // 25. 0x115d0525
831  "sp6JS7f14BuwFY8MwmCucYAqNp4iF", // 26. 0x115d0525
832  "sp6JS7f14BuwFY8Mwo2bgdFtxBzpF", // 27. 0x115d0525
833  "sp6JS7f14BuwFY8MwoGwD7v4U6qBh", // 28. 0x115d0525
834  "sp6JS7f14BuwFY8MwoUczqFADMoXi", // 29. 0x115d0525
835  "sp6JS7f14BuwFY8MwoY1xZeGd3gAr", // 30. 0x115d0525
836  "sp6JS7f14BuwFY8MwomVCbfkv4kYZ", // 31. 0x115d0525
837  "sp6JS7f14BuwFY8MwoqbrPSr4z13F", // 32. 0x115d0525
838  };
839 
840  // Create accounts for all of the seeds and fund those accounts.
841  std::vector<Account> accounts;
842  accounts.reserve(seeds.size());
843  for (std::string_view const& seed : seeds)
844  {
845  Account const& account =
846  accounts.emplace_back(Account::base58Seed, std::string(seed));
847  env.fund(XRP(10000), account);
848 
849  // Do not close the ledger inside the loop. If
850  // fixNFTokenRemint is enabled and accounts are initialized
851  // at different ledgers, they will have different account
852  // sequences. That would cause the accounts to have
853  // different NFTokenID sequence numbers.
854  }
855  env.close();
856 
857  // All of the accounts create seven consecutive NFTs and and offer
858  // those NFTs to buyer.
859  std::array<std::vector<uint256>, 7> nftIDsByPage;
860  for (auto& vec : nftIDsByPage)
861  vec.reserve(accounts.size());
862  std::array<std::vector<uint256>, 7> offers;
863  for (auto& vec : offers)
864  vec.reserve(accounts.size());
865  for (std::size_t i = 0; i < nftIDsByPage.size(); ++i)
866  {
867  for (Account const& account : accounts)
868  {
869  // Mint the NFT. Tweak the taxon so zero is always stored.
870  std::uint32_t taxon =
871  toUInt32(nft::cipheredTaxon(i, nft::toTaxon(0)));
872 
873  uint256 const& nftID = nftIDsByPage[i].emplace_back(
874  token::getNextID(env, account, taxon, tfTransferable));
875  env(token::mint(account, taxon), txflags(tfTransferable));
876  env.close();
877 
878  // Create an offer to give the NFT to buyer for free.
879  offers[i].emplace_back(
880  keylet::nftoffer(account, env.seq(account)).key);
881  env(token::createOffer(account, nftID, XRP(0)),
882  token::destination(buyer),
883  txflags((tfSellNFToken)));
884  }
885  }
886  env.close();
887 
888  // Verify that the low 96 bits of all generated NFTs of the same
889  // sequence is identical.
890  for (auto const& vec : nftIDsByPage)
891  {
892  uint256 const expectLowBits = vec.front() & nft::pageMask;
893  for (uint256 const& nftID : vec)
894  {
895  BEAST_EXPECT(expectLowBits == (nftID & nft::pageMask));
896  }
897  }
898 
899  // Remove one NFT and offer from each of the vectors. These offers
900  // are the ones that will overflow the page.
901  std::vector<uint256> overflowNFTs;
902  overflowNFTs.reserve(nftIDsByPage.size());
903  std::vector<uint256> overflowOffers;
904  overflowOffers.reserve(nftIDsByPage.size());
905 
906  for (std::size_t i = 0; i < nftIDsByPage.size(); ++i)
907  {
908  overflowNFTs.push_back(nftIDsByPage[i].back());
909  nftIDsByPage[i].pop_back();
910  BEAST_EXPECT(nftIDsByPage[i].size() == seeds.size() - 1);
911 
912  overflowOffers.push_back(offers[i].back());
913  offers[i].pop_back();
914  BEAST_EXPECT(offers[i].size() == seeds.size() - 1);
915  }
916 
917  // buyer accepts all of the offers that won't cause an overflow.
918  // Fill the center and outsides first to exercise different boundary
919  // cases.
920  for (int i : std::initializer_list<int>{3, 6, 0, 1, 2, 5, 4})
921  {
922  for (uint256 const& offer : offers[i])
923  {
924  env(token::acceptSellOffer(buyer, offer));
925  env.close();
926  }
927  }
928 
929  // buyer accepts the seven offers that would cause page overflows if
930  // the transaction succeeded.
931  for (uint256 const& offer : overflowOffers)
932  {
933  env(token::acceptSellOffer(buyer, offer),
934  ter(tecNO_SUITABLE_NFTOKEN_PAGE));
935  env.close();
936  }
937 
938  // Verify that all expected NFTs are owned by buyer and findable in
939  // the ledger by having buyer create sell offers for all of their NFTs.
940  // Attempting to sell an offer that the ledger can't find generates
941  // a non-tesSUCCESS error code.
942  for (auto const& vec : nftIDsByPage)
943  {
944  for (uint256 const& nftID : vec)
945  {
946  env(token::createOffer(buyer, nftID, XRP(100)),
947  txflags(tfSellNFToken));
948  env.close();
949  }
950  }
951 
952  // See what the account_objects command does with "nft_offer".
953  {
954  Json::Value ownedNftOffers(Json::arrayValue);
955  std::string marker;
956  do
957  {
958  Json::Value buyerOffers = [&env, &buyer, &marker]() {
959  Json::Value params;
960  params[jss::account] = buyer.human();
961  params[jss::type] = jss::nft_offer;
962 
963  if (!marker.empty())
964  params[jss::marker] = marker;
965  return env.rpc(
966  "json", "account_objects", to_string(params));
967  }();
968 
969  marker.clear();
970  if (buyerOffers.isMember(jss::result))
971  {
972  Json::Value& result = buyerOffers[jss::result];
973 
974  if (result.isMember(jss::marker))
975  marker = result[jss::marker].asString();
976 
977  if (result.isMember(jss::account_objects))
978  {
979  Json::Value& someOffers = result[jss::account_objects];
980  for (std::size_t i = 0; i < someOffers.size(); ++i)
981  ownedNftOffers.append(someOffers[i]);
982  }
983  }
984  } while (!marker.empty());
985 
986  // Verify there are as many offers are there are NFTs.
987  {
988  std::size_t totalOwnedNFTs = 0;
989  for (auto const& vec : nftIDsByPage)
990  totalOwnedNFTs += vec.size();
991  BEAST_EXPECT(ownedNftOffers.size() == totalOwnedNFTs);
992  }
993 
994  // Cancel all the offers.
995  {
996  std::vector<uint256> cancelOffers;
997  cancelOffers.reserve(ownedNftOffers.size());
998 
999  for (auto const& offer : ownedNftOffers)
1000  {
1001  if (offer.isMember(jss::index))
1002  {
1003  uint256 offerIndex;
1004  if (offerIndex.parseHex(offer[jss::index].asString()))
1005  cancelOffers.push_back(offerIndex);
1006  }
1007  }
1008  env(token::cancelOffer(buyer, cancelOffers));
1009  env.close();
1010  }
1011 
1012  // account_objects should no longer return any "nft_offer"s.
1013  Json::Value remainingOffers = [&env, &buyer]() {
1014  Json::Value params;
1015  params[jss::account] = buyer.human();
1016  params[jss::type] = jss::nft_offer;
1017 
1018  return env.rpc("json", "account_objects", to_string(params));
1019  }();
1020  BEAST_EXPECT(
1021  remainingOffers.isMember(jss::result) &&
1022  remainingOffers[jss::result].isMember(jss::account_objects) &&
1023  remainingOffers[jss::result][jss::account_objects].size() == 0);
1024  }
1025 
1026  // Verify that the ledger reports all of the NFTs owned by buyer.
1027  // Use the account_nfts rpc call to get the values.
1028  Json::Value ownedNFTs(Json::arrayValue);
1029  std::string marker;
1030  do
1031  {
1032  Json::Value buyerNFTs = [&env, &buyer, &marker]() {
1033  Json::Value params;
1034  params[jss::account] = buyer.human();
1035  params[jss::type] = "state";
1036 
1037  if (!marker.empty())
1038  params[jss::marker] = marker;
1039  return env.rpc("json", "account_nfts", to_string(params));
1040  }();
1041 
1042  marker.clear();
1043  if (buyerNFTs.isMember(jss::result))
1044  {
1045  Json::Value& result = buyerNFTs[jss::result];
1046 
1047  if (result.isMember(jss::marker))
1048  marker = result[jss::marker].asString();
1049 
1050  if (result.isMember(jss::account_nfts))
1051  {
1052  Json::Value& someNFTs = result[jss::account_nfts];
1053  for (std::size_t i = 0; i < someNFTs.size(); ++i)
1054  ownedNFTs.append(someNFTs[i]);
1055  }
1056  }
1057  } while (!marker.empty());
1058 
1059  // Copy all of the nftIDs into a set to make validation easier.
1060  std::set<uint256> allNftIDs;
1061  for (auto& vec : nftIDsByPage)
1062  allNftIDs.insert(vec.begin(), vec.end());
1063 
1064  BEAST_EXPECT(ownedNFTs.size() == allNftIDs.size());
1065 
1066  for (Json::Value const& ownedNFT : ownedNFTs)
1067  {
1068  if (ownedNFT.isMember(sfNFTokenID.jsonName))
1069  {
1070  uint256 ownedID;
1071  BEAST_EXPECT(ownedID.parseHex(
1072  ownedNFT[sfNFTokenID.jsonName].asString()));
1073  auto const foundIter = allNftIDs.find(ownedID);
1074 
1075  // Assuming we find the NFT, erase it so we know it's been found
1076  // and can't be found again.
1077  if (BEAST_EXPECT(foundIter != allNftIDs.end()))
1078  allNftIDs.erase(foundIter);
1079  }
1080  }
1081 
1082  // All NFTs should now be accounted for, so allNftIDs should be empty.
1083  BEAST_EXPECT(allNftIDs.empty());
1084  }
1085 
1086  void
1087  testWithFeats(FeatureBitset features)
1088  {
1089  testConsecutiveNFTs(features);
1090  testLopsidedSplits(features);
1091  testFixNFTokenDirV1(features);
1092  testTooManyEquivalent(features);
1093  testConsecutivePacking(features);
1094  }
1095 
1096 public:
1097  void
1098  run() override
1099  {
1100  using namespace test::jtx;
1101  FeatureBitset const all{supported_amendments()};
1102  FeatureBitset const fixNFTDir{
1103  fixNFTokenDirV1, featureNonFungibleTokensV1_1};
1104 
1105  testWithFeats(all - fixNFTDir - fixNFTokenRemint);
1106  testWithFeats(all - fixNFTokenRemint);
1107  testWithFeats(all);
1108  }
1109 };
1110 
1111 BEAST_DEFINE_TESTSUITE_PRIO(NFTokenDir, tx, ripple, 1);
1112 
1113 } // namespace ripple
1114 
1115 // Seed that produces an account with the low-32 bits == 0xFFFFFFFF in
1116 // case it is needed for future testing:
1117 //
1118 // sp6JS7f14BuwFY8MwFe95Vpi9Znjs
1119 //
1120 
1121 // Sets of related accounts.
1122 //
1123 // Identifying the seeds of accounts that generate account IDs with the
1124 // same low 32 bits takes a while. However several sets of accounts with
1125 // that relationship have been located. In case these sets of accounts are
1126 // needed for future testing scenarios they are recorded below.
1127 #if 0
1128 34 account seeds that produce account IDs with low 32-bits 0x399187e9:
1129  sp6JS7f14BuwFY8Mw5EYu5z86hKDL
1130  sp6JS7f14BuwFY8Mw5PUAMwc5ygd7
1131  sp6JS7f14BuwFY8Mw5R3xUBcLSeTs
1132  sp6JS7f14BuwFY8Mw5W6oS5sdC3oF
1133  sp6JS7f14BuwFY8Mw5pYc3D9iuLcw
1134  sp6JS7f14BuwFY8Mw5pfGVnhcdp3b
1135  sp6JS7f14BuwFY8Mw6jS6RdEqXqrN
1136  sp6JS7f14BuwFY8Mw6krt6AKbvRXW
1137  sp6JS7f14BuwFY8Mw6mnVBQq7cAN2
1138  sp6JS7f14BuwFY8Mw8ECJxPjmkufQ
1139  sp6JS7f14BuwFY8Mw8asgzcceGWYm
1140  sp6JS7f14BuwFY8MwF6J3FXnPCgL8
1141  sp6JS7f14BuwFY8MwFEud2w5czv5q
1142  sp6JS7f14BuwFY8MwFNxKVqJnx8P5
1143  sp6JS7f14BuwFY8MwFnTCXg3eRidL
1144  sp6JS7f14BuwFY8Mwj47hv1vrDge6
1145  sp6JS7f14BuwFY8Mwj6TYekeeyukh
1146  sp6JS7f14BuwFY8MwjFjsRDerz7jb
1147  sp6JS7f14BuwFY8Mwjrj9mHTLBrcX
1148  sp6JS7f14BuwFY8MwkKcJi3zMzAea
1149  sp6JS7f14BuwFY8MwkYTDdnYRm9z4
1150  sp6JS7f14BuwFY8Mwkq8ei4D8uPNd
1151  sp6JS7f14BuwFY8Mwm2pFruxbnJRd
1152  sp6JS7f14BuwFY8MwmJV2ZnAjpC2g
1153  sp6JS7f14BuwFY8MwmTFMPHQHfVYF
1154  sp6JS7f14BuwFY8MwmkG2jXEgqiud
1155  sp6JS7f14BuwFY8Mwms3xEh5tMDTw
1156  sp6JS7f14BuwFY8MwmtipW4D8giZ9
1157  sp6JS7f14BuwFY8MwoRQBZm4KUUeE
1158  sp6JS7f14BuwFY8MwoVey94QpXcrc
1159  sp6JS7f14BuwFY8MwoZiuUoUTo3VG
1160  sp6JS7f14BuwFY8MwonFFDLT4bHAZ
1161  sp6JS7f14BuwFY8MwooGphD4hefBQ
1162  sp6JS7f14BuwFY8MwoxDp3dmX6q5N
1163 
1164 34 account seeds that produce account IDs with low 32-bits 0x473f2c9a:
1165  sp6JS7f14BuwFY8Mw53ktgqmv5Bmz
1166  sp6JS7f14BuwFY8Mw5KPb2Kz7APFX
1167  sp6JS7f14BuwFY8Mw5Xx4A6HRTPEE
1168  sp6JS7f14BuwFY8Mw5y6qZFNAo358
1169  sp6JS7f14BuwFY8Mw6kdaBg1QrZfn
1170  sp6JS7f14BuwFY8Mw8QmTfLMAZ5K1
1171  sp6JS7f14BuwFY8Mw8cbRRVcCEELr
1172  sp6JS7f14BuwFY8Mw8gQvJebmxvDG
1173  sp6JS7f14BuwFY8Mw8qPQurwu3P7Y
1174  sp6JS7f14BuwFY8MwFS4PEVKmuPy5
1175  sp6JS7f14BuwFY8MwFUQM1rAsQ8tS
1176  sp6JS7f14BuwFY8MwjJBZCkuwsRnM
1177  sp6JS7f14BuwFY8MwjTdS8vZhX5E9
1178  sp6JS7f14BuwFY8MwjhSmWCbNhd25
1179  sp6JS7f14BuwFY8MwjwkpqwZsDBw9
1180  sp6JS7f14BuwFY8MwjyET4p6eqd5J
1181  sp6JS7f14BuwFY8MwkMNAe4JhnG7E
1182  sp6JS7f14BuwFY8MwkRRpnT93UWWS
1183  sp6JS7f14BuwFY8MwkY9CvB22RvUe
1184  sp6JS7f14BuwFY8Mwkhw9VxXqmTr7
1185  sp6JS7f14BuwFY8MwkmgaTat7eFa7
1186  sp6JS7f14BuwFY8Mwkq5SxGGv1oLH
1187  sp6JS7f14BuwFY8MwmCBM5p5bTg6y
1188  sp6JS7f14BuwFY8MwmmmXaVah64dB
1189  sp6JS7f14BuwFY8Mwo7R7Cn614v9V
1190  sp6JS7f14BuwFY8MwoCAG1na7GR2M
1191  sp6JS7f14BuwFY8MwoDuPvJS4gG7C
1192  sp6JS7f14BuwFY8MwoMMowSyPQLfy
1193  sp6JS7f14BuwFY8MwoRqDiwTNsTBm
1194  sp6JS7f14BuwFY8MwoWbBWtjpB7pg
1195  sp6JS7f14BuwFY8Mwoi1AEeELGecF
1196  sp6JS7f14BuwFY8MwopGP6Lo5byuj
1197  sp6JS7f14BuwFY8MwoufkXGHp2VW8
1198  sp6JS7f14BuwFY8MwowGeagFQY32k
1199 
1200 34 account seeds that produce account IDs with low 32-bits 0x4d59f0d1:
1201  sp6JS7f14BuwFY8Mw5CsNgH64zxK7
1202  sp6JS7f14BuwFY8Mw5Dg4wi2E344h
1203  sp6JS7f14BuwFY8Mw5ErV949Zh2PX
1204  sp6JS7f14BuwFY8Mw5p4nsQvEUE1s
1205  sp6JS7f14BuwFY8Mw8LGnkbaP68Gn
1206  sp6JS7f14BuwFY8Mw8aq6RCBc3iHo
1207  sp6JS7f14BuwFY8Mw8bkWaGoKYT6e
1208  sp6JS7f14BuwFY8Mw8qrCuXnzAXVj
1209  sp6JS7f14BuwFY8MwFDKcPAHPHJTm
1210  sp6JS7f14BuwFY8MwFUXJs4unfgNu
1211  sp6JS7f14BuwFY8MwFj9Yv5LjshD9
1212  sp6JS7f14BuwFY8Mwj3H73nmq5UaC
1213  sp6JS7f14BuwFY8MwjHSYShis1Yhk
1214  sp6JS7f14BuwFY8MwjpfE1HVo8UP1
1215  sp6JS7f14BuwFY8Mwk6JE1SXUuiNc
1216  sp6JS7f14BuwFY8MwkASgxEjEnFmU
1217  sp6JS7f14BuwFY8MwkGNY8kg7R6RK
1218  sp6JS7f14BuwFY8MwkHinNZ8SYBQu
1219  sp6JS7f14BuwFY8MwkXLCW1hbhGya
1220  sp6JS7f14BuwFY8MwkZ7mWrYK9YtU
1221  sp6JS7f14BuwFY8MwkdFSqNB5DbKL
1222  sp6JS7f14BuwFY8Mwm3jdBaCAx8H6
1223  sp6JS7f14BuwFY8Mwm3rk5hEwDRtY
1224  sp6JS7f14BuwFY8Mwm77a2ULuwxu4
1225  sp6JS7f14BuwFY8MwmJpY7braKLaN
1226  sp6JS7f14BuwFY8MwmKHQjG4XiZ6g
1227  sp6JS7f14BuwFY8Mwmmv8Y3wyUDzs
1228  sp6JS7f14BuwFY8MwmucFe1WgqtwG
1229  sp6JS7f14BuwFY8Mwo1EjdU1bznZR
1230  sp6JS7f14BuwFY8MwoJiqankkU5uR
1231  sp6JS7f14BuwFY8MwoLnvQ6zdqbKw
1232  sp6JS7f14BuwFY8MwoUGeJ319eu48
1233  sp6JS7f14BuwFY8MwoYf135tQjHP4
1234  sp6JS7f14BuwFY8MwogeF6M6SAyid
1235 
1236 34 account seeds that produce account IDs with low 32-bits 0xabb11898:
1237  sp6JS7f14BuwFY8Mw5DgiYaNVSb1G
1238  sp6JS7f14BuwFY8Mw5k6e94TMvuox
1239  sp6JS7f14BuwFY8Mw5tTSN7KzYxiT
1240  sp6JS7f14BuwFY8Mw61XV6m33utif
1241  sp6JS7f14BuwFY8Mw87jKfrjiENCb
1242  sp6JS7f14BuwFY8Mw8AFtxxFiRtJG
1243  sp6JS7f14BuwFY8Mw8cosAVExzbeE
1244  sp6JS7f14BuwFY8Mw8fmkQ63zE8WQ
1245  sp6JS7f14BuwFY8Mw8iYSsxNbDN6D
1246  sp6JS7f14BuwFY8Mw8wTZdGRJyyM1
1247  sp6JS7f14BuwFY8Mw8z7xEh3qBGr7
1248  sp6JS7f14BuwFY8MwFL5gpKQWZj7g
1249  sp6JS7f14BuwFY8MwFPeZchXQnRZ5
1250  sp6JS7f14BuwFY8MwFSPxWSJVoU29
1251  sp6JS7f14BuwFY8MwFYyVkqX8kvRm
1252  sp6JS7f14BuwFY8MwFcbVikUEwJvk
1253  sp6JS7f14BuwFY8MwjF7NcZk1NctK
1254  sp6JS7f14BuwFY8MwjJCwYr9zSfAv
1255  sp6JS7f14BuwFY8MwjYa5yLkgCLuT
1256  sp6JS7f14BuwFY8MwjenxuJ3TH2Bc
1257  sp6JS7f14BuwFY8MwjriN7Ui11NzB
1258  sp6JS7f14BuwFY8Mwk3AuoJNSEo34
1259  sp6JS7f14BuwFY8MwkT36hnRv8hTo
1260  sp6JS7f14BuwFY8MwkTQixEXfi1Cr
1261  sp6JS7f14BuwFY8MwkYJaZM1yTJBF
1262  sp6JS7f14BuwFY8Mwkc4k1uo85qp2
1263  sp6JS7f14BuwFY8Mwkf7cFhF1uuxx
1264  sp6JS7f14BuwFY8MwmCK2un99wb4e
1265  sp6JS7f14BuwFY8MwmETztNHYu2Bx
1266  sp6JS7f14BuwFY8MwmJws9UwRASfR
1267  sp6JS7f14BuwFY8MwoH5PQkGK8tEb
1268  sp6JS7f14BuwFY8MwoVXtP2yCzjJV
1269  sp6JS7f14BuwFY8MwobxRXA9vsTeX
1270  sp6JS7f14BuwFY8Mwos3pc5Gb3ihU
1271 
1272 34 account seeds that produce account IDs with low 32-bits 0xce627322:
1273  sp6JS7f14BuwFY8Mw5Ck6i83pGNh3
1274  sp6JS7f14BuwFY8Mw5FKuwTxjAdH1
1275  sp6JS7f14BuwFY8Mw5FVKkEn6TkLH
1276  sp6JS7f14BuwFY8Mw5NbQwLwHDd5v
1277  sp6JS7f14BuwFY8Mw5X1dbz3msZaZ
1278  sp6JS7f14BuwFY8Mw6qv6qaXNeP74
1279  sp6JS7f14BuwFY8Mw81SXagUeutCw
1280  sp6JS7f14BuwFY8Mw84Ph7Qa8kwwk
1281  sp6JS7f14BuwFY8Mw8Hp4gFyU3Qko
1282  sp6JS7f14BuwFY8Mw8Kt8bAKredSx
1283  sp6JS7f14BuwFY8Mw8XHK3VKRQ7v7
1284  sp6JS7f14BuwFY8Mw8eGyWxZGHY6v
1285  sp6JS7f14BuwFY8Mw8iU5CLyHVcD2
1286  sp6JS7f14BuwFY8Mw8u3Zr26Ar914
1287  sp6JS7f14BuwFY8MwF2Kcdxtjzjv8
1288  sp6JS7f14BuwFY8MwFLmPWb6rbxNg
1289  sp6JS7f14BuwFY8MwFUu8s7UVuxuJ
1290  sp6JS7f14BuwFY8MwFYBaatwHxAJ8
1291  sp6JS7f14BuwFY8Mwjg6hFkeHwoqG
1292  sp6JS7f14BuwFY8MwjjycJojy2ufk
1293  sp6JS7f14BuwFY8MwkEWoxcSKGPXv
1294  sp6JS7f14BuwFY8MwkMe7wLkEUsQT
1295  sp6JS7f14BuwFY8MwkvyKLaPUc4FS
1296  sp6JS7f14BuwFY8Mwm8doqXPKZmVQ
1297  sp6JS7f14BuwFY8Mwm9r3No8yQ8Tx
1298  sp6JS7f14BuwFY8Mwm9w6dks68W9B
1299  sp6JS7f14BuwFY8MwmMPrv9sCdbpS
1300  sp6JS7f14BuwFY8MwmPAvs3fcQNja
1301  sp6JS7f14BuwFY8MwmS5jasapfcnJ
1302  sp6JS7f14BuwFY8MwmU2L3qJEhnuA
1303  sp6JS7f14BuwFY8MwoAQYmiBnW7fM
1304  sp6JS7f14BuwFY8MwoBkkkXrPmkKF
1305  sp6JS7f14BuwFY8MwonfmxPo6tkvC
1306  sp6JS7f14BuwFY8MwouZFwhiNcYq6
1307 
1308 34 account seeds that produce account IDs with low 32-bits 0xe29643e8:
1309  sp6JS7f14BuwFY8Mw5EfAavcXAh2k
1310  sp6JS7f14BuwFY8Mw5LhFjLkFSCVF
1311  sp6JS7f14BuwFY8Mw5bRfEv5HgdBh
1312  sp6JS7f14BuwFY8Mw5d6sPcKzypKN
1313  sp6JS7f14BuwFY8Mw5rcqDtk1fACP
1314  sp6JS7f14BuwFY8Mw5xkxRq1Notzv
1315  sp6JS7f14BuwFY8Mw66fbkdw5WYmt
1316  sp6JS7f14BuwFY8Mw6diEG8sZ7Fx7
1317  sp6JS7f14BuwFY8Mw6v2r1QhG7xc1
1318  sp6JS7f14BuwFY8Mw6zP6DHCTx2Fd
1319  sp6JS7f14BuwFY8Mw8B3n39JKuFkk
1320  sp6JS7f14BuwFY8Mw8FmBvqYw7uqn
1321  sp6JS7f14BuwFY8Mw8KEaftb1eRwu
1322  sp6JS7f14BuwFY8Mw8WJ1qKkegj9N
1323  sp6JS7f14BuwFY8Mw8r8cAZEkq2BS
1324  sp6JS7f14BuwFY8MwFKPxxwF65gZh
1325  sp6JS7f14BuwFY8MwFKhaF8APcN5H
1326  sp6JS7f14BuwFY8MwFN2buJn4BgYC
1327  sp6JS7f14BuwFY8MwFUTe175MjP3x
1328  sp6JS7f14BuwFY8MwFZhmRDb53NNb
1329  sp6JS7f14BuwFY8MwFa2Azn5nU2WS
1330  sp6JS7f14BuwFY8MwjNNt91hwgkn7
1331  sp6JS7f14BuwFY8MwjdiYt6ChACe7
1332  sp6JS7f14BuwFY8Mwk5qFVQ48Mmr9
1333  sp6JS7f14BuwFY8MwkGvCj7pNf1zG
1334  sp6JS7f14BuwFY8MwkY9UcN2D2Fzs
1335  sp6JS7f14BuwFY8MwkpGvSk9G9RyT
1336  sp6JS7f14BuwFY8MwmGQ7nJf1eEzV
1337  sp6JS7f14BuwFY8MwmQLjGsYdyAmV
1338  sp6JS7f14BuwFY8MwmZ8usztKvikT
1339  sp6JS7f14BuwFY8MwobyMLC2hQdFR
1340  sp6JS7f14BuwFY8MwoiRtwUecZeJ5
1341  sp6JS7f14BuwFY8MwojHjKsUzj1KJ
1342  sp6JS7f14BuwFY8Mwop29anGAjidU
1343 
1344 33 account seeds that produce account IDs with low 32-bits 0x115d0525:
1345  sp6JS7f14BuwFY8Mw56vZeiBuhePx
1346  sp6JS7f14BuwFY8Mw5BodF9tGuTUe
1347  sp6JS7f14BuwFY8Mw5EnhC1cg84J7
1348  sp6JS7f14BuwFY8Mw5P913Cunr2BK
1349  sp6JS7f14BuwFY8Mw5Pru7eLo1XzT
1350  sp6JS7f14BuwFY8Mw61SLUC8UX2m8
1351  sp6JS7f14BuwFY8Mw6AsBF9TpeMpq
1352  sp6JS7f14BuwFY8Mw84XqrBZkU2vE
1353  sp6JS7f14BuwFY8Mw89oSU6dBk3KB
1354  sp6JS7f14BuwFY8Mw89qUKCyDmyzj
1355  sp6JS7f14BuwFY8Mw8GfqQ9VRZ8tm
1356  sp6JS7f14BuwFY8Mw8LtW3VqrqMks
1357  sp6JS7f14BuwFY8Mw8ZrAkJc2sHew
1358  sp6JS7f14BuwFY8Mw8jpkYSNrD3ah
1359  sp6JS7f14BuwFY8MwF2mshd786m3V
1360  sp6JS7f14BuwFY8MwFHfXq9x5NbPY
1361  sp6JS7f14BuwFY8MwFrjWq5LAB8NT
1362  sp6JS7f14BuwFY8Mwj4asgSh6hQZd
1363  sp6JS7f14BuwFY8Mwj7ipFfqBSRrE
1364  sp6JS7f14BuwFY8MwjHqtcvGav8uW
1365  sp6JS7f14BuwFY8MwjLp4sk5fmzki
1366  sp6JS7f14BuwFY8MwjioHuYb3Ytkx
1367  sp6JS7f14BuwFY8MwkRjHPXWi7fGN
1368  sp6JS7f14BuwFY8MwkdVdPV3LjNN1
1369  sp6JS7f14BuwFY8MwkxUtVY5AXZFk
1370  sp6JS7f14BuwFY8Mwm4jQzdfTbY9F
1371  sp6JS7f14BuwFY8MwmCucYAqNp4iF
1372  sp6JS7f14BuwFY8Mwo2bgdFtxBzpF
1373  sp6JS7f14BuwFY8MwoGwD7v4U6qBh
1374  sp6JS7f14BuwFY8MwoUczqFADMoXi
1375  sp6JS7f14BuwFY8MwoY1xZeGd3gAr
1376  sp6JS7f14BuwFY8MwomVCbfkv4kYZ
1377  sp6JS7f14BuwFY8MwoqbrPSr4z13F
1378 
1379 33 account seeds that produce account IDs with low 32-bits 0x304033aa:
1380  sp6JS7f14BuwFY8Mw5DaUP9agF5e1
1381  sp6JS7f14BuwFY8Mw5ohbtmPN4yGN
1382  sp6JS7f14BuwFY8Mw5rRsA5fcoTAQ
1383  sp6JS7f14BuwFY8Mw6zpYHMY3m6KT
1384  sp6JS7f14BuwFY8Mw86BzQq4sTnoW
1385  sp6JS7f14BuwFY8Mw8CCpnfvmGdV7
1386  sp6JS7f14BuwFY8Mw8DRjUDaBcFco
1387  sp6JS7f14BuwFY8Mw8cL7GPo3zZN7
1388  sp6JS7f14BuwFY8Mw8y6aeYVtH6qt
1389  sp6JS7f14BuwFY8MwFZR3PtVTCdUH
1390  sp6JS7f14BuwFY8MwFcdcdbgz7m3s
1391  sp6JS7f14BuwFY8MwjdnJDiUxEBRR
1392  sp6JS7f14BuwFY8MwjhxWgSntqrFe
1393  sp6JS7f14BuwFY8MwjrSHEhZ8CUM1
1394  sp6JS7f14BuwFY8MwjzkEeSTc9ZYf
1395  sp6JS7f14BuwFY8MwkBZSk9JhaeCB
1396  sp6JS7f14BuwFY8MwkGfwNY4i2iiU
1397  sp6JS7f14BuwFY8MwknjtZd2oU2Ff
1398  sp6JS7f14BuwFY8Mwkszsqd3ok9NE
1399  sp6JS7f14BuwFY8Mwm58A81MAMvgZ
1400  sp6JS7f14BuwFY8MwmiPTWysuDJCH
1401  sp6JS7f14BuwFY8MwmxhiNeLfD76r
1402  sp6JS7f14BuwFY8Mwo7SPdkwpGrFH
1403  sp6JS7f14BuwFY8MwoANq4F1Sj3qH
1404  sp6JS7f14BuwFY8MwoVjcHufAkd6L
1405  sp6JS7f14BuwFY8MwoVxHBXdaxzhm
1406  sp6JS7f14BuwFY8MwoZ2oTjBNfLpm
1407  sp6JS7f14BuwFY8Mwoc9swzyotFVD
1408  sp6JS7f14BuwFY8MwogMqVRwVEcQ9
1409  sp6JS7f14BuwFY8MwohMm7WxwnFqH
1410  sp6JS7f14BuwFY8MwopUcpZHuF8BH
1411  sp6JS7f14BuwFY8Mwor6rW6SS7tiB
1412  sp6JS7f14BuwFY8MwoxyaqYz4Ngsb
1413 
1414 33 account seeds that produce account IDs with low 32-bits 0x42d4e09c:
1415  sp6JS7f14BuwFY8Mw58NSZH9EaUxQ
1416  sp6JS7f14BuwFY8Mw5JByk1pgPpL7
1417  sp6JS7f14BuwFY8Mw5YrJJuXnkHVB
1418  sp6JS7f14BuwFY8Mw5kZe2ZzNSnKR
1419  sp6JS7f14BuwFY8Mw6eXHTsbwi1U7
1420  sp6JS7f14BuwFY8Mw6gqN7HHDDKSh
1421  sp6JS7f14BuwFY8Mw6zw8L1sSSR53
1422  sp6JS7f14BuwFY8Mw8E4WqSKKbksy
1423  sp6JS7f14BuwFY8MwF3V9gemqJtND
1424  sp6JS7f14BuwFY8Mwj4j46LHWZuY6
1425  sp6JS7f14BuwFY8MwjF5i8vh4Ezjy
1426  sp6JS7f14BuwFY8MwjJZpEKgMpUAt
1427  sp6JS7f14BuwFY8MwjWL7LfnzNUuh
1428  sp6JS7f14BuwFY8Mwk7Y1csGuqAhX
1429  sp6JS7f14BuwFY8MwkB1HVH17hN5W
1430  sp6JS7f14BuwFY8MwkBntH7BZZupu
1431  sp6JS7f14BuwFY8MwkEy4rMbNHG9P
1432  sp6JS7f14BuwFY8MwkKz4LYesZeiN
1433  sp6JS7f14BuwFY8MwkUrXyo9gMDPM
1434  sp6JS7f14BuwFY8MwkV2hySsxej1G
1435  sp6JS7f14BuwFY8MwkozhTVN12F9C
1436  sp6JS7f14BuwFY8MwkpkzGB3sFJw5
1437  sp6JS7f14BuwFY8Mwks3zDZLGrhdn
1438  sp6JS7f14BuwFY8MwktG1KCS7L2wW
1439  sp6JS7f14BuwFY8Mwm1jVFsafwcYx
1440  sp6JS7f14BuwFY8Mwm8hmrU6g5Wd6
1441  sp6JS7f14BuwFY8MwmFvstfRF7e2f
1442  sp6JS7f14BuwFY8MwmeRohi6m5fs8
1443  sp6JS7f14BuwFY8MwmmU96RHUaRZL
1444  sp6JS7f14BuwFY8MwoDFzteYqaUh4
1445  sp6JS7f14BuwFY8MwoPkTf5tDykPF
1446  sp6JS7f14BuwFY8MwoSbMaDtiMoDN
1447  sp6JS7f14BuwFY8MwoVL1vY1CysjR
1448 
1449 33 account seeds that produce account IDs with low 32-bits 0x9a8ebed3:
1450  sp6JS7f14BuwFY8Mw5FnqmbciPvH6
1451  sp6JS7f14BuwFY8Mw5MBGbyMSsXLp
1452  sp6JS7f14BuwFY8Mw5S4PnDyBdKKm
1453  sp6JS7f14BuwFY8Mw6kcXpM2enE35
1454  sp6JS7f14BuwFY8Mw6tuuSMMwyJ44
1455  sp6JS7f14BuwFY8Mw8E8JWLQ1P8pt
1456  sp6JS7f14BuwFY8Mw8WwdgWkCHhEx
1457  sp6JS7f14BuwFY8Mw8XDUYvU6oGhQ
1458  sp6JS7f14BuwFY8Mw8ceVGL4M1zLQ
1459  sp6JS7f14BuwFY8Mw8fdSwLCZWDFd
1460  sp6JS7f14BuwFY8Mw8zuF6Fg65i1E
1461  sp6JS7f14BuwFY8MwF2k7bihVfqes
1462  sp6JS7f14BuwFY8MwF6X24WXGn557
1463  sp6JS7f14BuwFY8MwFMpn7strjekg
1464  sp6JS7f14BuwFY8MwFSdy9sYVrwJs
1465  sp6JS7f14BuwFY8MwFdMcLy9UkrXn
1466  sp6JS7f14BuwFY8MwFdbwFm1AAboa
1467  sp6JS7f14BuwFY8MwFdr5AhKThVtU
1468  sp6JS7f14BuwFY8MwjFc3Q9YatvAw
1469  sp6JS7f14BuwFY8MwjRXcNs1ozEXn
1470  sp6JS7f14BuwFY8MwkQGUKL7v1FBt
1471  sp6JS7f14BuwFY8Mwkamsoxx1wECt
1472  sp6JS7f14BuwFY8Mwm3hus1dG6U8y
1473  sp6JS7f14BuwFY8Mwm589M8vMRpXF
1474  sp6JS7f14BuwFY8MwmJTRJ4Fqz1A3
1475  sp6JS7f14BuwFY8MwmRfy8fer4QbL
1476  sp6JS7f14BuwFY8MwmkkFx1HtgWRx
1477  sp6JS7f14BuwFY8MwmwP9JFdKa4PS
1478  sp6JS7f14BuwFY8MwoXWJLB3ciHfo
1479  sp6JS7f14BuwFY8MwoYc1gTtT2mWL
1480  sp6JS7f14BuwFY8MwogXtHH7FNVoo
1481  sp6JS7f14BuwFY8MwoqYoA9P8gf3r
1482  sp6JS7f14BuwFY8MwoujwMJofGnsA
1483 
1484 33 account seeds that produce account IDs with low 32-bits 0xa1dcea4a:
1485  sp6JS7f14BuwFY8Mw5Ccov2N36QTy
1486  sp6JS7f14BuwFY8Mw5CuSemVb5p7w
1487  sp6JS7f14BuwFY8Mw5Ep8wpsTfpSz
1488  sp6JS7f14BuwFY8Mw5WtutJc2H45M
1489  sp6JS7f14BuwFY8Mw6vsDeaSKeUJZ
1490  sp6JS7f14BuwFY8Mw83t5BPWUAzzF
1491  sp6JS7f14BuwFY8Mw8FYGnK35mgkV
1492  sp6JS7f14BuwFY8Mw8huo1x5pfKKJ
1493  sp6JS7f14BuwFY8Mw8mPStxfMDrZa
1494  sp6JS7f14BuwFY8Mw8yC3A7aQJytK
1495  sp6JS7f14BuwFY8MwFCWCDmo9o3t8
1496  sp6JS7f14BuwFY8MwFjapa4gKxPhR
1497  sp6JS7f14BuwFY8Mwj8CWtG29uw71
1498  sp6JS7f14BuwFY8MwjHyU5KpEMLVT
1499  sp6JS7f14BuwFY8MwjMZSN7LZuWD8
1500  sp6JS7f14BuwFY8Mwja2TXJNBhKHU
1501  sp6JS7f14BuwFY8Mwjf3xNTopHKTF
1502  sp6JS7f14BuwFY8Mwjn5RAhedPeuM
1503  sp6JS7f14BuwFY8MwkJdr4d6QoE8K
1504  sp6JS7f14BuwFY8MwkmBryo3SUoLm
1505  sp6JS7f14BuwFY8MwkrPdsc4tR8yw
1506  sp6JS7f14BuwFY8Mwkttjcw2a65Fi
1507  sp6JS7f14BuwFY8Mwm19n3rSaNx5S
1508  sp6JS7f14BuwFY8Mwm3ryr4Xp2aQX
1509  sp6JS7f14BuwFY8MwmBnDmgnJLB6B
1510  sp6JS7f14BuwFY8MwmHgPjzrYjthq
1511  sp6JS7f14BuwFY8MwmeV55DAnWKdd
1512  sp6JS7f14BuwFY8Mwo49hK6BGrauT
1513  sp6JS7f14BuwFY8Mwo56vfKY9aoWu
1514  sp6JS7f14BuwFY8MwoU7tTTXLQTrh
1515  sp6JS7f14BuwFY8MwoXpogSF2KaZB
1516  sp6JS7f14BuwFY8MwoY9JYQAR16pc
1517  sp6JS7f14BuwFY8MwoozLzKNAEXKM
1518 
1519 33 account seeds that produce account IDs with low 32-bits 0xbd2116db:
1520  sp6JS7f14BuwFY8Mw5GrpkmPuA3Bw
1521  sp6JS7f14BuwFY8Mw5r1sLoQJZDc6
1522  sp6JS7f14BuwFY8Mw68zzRmezLdd6
1523  sp6JS7f14BuwFY8Mw6jDSyaiF1mRp
1524  sp6JS7f14BuwFY8Mw813wU9u5D6Uh
1525  sp6JS7f14BuwFY8Mw8BBvpf2JFGoJ
1526  sp6JS7f14BuwFY8Mw8F7zXxAiT263
1527  sp6JS7f14BuwFY8Mw8XG7WuVGHP2N
1528  sp6JS7f14BuwFY8Mw8eyWrcz91cz6
1529  sp6JS7f14BuwFY8Mw8yNVKFVYyk9u
1530  sp6JS7f14BuwFY8MwF2oA6ePqvZWP
1531  sp6JS7f14BuwFY8MwF9VkcSNh3keq
1532  sp6JS7f14BuwFY8MwFYsMWajgEf2j
1533  sp6JS7f14BuwFY8Mwj3Gu43jYoJ4n
1534  sp6JS7f14BuwFY8MwjJ5iRmYDHrW4
1535  sp6JS7f14BuwFY8MwjaUSSga93CiM
1536  sp6JS7f14BuwFY8MwjxgLh2FY4Lvt
1537  sp6JS7f14BuwFY8Mwk9hQdNZUgmTB
1538  sp6JS7f14BuwFY8MwkcMXqtFp1sMx
1539  sp6JS7f14BuwFY8MwkzZCDc56jsUB
1540  sp6JS7f14BuwFY8Mwm5Zz7fP24Qym
1541  sp6JS7f14BuwFY8MwmDWqizXSoJRG
1542  sp6JS7f14BuwFY8MwmKHmkNYdMqqi
1543  sp6JS7f14BuwFY8MwmRfAWHxWpGNK
1544  sp6JS7f14BuwFY8MwmjCdXwyhphZ1
1545  sp6JS7f14BuwFY8MwmmukDAm1w6FL
1546  sp6JS7f14BuwFY8Mwmmz2SzaR9TRH
1547  sp6JS7f14BuwFY8Mwmz2z5mKHXzfn
1548  sp6JS7f14BuwFY8Mwo2xNe5629r5k
1549  sp6JS7f14BuwFY8MwoKy8tZxZrfJw
1550  sp6JS7f14BuwFY8MwoLyQ9aMsq8Dm
1551  sp6JS7f14BuwFY8MwoqqYkewuyZck
1552  sp6JS7f14BuwFY8MwouvvhREVp6Pp
1553 
1554 33 account seeds that produce account IDs with low 32-bits 0xd80df065:
1555  sp6JS7f14BuwFY8Mw5B7ERyhAfgHA
1556  sp6JS7f14BuwFY8Mw5VuW3cF7bm2v
1557  sp6JS7f14BuwFY8Mw5py3t1j7YbFT
1558  sp6JS7f14BuwFY8Mw5qc84SzB6RHr
1559  sp6JS7f14BuwFY8Mw5vGHW1G1hAy8
1560  sp6JS7f14BuwFY8Mw6gVa8TYukws6
1561  sp6JS7f14BuwFY8Mw8K9w1RoUAv1w
1562  sp6JS7f14BuwFY8Mw8KvKtB7787CA
1563  sp6JS7f14BuwFY8Mw8Y7WhRbuFzRq
1564  sp6JS7f14BuwFY8Mw8cipw7inRmMn
1565  sp6JS7f14BuwFY8MwFM5fAUNLNB13
1566  sp6JS7f14BuwFY8MwFSe1zAsht3X3
1567  sp6JS7f14BuwFY8MwFYNdigqQuHZM
1568  sp6JS7f14BuwFY8MwjWkejj7V4V5Q
1569  sp6JS7f14BuwFY8Mwjd2JGpsjvynq
1570  sp6JS7f14BuwFY8Mwjg1xkducn751
1571  sp6JS7f14BuwFY8Mwjsp6LnaJvL1W
1572  sp6JS7f14BuwFY8MwjvSbLc9593yH
1573  sp6JS7f14BuwFY8Mwjw2h5wx7U6vZ
1574  sp6JS7f14BuwFY8MwjxKUjtRsmPLH
1575  sp6JS7f14BuwFY8Mwk1Yy8ginDfqv
1576  sp6JS7f14BuwFY8Mwk2HrWhWwZP12
1577  sp6JS7f14BuwFY8Mwk4SsqiexvpWs
1578  sp6JS7f14BuwFY8Mwk66zCs5ACpE6
1579  sp6JS7f14BuwFY8MwkCwx6vY97Nwh
1580  sp6JS7f14BuwFY8MwknrbjnhTTWU8
1581  sp6JS7f14BuwFY8MwkokDy2ShRzQx
1582  sp6JS7f14BuwFY8Mwm3BxnRPNxsuu
1583  sp6JS7f14BuwFY8MwmY9EWdQQsFVr
1584  sp6JS7f14BuwFY8MwmYTWjrDhmk8S
1585  sp6JS7f14BuwFY8Mwo9skXt9Y5BVS
1586  sp6JS7f14BuwFY8MwoZYKZybJ1Crp
1587  sp6JS7f14BuwFY8MwoyXqkhySfSmF
1588 
1589 33 account seeds that produce account IDs with low 32-bits 0xe2e44294:
1590  sp6JS7f14BuwFY8Mw53dmvTgNtBwi
1591  sp6JS7f14BuwFY8Mw5Wrxsqn6WrXW
1592  sp6JS7f14BuwFY8Mw5fGDT31RCXgC
1593  sp6JS7f14BuwFY8Mw5nKRkubwrLWM
1594  sp6JS7f14BuwFY8Mw5nXMajwKjriB
1595  sp6JS7f14BuwFY8Mw5xZybggrC9NG
1596  sp6JS7f14BuwFY8Mw5xea8f6dBMV5
1597  sp6JS7f14BuwFY8Mw5zDGofAHy5Lb
1598  sp6JS7f14BuwFY8Mw6eado41rQNVG
1599  sp6JS7f14BuwFY8Mw6yqKXQsQJPuU
1600  sp6JS7f14BuwFY8Mw83MSN4FDzSGH
1601  sp6JS7f14BuwFY8Mw8B3pUbzQqHe2
1602  sp6JS7f14BuwFY8Mw8WwRLnhBRvfk
1603  sp6JS7f14BuwFY8Mw8hDBpKbpJwJX
1604  sp6JS7f14BuwFY8Mw8jggRSZACe7M
1605  sp6JS7f14BuwFY8Mw8mJRpU3qWbwC
1606  sp6JS7f14BuwFY8MwFDnVozykN21u
1607  sp6JS7f14BuwFY8MwFGGRGY9fctgv
1608  sp6JS7f14BuwFY8MwjKznfChH9DQb
1609  sp6JS7f14BuwFY8MwjbC5GvngRCk6
1610  sp6JS7f14BuwFY8Mwk3Lb7FPe1629
1611  sp6JS7f14BuwFY8MwkCeS41BwVrBD
1612  sp6JS7f14BuwFY8MwkDnnvRyuWJ7d
1613  sp6JS7f14BuwFY8MwkbkRNnzDEFpf
1614  sp6JS7f14BuwFY8MwkiNhaVhGNk6v
1615  sp6JS7f14BuwFY8Mwm1X4UJXRZx3p
1616  sp6JS7f14BuwFY8Mwm7da9q5vfq7J
1617  sp6JS7f14BuwFY8MwmPLqfBPrHw5H
1618  sp6JS7f14BuwFY8MwmbJpxvVjEwm2
1619  sp6JS7f14BuwFY8MwoAVeA7ka37cD
1620  sp6JS7f14BuwFY8MwoTFFTAwFKmVM
1621  sp6JS7f14BuwFY8MwoYsne51VpDE3
1622  sp6JS7f14BuwFY8MwohLVnU1VTk5h
1623 
1624 #endif // 0
ripple::tfTransferable
constexpr const std::uint32_t tfTransferable
Definition: TxFlags.h:130
ripple::NFTokenDir_test::testWithFeats
void testWithFeats(FeatureBitset features)
Definition: NFTokenDir_test.cpp:1087
ripple::tecINVARIANT_FAILED
@ tecINVARIANT_FAILED
Definition: TER.h:280
std::string
STL class.
beast::severities::kDisabled
@ kDisabled
Definition: Journal.h:41
std::string_view
STL class.
ripple::sfNFTokenID
const SF_UINT256 sfNFTokenID
Json::arrayValue
@ arrayValue
array value (ordered list)
Definition: json_value.h:42
std::vector::reserve
T reserve(T... args)
ripple::TxSearched::all
@ all
Json::UInt
unsigned int UInt
Definition: json_forwards.h:27
std::vector
STL class.
std::find
T find(T... args)
std::vector::size
T size(T... args)
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::NFTokenDir_test::testTooManyEquivalent
void testTooManyEquivalent(FeatureBitset features)
Definition: NFTokenDir_test.cpp:606
std::reverse
T reverse(T... args)
Json::Value::toStyledString
std::string toStyledString() const
Definition: json_value.cpp:1039
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::SField::jsonName
const Json::StaticString jsonName
Definition: SField.h:136
std::vector::front
T front(T... args)
std::string::clear
T clear(T... args)
ripple::nft::pageMask
constexpr uint256 pageMask(std::string_view("0000000000000000000000000000000000000000ffffffffffffffffffffffff"))
ripple::fixNFTokenRemint
const uint256 fixNFTokenRemint
std::vector::push_back
T push_back(T... args)
ripple::NFTokenDir_test::testLopsidedSplits
void testLopsidedSplits(FeatureBitset features)
Definition: NFTokenDir_test.cpp:157
std::cout
ripple::Keylet::key
uint256 key
Definition: Keylet.h:40
ripple::base_uint< 256 >
Json::Value::append
Value & append(const Value &value)
Append value to array at the end.
Definition: json_value.cpp:882
ripple::NFTokenDir_test::testFixNFTokenDirV1
void testFixNFTokenDirV1(FeatureBitset features)
Definition: NFTokenDir_test.cpp:380
ripple::NFTokenDir_test::run
void run() override
Definition: NFTokenDir_test.cpp:1098
ripple::TERSubset< CanCvtToTER >
ripple::NFTokenDir_test::printNFTPages
void printNFTPages(test::jtx::Env &env, Volume vol)
Definition: NFTokenDir_test.cpp:42
std::array
STL class.
Json::Value::size
UInt size() const
Number of values in array or object.
Definition: json_value.cpp:706
std::set::erase
T erase(T... args)
ripple::tfSellNFToken
constexpr const std::uint32_t tfSellNFToken
Definition: TxFlags.h:152
ripple::NFTokenDir_test::quiet
@ quiet
Definition: NFTokenDir_test.cpp:37
Json::Value::isMember
bool isMember(const char *key) const
Return true if the object has a member named key.
Definition: json_value.cpp:932
std::uint32_t
ripple::fixNFTokenDirV1
const uint256 fixNFTokenDirV1
ripple::NFTokenDir_test::noisy
@ noisy
Definition: NFTokenDir_test.cpp:38
Json::Value::isArray
bool isArray() const
Definition: json_value.cpp:1015
ripple::sfNFTokens
const SField sfNFTokens
ripple::NFTokenDir_test::testConsecutivePacking
void testConsecutivePacking(FeatureBitset features)
Definition: NFTokenDir_test.cpp:773
std::vector::emplace_back
T emplace_back(T... args)
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
std::endl
T endl(T... args)
ripple::NFTokenDir_test::Volume
Volume
Definition: NFTokenDir_test.cpp:36
std::set::insert
T insert(T... args)
ripple::featureNonFungibleTokensV1_1
const uint256 featureNonFungibleTokensV1_1
ripple::tecNO_SUITABLE_NFTOKEN_PAGE
@ tecNO_SUITABLE_NFTOKEN_PAGE
Definition: TER.h:288
ripple::FeatureBitset
Definition: Feature.h:113
std::string::empty
T empty(T... args)
std::size_t
ripple::to_string
std::string to_string(Manifest const &m)
Format the specified manifest to a string for debugging purposes.
Definition: app/misc/impl/Manifest.cpp:41
std::set::end
T end(T... args)
ripple::base_uint::parseHex
constexpr bool parseHex(std::string_view sv)
Parse a hex string into a base_uint.
Definition: base_uint.h:496
ripple::nft::cipheredTaxon
Taxon cipheredTaxon(std::uint32_t tokenSeq, Taxon taxon)
Definition: NFTokenUtils.h:144
ripple::tesSUCCESS
@ tesSUCCESS
Definition: TER.h:222
std::set
STL class.
ripple::NFTokenDir_test
Definition: NFTokenDir_test.cpp:30
ripple::test::jtx::Env
A transaction testing environment.
Definition: Env.h:116
ripple::NFTokenDir_test::testConsecutiveNFTs
void testConsecutiveNFTs(FeatureBitset features)
Definition: NFTokenDir_test.cpp:100
ripple::test::jtx::Env::rpc
Json::Value rpc(std::unordered_map< std::string, std::string > const &headers, std::string const &cmd, Args &&... args)
Execute an RPC command.
Definition: Env.h:687
Json::Value
Represents a JSON value.
Definition: json_value.h:145
initializer_list
Json::Value::asString
std::string asString() const
Returns the unquoted string value.
Definition: json_value.cpp:469
Generated by   doxygen 1.8.17