194 Env env{*
this, features};
196 Account const minter{
"minter"};
200 auto const acctReserve = env.current()->fees().reserve;
201 auto const incReserve = env.current()->fees().increment;
202 auto const baseFee = env.current()->fees().base;
204 env.fund(acctReserve, alice, minter);
207 BEAST_EXPECT(env.balance(alice) == acctReserve);
208 BEAST_EXPECT(env.balance(minter) == acctReserve);
222 env(pay(env.master, alice, incReserve + drops(baseFee - 1)));
227 auto const checkAliceOwnerMintedBurned =
228 [&env,
this, &alice](
230 auto const oneCheck =
239 ss <<
"Wrong " << type <<
" count. Found: " << found
240 <<
"; Expected: " << exp;
241 fail(ss.
str(), __FILE__, line);
244 oneCheck(
"owner",
ownerCount(env, alice), owners);
245 oneCheck(
"minted",
mintedCount(env, alice), minted);
246 oneCheck(
"burned",
burnedCount(env, alice), burned);
254 checkAliceOwnerMintedBurned(0, 0, 0, __LINE__);
257 env(pay(env.master, alice, drops(baseFee + 1)));
261 env(token::mint(alice));
264 checkAliceOwnerMintedBurned(1, 1, 0, __LINE__);
268 for (
int i = 1; i < 32; ++i)
270 env(token::mint(alice));
271 checkAliceOwnerMintedBurned(1, i + 1, 0, __LINE__);
278 checkAliceOwnerMintedBurned(1, 32, 0, __LINE__);
281 env(pay(env.master, alice, incReserve + drops(baseFee * 33 - 1)));
288 checkAliceOwnerMintedBurned(1, 32, 0, __LINE__);
291 env(pay(env.master, alice, drops(baseFee + 1)));
295 env(token::mint(alice));
297 checkAliceOwnerMintedBurned(2, 33, 0, __LINE__);
304 env(token::burn(alice, token::getID(env, alice, 0, seq++)));
306 checkAliceOwnerMintedBurned(((33 - seq) != 0u) ? 1 : 0, 33, seq, __LINE__);
310 env(token::burn(alice, token::getID(env, alice, 197, 5)), Ter(
tecNO_ENTRY));
312 checkAliceOwnerMintedBurned(0, 33, 33, __LINE__);
317 env(token::setMinter(alice, minter));
319 BEAST_EXPECT(env.le(alice)->getAccountID(sfNFTokenMinter) == minter.id());
323 auto const checkMintersOwnerMintedBurned = [&env,
this, &alice, &minter](
331 auto const oneCheck =
340 ss <<
"Wrong " << type <<
" count. Found: " << found
341 <<
"; Expected: " << exp;
342 fail(ss.
str(), __FILE__, line);
345 oneCheck(
"alice owner",
ownerCount(env, alice), aliceOwners, line);
346 oneCheck(
"alice minted",
mintedCount(env, alice), aliceMinted, line);
347 oneCheck(
"alice burned",
burnedCount(env, alice), aliceBurned, line);
348 oneCheck(
"minter owner",
ownerCount(env, minter), minterOwners, line);
349 oneCheck(
"minter minted",
mintedCount(env, minter), minterMinted, line);
350 oneCheck(
"minter burned",
burnedCount(env, minter), minterBurned, line);
356 env(pay(env.master, minter, incReserve - drops(1)));
358 checkMintersOwnerMintedBurned(0, 33, nftSeq, 0, 0, 0, __LINE__);
363 env(token::mint(minter),
364 token::Issuer(alice),
368 checkMintersOwnerMintedBurned(0, 33, nftSeq, 0, 0, 0, __LINE__);
371 env(pay(env.master, minter, drops(baseFee + 1)));
375 env(token::mint(minter), token::Issuer(alice), token::Uri(
"uri"));
377 checkMintersOwnerMintedBurned(0, 34, nftSeq, 1, 0, 0, __LINE__);
381 for (
int i = 1; i < 32; ++i)
383 env(token::mint(minter), token::Issuer(alice), token::Uri(
"uri"));
384 checkMintersOwnerMintedBurned(0, i + 34, nftSeq, 1, 0, 0, __LINE__);
389 env(pay(env.master, minter, incReserve + drops(baseFee * 32 - 1)));
394 env(token::mint(minter),
395 token::Issuer(alice),
399 checkMintersOwnerMintedBurned(0, 65, nftSeq, 1, 0, 0, __LINE__);
402 env(pay(env.master, minter, drops(baseFee + 1)));
406 env(token::mint(minter), token::Issuer(alice), token::Uri(
"uri"));
408 checkMintersOwnerMintedBurned(0, 66, nftSeq, 2, 0, 0, __LINE__);
413 env(token::burn(minter, token::getID(env, alice, 0, nftSeq++)));
415 checkMintersOwnerMintedBurned(
416 0, 66, nftSeq, ((65 - seq) != 0u) ? 1 : 0, 0, 0, __LINE__);
421 env(token::burn(minter, token::getID(env, alice, 0, nftSeq++)));
423 checkMintersOwnerMintedBurned(0, 66, nftSeq, 0, 0, 0, __LINE__);
426 env(token::burn(minter, token::getID(env, alice, 2009, 3)), Ter(
tecNO_ENTRY));
428 checkMintersOwnerMintedBurned(0, 66, nftSeq, 0, 0, 0, __LINE__);
616 testcase(
"Invalid NFT offer create");
620 Env env{*
this, features};
624 IOU
const gwAUD(gw[
"AUD"]);
629 env.fund(XRP(250), alice, buyer, gw);
633 UInt256 const nftAlice0ID = token::getNextID(env, alice, 0, tfTransferable, 10);
634 env(token::mint(alice, 0u), Txflags(tfTransferable), token::XferFee(10));
638 UInt256 const nftXrpOnlyID = token::getNextID(env, alice, 0, tfOnlyXRP | tfTransferable);
639 env(token::mint(alice, 0), Txflags(tfOnlyXRP | tfTransferable));
643 UInt256 const nftNoXferID = token::getNextID(env, alice, 0);
644 env(token::mint(alice, 0));
657 env(token::createOffer(buyer, nftAlice0ID, XRP(1000)),
664 env(token::createOffer(buyer, nftAlice0ID, XRP(1000)),
671 env(token::createOffer(buyer, nftAlice0ID, XRP(1000)),
678 env(token::createOffer(buyer, nftXrpOnlyID, buyer[
"USD"](1)), Ter(
temBAD_AMOUNT));
679 env(token::createOffer(buyer, nftAlice0ID, buyer[
"USD"](0)), Ter(
temBAD_AMOUNT));
680 env(token::createOffer(buyer, nftXrpOnlyID, drops(0)), Ter(
temBAD_AMOUNT));
685 env(token::createOffer(buyer, nftAlice0ID, buyer[
"USD"](1)),
686 token::Expiration(0),
693 env(token::createOffer(buyer, nftXrpOnlyID, XRP(1000)), Ter(
temMALFORMED));
698 env(token::createOffer(alice, nftXrpOnlyID, XRP(1000)),
700 Txflags(tfSellNFToken),
706 env(token::createOffer(alice, nftXrpOnlyID, XRP(1000)),
713 env(token::createOffer(alice, nftXrpOnlyID, XRP(1000)),
714 token::Destination(alice),
715 Txflags(tfSellNFToken),
721 env(token::createOffer(alice, nftXrpOnlyID, XRP(1000)),
722 token::Destination(
Account(
"demon")),
723 Txflags(tfSellNFToken),
732 env(token::createOffer(buyer, nftXrpOnlyID, XRP(1000)),
740 env(token::createOffer(buyer, token::getID(env, alice, 0, 1), XRP(1000)),
747 env(token::createOffer(alice, token::getID(env, alice, 0, 1), XRP(1000)),
748 Txflags(tfSellNFToken),
754 env(token::createOffer(buyer, nftAlice0ID, gwAUD(1000)),
760 env(trust(buyer, gwAUD(1000)));
766 env(token::createOffer(buyer, nftAlice0ID, gwAUD(1000)),
773 env(trust(gw, alice[
"AUD"](999), tfSetFreeze));
778 env(token::createOffer(buyer, nftAlice0ID, gwAUD(1000)),
785 env(trust(gw, alice[
"AUD"](999), tfClearFreeze));
789 env(token::createOffer(buyer, nftNoXferID, gwAUD(1000)),
796 env(trust(gw, buyer[
"AUD"](999), tfSetFreeze));
799 env(token::createOffer(buyer, nftAlice0ID, gwAUD(1000)),
807 env(trust(gw, buyer[
"AUD"](999), tfClearFreeze));
808 env(trust(buyer, gwAUD(1000)));
811 env(token::createOffer(buyer, nftAlice0ID, gwAUD(1000)),
821 env(pay(gw, buyer, gwAUD(999)));
826 env(token::createOffer(buyer, nftAlice0ID, gwAUD(1000)),
833 auto const baseFee = env.current()->fees().base;
834 env(pay(env.master, buyer, XRP(50) + drops(baseFee * 12 - 1)));
837 env(token::createOffer(buyer, nftAlice0ID, gwAUD(1000)),
844 env(pay(env.master, buyer, drops(baseFee + 1)));
849 env(token::createOffer(buyer, nftAlice0ID, gwAUD(1000)),
994 testcase(
"Invalid NFT offer accept");
998 Env env{*
this, features};
1002 IOU
const gwAUD(gw[
"AUD"]);
1004 env.fund(XRP(1000), alice, buyer, gw);
1009 UInt256 const nftAlice0ID = token::getNextID(env, alice, 0, tfTransferable);
1010 env(token::mint(alice, 0u), Txflags(tfTransferable));
1012 uint8_t aliceCount = 1;
1013 BEAST_EXPECT(
ownerCount(env, alice) == aliceCount);
1015 UInt256 const nftXrpOnlyID = token::getNextID(env, alice, 0, tfOnlyXRP | tfTransferable);
1016 env(token::mint(alice, 0), Txflags(tfOnlyXRP | tfTransferable));
1018 BEAST_EXPECT(
ownerCount(env, alice) == aliceCount);
1020 UInt256 const nftNoXferID = token::getNextID(env, alice, 0);
1021 env(token::mint(alice, 0));
1023 BEAST_EXPECT(
ownerCount(env, alice) == aliceCount);
1026 UInt256 const plainOfferIndex =
1028 env(token::createOffer(alice, nftAlice0ID, XRP(10)), Txflags(tfSellNFToken));
1031 BEAST_EXPECT(
ownerCount(env, alice) == aliceCount);
1035 env(token::createOffer(alice, nftAlice0ID, gwAUD(30)), Txflags(tfSellNFToken));
1038 BEAST_EXPECT(
ownerCount(env, alice) == aliceCount);
1040 UInt256 const xrpOnlyOfferIndex =
1042 env(token::createOffer(alice, nftXrpOnlyID, XRP(20)), Txflags(tfSellNFToken));
1045 BEAST_EXPECT(
ownerCount(env, alice) == aliceCount);
1047 UInt256 const noXferOfferIndex =
1049 env(token::createOffer(alice, nftNoXferID, XRP(30)), Txflags(tfSellNFToken));
1052 BEAST_EXPECT(
ownerCount(env, alice) == aliceCount);
1055 UInt256 const aliceExpOfferIndex =
1057 env(token::createOffer(alice, nftNoXferID, XRP(40)),
1058 Txflags(tfSellNFToken),
1062 BEAST_EXPECT(
ownerCount(env, alice) == aliceCount);
1065 UInt256 const buyerExpOfferIndex =
1067 env(token::createOffer(buyer, nftAlice0ID, XRP(40)),
1068 token::Owner(alice),
1071 uint8_t buyerCount = 1;
1072 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1078 env(token::acceptSellOffer(buyer, noXferOfferIndex),
1082 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1085 env(token::acceptSellOffer(buyer, noXferOfferIndex),
1086 Txflags(0x00008000),
1089 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1093 json::Value jv = token::acceptSellOffer(buyer, noXferOfferIndex);
1097 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1102 json::Value jv = token::acceptBuyOffer(buyer, noXferOfferIndex);
1106 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1111 json::Value jv = token::acceptSellOffer(buyer, noXferOfferIndex);
1115 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1119 env(token::brokerOffers(buyer, noXferOfferIndex, xrpOnlyOfferIndex),
1120 token::BrokerFee(gwAUD(0)),
1123 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1131 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1137 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1141 env(token::acceptBuyOffer(alice, buyerExpOfferIndex), Ter(
tecEXPIRED));
1143 if (features[fixCleanup3_1_3])
1148 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1153 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1158 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1162 env(token::acceptSellOffer(buyer, aliceExpOfferIndex), Ter(
tecEXPIRED));
1167 if (features[fixCleanup3_1_3])
1172 BEAST_EXPECT(
ownerCount(env, alice) == aliceCount);
1173 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1180 env(trust(alice, gwAUD(1000)));
1181 env(trust(buyer, gwAUD(1000)));
1183 env(pay(gw, buyer, gwAUD(30)));
1187 BEAST_EXPECT(
ownerCount(env, alice) == aliceCount);
1188 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1190 BEAST_EXPECT(
ownerCount(env, alice) == aliceCount);
1191 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1197 UInt256 const buyerOfferIndex =
1199 env(token::createOffer(buyer, nftAlice0ID, gwAUD(29)), token::Owner(alice));
1202 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1205 env(token::brokerOffers(gw, buyerOfferIndex, xrpOnlyOfferIndex),
1208 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1211 env(token::brokerOffers(gw, buyerOfferIndex, plainOfferIndex),
1214 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1218 env(token::brokerOffers(gw, buyerOfferIndex, audOfferIndex),
1221 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1224 env(token::cancelOffer(buyer, {buyerOfferIndex}));
1227 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1231 UInt256 const buyerOfferIndex =
1233 env(token::createOffer(buyer, nftAlice0ID, gwAUD(31)), token::Owner(alice));
1236 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1240 env(token::brokerOffers(gw, buyerOfferIndex, audOfferIndex),
1241 token::BrokerFee(XRP(40)),
1244 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1247 env(token::brokerOffers(gw, buyerOfferIndex, audOfferIndex),
1248 token::BrokerFee(gwAUD(31)),
1251 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1255 env(token::brokerOffers(gw, buyerOfferIndex, audOfferIndex),
1256 token::BrokerFee(gwAUD(1.5)),
1259 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1262 env(token::cancelOffer(buyer, {buyerOfferIndex}));
1265 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1271 UInt256 const buyerOfferIndex =
1273 env(token::createOffer(buyer, nftAlice0ID, gwAUD(30)), token::Owner(alice));
1276 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1281 BEAST_EXPECT(
ownerCount(env, alice) == aliceCount);
1284 env(token::acceptBuyOffer(buyer, buyerOfferIndex),
1287 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1290 env(pay(buyer, gw, gwAUD(30)));
1292 BEAST_EXPECT(env.balance(buyer, gwAUD) == gwAUD(0));
1295 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1301 env(token::createOffer(alice, nftAlice0ID, XRP(0)), Txflags(tfSellNFToken));
1303 env(token::acceptSellOffer(gw, offerIndex));
1305 BEAST_EXPECT(
ownerCount(env, alice) == aliceCount);
1307 env(pay(gw, buyer, gwAUD(30)));
1313 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1316 env(token::cancelOffer(buyer, {buyerOfferIndex}));
1319 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1325 UInt256 const buyerOfferIndex =
1327 env(token::createOffer(buyer, nftXrpOnlyID, XRP(30)), token::Owner(alice));
1330 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1333 env(token::acceptSellOffer(alice, buyerOfferIndex),
1336 BEAST_EXPECT(
ownerCount(env, alice) == aliceCount);
1339 env(token::acceptSellOffer(alice, plainOfferIndex),
1342 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1346 env(token::acceptSellOffer(buyer, plainOfferIndex), Ter(
tecNO_PERMISSION));
1348 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1356 env(token::createOffer(gw, nftAlice0ID, XRP(0)), Txflags(tfSellNFToken));
1358 env(token::acceptSellOffer(alice, offerIndex));
1360 BEAST_EXPECT(
ownerCount(env, alice) == aliceCount);
1362 env(pay(buyer, gw, gwAUD(30)));
1364 BEAST_EXPECT(env.balance(buyer, gwAUD) == gwAUD(0));
1367 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
1577 testcase(
"Mint flagCreateTrustLines");
1585 IOU
const gwAUD(gw[
"AUD"]);
1586 IOU
const gwCAD(gw[
"CAD"]);
1587 IOU
const gwEUR(gw[
"EUR"]);
1592 for (
auto const& tweakedFeatures :
1593 {features - fixRemoveNFTokenAutoTrustLine, features | fixRemoveNFTokenAutoTrustLine})
1595 Env env{*
this, tweakedFeatures};
1596 env.fund(XRP(1000), alice, becky, cheri, gw);
1600 env(trust(becky, gwAUD(1000)));
1601 env(trust(cheri, gwAUD(1000)));
1602 env(trust(becky, gwCAD(1000)));
1603 env(trust(cheri, gwCAD(1000)));
1604 env(trust(becky, gwEUR(1000)));
1605 env(trust(cheri, gwEUR(1000)));
1607 env(pay(gw, becky, gwAUD(500)));
1608 env(pay(gw, becky, gwCAD(500)));
1609 env(pay(gw, becky, gwEUR(500)));
1610 env(pay(gw, cheri, gwAUD(500)));
1611 env(pay(gw, cheri, gwCAD(500)));
1618 UInt256 const nftNoAutoTrustID{
1619 token::getNextID(env, alice, 0u, tfTransferable, xferFee),
1621 env(token::mint(alice, 0u), token::XferFee(xferFee), Txflags(tfTransferable));
1625 UInt256 const beckyBuyOfferIndex =
1627 env(token::createOffer(becky, nftNoAutoTrustID, drops(1)), token::Owner(alice));
1629 env(token::acceptBuyOffer(alice, beckyBuyOfferIndex));
1634 UInt256 const beckyOfferIndex =
1636 env(token::createOffer(becky, nftNoAutoTrustID, gwAUD(100)),
1637 Txflags(tfSellNFToken),
1638 Ter(createOfferTER));
1642 UInt256 const cheriOfferIndex =
1644 env(token::createOffer(cheri, nftNoAutoTrustID, gwCAD(100)),
1645 token::Owner(becky),
1646 Ter(createOfferTER));
1650 env(token::cancelOffer(becky, {beckyOfferIndex}));
1651 env(token::cancelOffer(cheri, {cheriOfferIndex}));
1660 token::getNextID(env, alice, 0u, tfTransferable |
tfTrustLine, transferFee),
1666 TER const mintTER = tweakedFeatures[fixRemoveNFTokenAutoTrustLine]
1670 env(token::mint(alice, 0u),
1671 token::XferFee(transferFee),
1678 if (tweakedFeatures[fixRemoveNFTokenAutoTrustLine])
1682 UInt256 const beckyBuyOfferIndex =
1684 env(token::createOffer(becky, nftAutoTrustID, drops(1)), token::Owner(alice));
1686 env(token::acceptBuyOffer(alice, beckyBuyOfferIndex));
1690 UInt256 const beckySellOfferIndex =
1692 env(token::createOffer(becky, nftAutoTrustID, gwAUD(100)), Txflags(tfSellNFToken));
1694 env(token::acceptSellOffer(cheri, beckySellOfferIndex));
1698 BEAST_EXPECT(env.balance(alice, gwAUD) == gwAUD(10));
1701 UInt256 const beckyBuyBackOfferIndex =
1703 env(token::createOffer(becky, nftAutoTrustID, gwCAD(50)), token::Owner(cheri));
1705 env(token::acceptBuyOffer(cheri, beckyBuyBackOfferIndex));
1709 BEAST_EXPECT(env.balance(alice, gwAUD) == gwAUD(10));
1710 BEAST_EXPECT(env.balance(alice, gwCAD) == gwCAD(5));
1716 UInt256 const nftNoAutoTrustID{
1717 token::getNextID(env, alice, 0u, tfTransferable, transferFee),
1719 env(token::mint(alice, 0u), token::XferFee(transferFee), Txflags(tfTransferable));
1723 UInt256 const aliceSellOfferIndex =
1725 env(token::createOffer(alice, nftNoAutoTrustID, gwAUD(200)),
1726 Txflags(tfSellNFToken));
1728 env(token::acceptSellOffer(cheri, aliceSellOfferIndex));
1734 BEAST_EXPECT(env.balance(alice, gwAUD) == gwAUD(210));
1737 env(token::createOffer(cheri, nftNoAutoTrustID, gwEUR(50)),
1738 Txflags(tfSellNFToken),
1741 UInt256 const cheriSellOfferIndex =
1743 env(token::createOffer(cheri, nftNoAutoTrustID, gwCAD(100)),
1744 Txflags(tfSellNFToken));
1746 env(token::acceptSellOffer(becky, cheriSellOfferIndex));
1752 BEAST_EXPECT(env.balance(alice, gwCAD) == gwCAD(10));
1765 Env env{*
this, features};
1769 Account const minter{
"minter"};
1771 env.fund(XRP(1000), alice, becky, minter);
1777 UInt256 const nftAliceNoTransferID{token::getNextID(env, alice, 0u)};
1778 env(token::mint(alice, 0u), token::XferFee(0));
1784 env(token::createOffer(becky, nftAliceNoTransferID, XRP(20)),
1785 token::Owner(alice),
1789 UInt256 const aliceSellOfferIndex =
1791 env(token::createOffer(alice, nftAliceNoTransferID, XRP(20)), Txflags(tfSellNFToken));
1793 env(token::acceptSellOffer(becky, aliceSellOfferIndex));
1799 env(token::createOffer(becky, nftAliceNoTransferID, XRP(21)),
1800 Txflags(tfSellNFToken),
1808 env(token::createOffer(becky, nftAliceNoTransferID, XRP(21)),
1809 Txflags(tfSellNFToken),
1810 token::Destination(alice),
1818 UInt256 const aliceBuyOfferIndex =
1820 env(token::createOffer(alice, nftAliceNoTransferID, XRP(22)), token::Owner(becky));
1822 env(token::acceptBuyOffer(becky, aliceBuyOfferIndex));
1828 env(token::burn(alice, nftAliceNoTransferID));
1835 env(token::setMinter(alice, minter));
1839 UInt256 const nftMinterNoTransferID{token::getNextID(env, alice, 0u)};
1840 env(token::mint(minter), token::Issuer(alice));
1846 env(token::createOffer(becky, nftMinterNoTransferID, XRP(20)),
1847 token::Owner(minter),
1853 env(token::clearMinter(alice));
1858 env(token::createOffer(minter, nftMinterNoTransferID, XRP(21)),
1859 Txflags(tfSellNFToken),
1866 for (
int i = 0; i < 10; ++i)
1869 env(token::setMinter(alice, minter));
1875 UInt256 const minterSellOfferIndex =
1877 env(token::createOffer(minter, nftMinterNoTransferID, XRP(22)), Txflags(tfSellNFToken));
1883 env(token::clearMinter(alice));
1889 env(token::acceptSellOffer(becky, minterSellOfferIndex));
1895 env(token::createOffer(becky, nftMinterNoTransferID, XRP(23)),
1896 Txflags(tfSellNFToken),
1903 env(token::createOffer(minter, nftMinterNoTransferID, XRP(24)),
1904 token::Owner(becky),
1911 UInt256 const aliceBuyOfferIndex =
1913 env(token::createOffer(alice, nftMinterNoTransferID, XRP(25)), token::Owner(becky));
1919 for (
int i = 0; i < 10; ++i)
1922 env(token::setMinter(alice, minter));
1927 UInt256 const minterBuyOfferIndex =
1929 env(token::createOffer(minter, nftMinterNoTransferID, XRP(26)), token::Owner(becky));
1935 env(token::clearMinter(alice));
1941 env(token::acceptBuyOffer(becky, minterBuyOfferIndex));
1949 env(token::burn(minter, nftMinterNoTransferID), Ter(
tesSUCCESS));
1951 env(token::cancelOffer(alice, {aliceBuyOfferIndex}));
1961 UInt256 const nftAliceID{token::getNextID(env, alice, 0u, tfTransferable)};
1962 env(token::mint(alice, 0u), Txflags(tfTransferable));
1967 UInt256 const aliceSellOfferIndex =
1969 env(token::createOffer(alice, nftAliceID, XRP(20)), Txflags(tfSellNFToken));
1973 UInt256 const beckyBuyOfferIndex =
1975 env(token::createOffer(becky, nftAliceID, XRP(21)), token::Owner(alice));
1980 env(token::acceptSellOffer(becky, aliceSellOfferIndex));
1986 UInt256 const beckySellOfferIndex =
1988 env(token::createOffer(becky, nftAliceID, XRP(22)), Txflags(tfSellNFToken));
1995 env(token::acceptSellOffer(minter, beckySellOfferIndex));
2002 UInt256 const minterSellOfferIndex =
2004 env(token::createOffer(minter, nftAliceID, XRP(23)), Txflags(tfSellNFToken));
2011 env(token::acceptSellOffer(alice, minterSellOfferIndex));
2019 env(token::acceptBuyOffer(alice, beckyBuyOfferIndex));
2027 env(token::burn(becky, nftAliceID));
2043 Env env{*
this, features};
2044 auto const baseFee = env.current()->fees().base;
2049 Account const minter{
"minter"};
2051 IOU
const gwXAU(gw[
"XAU"]);
2053 env.fund(XRP(1000), alice, becky, carol, minter, gw);
2056 env(trust(alice, gwXAU(2000)));
2057 env(trust(becky, gwXAU(2000)));
2058 env(trust(carol, gwXAU(2000)));
2059 env(trust(minter, gwXAU(2000)));
2061 env(pay(gw, alice, gwXAU(1000)));
2062 env(pay(gw, becky, gwXAU(1000)));
2063 env(pay(gw, carol, gwXAU(1000)));
2064 env(pay(gw, minter, gwXAU(1000)));
2069 env(token::setMinter(alice, minter));
2080 UInt256 const nftID = token::getNextID(env, alice, 0u, tfTransferable);
2081 env(token::mint(alice), Txflags(tfTransferable));
2085 UInt256 const beckyBuyOfferIndex =
2087 env(token::createOffer(becky, nftID, gwXAU(10)), token::Owner(alice));
2089 BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1000));
2090 BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1000));
2092 env(token::acceptBuyOffer(alice, beckyBuyOfferIndex));
2094 BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1010));
2095 BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(990));
2098 UInt256 const beckySellOfferIndex =
2100 env(token::createOffer(becky, nftID, gwXAU(10)), Txflags(tfSellNFToken));
2102 env(token::acceptSellOffer(carol, beckySellOfferIndex));
2104 BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1010));
2105 BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1000));
2106 BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(990));
2109 UInt256 const minterBuyOfferIndex =
2111 env(token::createOffer(minter, nftID, gwXAU(10)), token::Owner(carol));
2113 env(token::acceptBuyOffer(carol, minterBuyOfferIndex));
2115 BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1010));
2116 BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1000));
2117 BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(1000));
2118 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(990));
2122 UInt256 const minterSellOfferIndex =
2124 env(token::createOffer(minter, nftID, gwXAU(10)), Txflags(tfSellNFToken));
2126 env(token::acceptSellOffer(alice, minterSellOfferIndex));
2128 BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1000));
2129 BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1000));
2130 BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(1000));
2131 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(1000));
2134 env(token::burn(alice, nftID));
2145 UInt256 const nftID = token::getNextID(env, alice, 0u, tfTransferable, 1);
2146 env(token::mint(alice), Txflags(tfTransferable), token::XferFee(1));
2150 UInt256 const beckyBuyOfferIndex =
2152 env(token::createOffer(becky, nftID, gwXAU(10)), token::Owner(alice));
2154 BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1000));
2155 BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1000));
2157 env(token::acceptBuyOffer(alice, beckyBuyOfferIndex));
2159 BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1010));
2160 BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(990));
2163 UInt256 const beckySellOfferIndex =
2165 env(token::createOffer(becky, nftID, gwXAU(10)), Txflags(tfSellNFToken));
2167 env(token::acceptSellOffer(carol, beckySellOfferIndex));
2170 BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1010.0001));
2171 BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(999.9999));
2172 BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(990));
2175 UInt256 const minterBuyOfferIndex =
2177 env(token::createOffer(minter, nftID, gwXAU(10)), token::Owner(carol));
2179 env(token::acceptBuyOffer(carol, minterBuyOfferIndex));
2182 BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1010.0002));
2183 BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(999.9999));
2184 BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(999.9999));
2185 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(990));
2189 UInt256 const minterSellOfferIndex =
2191 env(token::createOffer(minter, nftID, gwXAU(10)), Txflags(tfSellNFToken));
2193 env(token::acceptSellOffer(alice, minterSellOfferIndex));
2195 BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1000.0002));
2196 BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(999.9999));
2197 BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(999.9999));
2198 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(1000));
2202 env(pay(alice, becky, gwXAU(0.0001)));
2203 env(pay(alice, carol, gwXAU(0.0001)));
2206 BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1000));
2207 BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1000));
2208 BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(1000));
2209 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(1000));
2212 env(token::burn(alice, nftID));
2223 env(token::mint(alice),
2224 Txflags(tfTransferable),
2231 env(token::mint(alice), Txflags(tfTransferable), token::XferFee(
kMaxTransferFee));
2235 UInt256 const beckyBuyOfferIndex =
2237 env(token::createOffer(becky, nftID, gwXAU(10)), token::Owner(alice));
2239 BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1000));
2240 BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1000));
2242 env(token::acceptBuyOffer(alice, beckyBuyOfferIndex));
2244 BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1010));
2245 BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(990));
2248 UInt256 const beckySellOfferIndex =
2250 env(token::createOffer(becky, nftID, gwXAU(100)), Txflags(tfSellNFToken));
2252 env(token::acceptSellOffer(minter, beckySellOfferIndex));
2255 BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1060));
2256 BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1040));
2257 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(900));
2260 UInt256 const carolBuyOfferIndex =
2262 env(token::createOffer(carol, nftID, gwXAU(10)), token::Owner(minter));
2264 env(token::acceptBuyOffer(minter, carolBuyOfferIndex));
2267 BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1065));
2268 BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1040));
2269 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(905));
2270 BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(990));
2274 UInt256 const carolSellOfferIndex =
2276 env(token::createOffer(carol, nftID, gwXAU(10)), Txflags(tfSellNFToken));
2278 env(token::acceptSellOffer(alice, carolSellOfferIndex));
2281 BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1055));
2282 BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1040));
2283 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(905));
2284 BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(1000));
2287 env(pay(alice, minter, gwXAU(55)));
2288 env(pay(becky, minter, gwXAU(40)));
2290 BEAST_EXPECT(env.balance(alice, gwXAU) == gwXAU(1000));
2291 BEAST_EXPECT(env.balance(becky, gwXAU) == gwXAU(1000));
2292 BEAST_EXPECT(env.balance(carol, gwXAU) == gwXAU(1000));
2293 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(1000));
2296 env(token::burn(alice, nftID));
2308 UInt256 const nftID = token::getNextID(env, alice, 0u, tfTransferable, 1);
2309 env(token::mint(alice), Txflags(tfTransferable), token::XferFee(1));
2314 STAmount aliceBalance = env.balance(alice);
2315 STAmount minterBalance = env.balance(minter);
2316 UInt256 const minterBuyOfferIndex =
2318 env(token::createOffer(minter, nftID, XRP(1)), token::Owner(alice));
2320 env(token::acceptBuyOffer(alice, minterBuyOfferIndex));
2322 aliceBalance += XRP(1) - baseFee;
2323 minterBalance -= XRP(1) + baseFee;
2324 BEAST_EXPECT(env.balance(alice) == aliceBalance);
2325 BEAST_EXPECT(env.balance(minter) == minterBalance);
2329 auto pmt = drops(50000);
2330 STAmount carolBalance = env.balance(carol);
2331 UInt256 const minterSellOfferIndex =
2333 env(token::createOffer(minter, nftID, pmt), Txflags(tfSellNFToken));
2335 env(token::acceptSellOffer(carol, minterSellOfferIndex));
2337 minterBalance += pmt - baseFee;
2338 carolBalance -= pmt + baseFee;
2339 BEAST_EXPECT(env.balance(alice) == aliceBalance);
2340 BEAST_EXPECT(env.balance(minter) == minterBalance);
2341 BEAST_EXPECT(env.balance(carol) == carolBalance);
2345 STAmount beckyBalance = env.balance(becky);
2346 UInt256 const beckyBuyOfferIndex =
2349 env(token::createOffer(becky, nftID, pmt), token::Owner(carol));
2351 env(token::acceptBuyOffer(carol, beckyBuyOfferIndex));
2353 carolBalance += pmt - drops(1) - baseFee;
2354 beckyBalance -= pmt + baseFee;
2355 aliceBalance += drops(1);
2357 BEAST_EXPECT(env.balance(alice) == aliceBalance);
2358 BEAST_EXPECT(env.balance(minter) == minterBalance);
2359 BEAST_EXPECT(env.balance(carol) == carolBalance);
2360 BEAST_EXPECT(env.balance(becky) == beckyBalance);
2367 UInt256 const nftID = token::getNextID(env, alice, 0u, tfTransferable, 1);
2368 env(token::mint(alice), Txflags(tfTransferable), token::XferFee(1));
2374 env(pay(alice, gw, env.balance(alice, gwXAU)));
2375 env(pay(minter, gw, env.balance(minter, gwXAU)));
2376 env(pay(becky, gw, env.balance(becky, gwXAU)));
2380 env(pay(gw, alice, startXAUBalance));
2381 env(pay(gw, minter, startXAUBalance));
2382 env(pay(gw, becky, startXAUBalance));
2390 STAmount aliceBalance = env.balance(alice, gwXAU);
2391 STAmount minterBalance = env.balance(minter, gwXAU);
2392 UInt256 const minterBuyOfferIndex =
2394 env(token::createOffer(minter, nftID, tinyXAU), token::Owner(alice));
2396 env(token::acceptBuyOffer(alice, minterBuyOfferIndex));
2398 aliceBalance += tinyXAU;
2399 minterBalance -= tinyXAU;
2400 BEAST_EXPECT(env.balance(alice, gwXAU) == aliceBalance);
2401 BEAST_EXPECT(env.balance(minter, gwXAU) == minterBalance);
2404 STAmount carolBalance = env.balance(carol, gwXAU);
2405 UInt256 const minterSellOfferIndex =
2407 env(token::createOffer(minter, nftID, tinyXAU), Txflags(tfSellNFToken));
2409 env(token::acceptSellOffer(carol, minterSellOfferIndex));
2412 minterBalance += tinyXAU;
2413 carolBalance -= tinyXAU;
2415 BEAST_EXPECT(env.balance(alice, gwXAU) == aliceBalance);
2416 BEAST_EXPECT(env.balance(minter, gwXAU) == minterBalance);
2417 BEAST_EXPECT(env.balance(carol, gwXAU) == carolBalance);
2423 STAmount beckyBalance = env.balance(becky, gwXAU);
2424 UInt256 const beckyBuyOfferIndex =
2426 env(token::createOffer(becky, nftID, cheapNFT), token::Owner(carol));
2428 env(token::acceptBuyOffer(carol, beckyBuyOfferIndex));
2431 aliceBalance += tinyXAU;
2432 beckyBalance -= cheapNFT;
2433 carolBalance += cheapNFT - tinyXAU;
2434 BEAST_EXPECT(env.balance(alice, gwXAU) == aliceBalance);
2435 BEAST_EXPECT(env.balance(minter, gwXAU) == minterBalance);
2436 BEAST_EXPECT(env.balance(carol, gwXAU) == carolBalance);
2437 BEAST_EXPECT(env.balance(becky, gwXAU) == beckyBalance);
2630 testcase(
"Create offer destination");
2634 Env env{*
this, features};
2636 Account const issuer{
"issuer"};
2637 Account const minter{
"minter"};
2639 Account const broker{
"broker"};
2641 env.fund(XRP(1000), issuer, minter, buyer, broker);
2645 env(token::setMinter(issuer, minter));
2648 UInt256 const nftokenID = token::getNextID(env, issuer, 0, tfTransferable);
2649 env(token::mint(minter, 0), token::Issuer(issuer), Txflags(tfTransferable));
2655 UInt256 const offerMinterToIssuer =
2657 env(token::createOffer(minter, nftokenID, drops(1)),
2658 token::Destination(issuer),
2659 Txflags(tfSellNFToken));
2661 UInt256 const offerMinterToBuyer =
2663 env(token::createOffer(minter, nftokenID, drops(1)),
2664 token::Destination(buyer),
2665 Txflags(tfSellNFToken));
2667 UInt256 const offerIssuerToMinter =
2669 env(token::createOffer(issuer, nftokenID, drops(1)),
2670 token::Owner(minter),
2671 token::Destination(minter));
2673 UInt256 const offerIssuerToBuyer =
2675 env(token::createOffer(issuer, nftokenID, drops(1)),
2676 token::Owner(minter),
2677 token::Destination(buyer));
2691 env(token::cancelOffer(issuer, {offerMinterToBuyer}), Ter(
tecNO_PERMISSION));
2692 env(token::cancelOffer(buyer, {offerMinterToIssuer}), Ter(
tecNO_PERMISSION));
2693 env(token::cancelOffer(buyer, {offerIssuerToMinter}), Ter(
tecNO_PERMISSION));
2694 env(token::cancelOffer(minter, {offerIssuerToBuyer}), Ter(
tecNO_PERMISSION));
2702 env(token::cancelOffer(buyer, {offerMinterToBuyer}));
2703 env(token::cancelOffer(minter, {offerMinterToIssuer}));
2704 env(token::cancelOffer(buyer, {offerIssuerToBuyer}));
2705 env(token::cancelOffer(issuer, {offerIssuerToMinter}));
2715 UInt256 const offerMinterSellsToBuyer =
2717 env(token::createOffer(minter, nftokenID, drops(1)),
2718 token::Destination(buyer),
2719 Txflags(tfSellNFToken));
2727 env(token::acceptSellOffer(issuer, offerMinterSellsToBuyer), Ter(
tecNO_PERMISSION));
2734 env(token::acceptSellOffer(buyer, offerMinterSellsToBuyer));
2744 UInt256 const offerMinterBuysFromBuyer =
2746 env(token::createOffer(minter, nftokenID, drops(1)),
2747 token::Owner(buyer),
2748 token::Destination(buyer));
2756 env(token::acceptBuyOffer(issuer, offerMinterBuysFromBuyer), Ter(
tecNO_PERMISSION));
2763 env(token::acceptBuyOffer(buyer, offerMinterBuysFromBuyer));
2772 UInt256 const offerBuyerBuysFromMinter =
2774 env(token::createOffer(buyer, nftokenID, drops(1)),
2775 token::Owner(minter),
2776 token::Destination(broker));
2782 env(token::acceptBuyOffer(minter, offerBuyerBuysFromMinter), Ter(
tecNO_PERMISSION));
2786 env(token::cancelOffer(buyer, {offerBuyerBuysFromMinter}));
2796 UInt256 const offerMinterToBroker =
2798 env(token::createOffer(minter, nftokenID, drops(1)),
2799 token::Destination(broker),
2800 Txflags(tfSellNFToken));
2802 UInt256 const offerBuyerToMinter =
2804 env(token::createOffer(buyer, nftokenID, drops(1)), token::Owner(minter));
2814 env(token::brokerOffers(issuer, offerBuyerToMinter, offerMinterToBroker),
2824 env(token::brokerOffers(broker, offerBuyerToMinter, offerMinterToBroker));
2835 UInt256 const offerBuyerToMinter =
2837 env(token::createOffer(buyer, nftokenID, drops(1)),
2838 token::Destination(minter),
2839 Txflags(tfSellNFToken));
2841 UInt256 const offerMinterToBuyer =
2843 env(token::createOffer(minter, nftokenID, drops(1)), token::Owner(buyer));
2845 UInt256 const offerIssuerToBuyer =
2847 env(token::createOffer(issuer, nftokenID, drops(1)), token::Owner(buyer));
2857 env(token::brokerOffers(broker, offerIssuerToBuyer, offerBuyerToMinter),
2865 env(token::brokerOffers(broker, offerMinterToBuyer, offerBuyerToMinter),
2870 env(token::acceptBuyOffer(buyer, offerMinterToBuyer));
2874 env(token::cancelOffer(buyer, {offerBuyerToMinter}));
2882 env(token::cancelOffer(issuer, {offerIssuerToBuyer}));
2894 UInt256 const offerMinterToBroker =
2896 env(token::createOffer(minter, nftokenID, drops(1)),
2897 token::Destination(broker),
2898 Txflags(tfSellNFToken));
2900 UInt256 const offerBuyerToBroker =
2902 env(token::createOffer(buyer, nftokenID, drops(1)),
2903 token::Owner(minter),
2904 token::Destination(broker));
2909 env(token::brokerOffers(issuer, offerBuyerToBroker, offerMinterToBroker),
2918 env(token::brokerOffers(broker, offerBuyerToBroker, offerMinterToBroker));
3062 testcase(
"Create offer expiration");
3066 Env env{*
this, features};
3068 Account const issuer{
"issuer"};
3069 Account const minter{
"minter"};
3072 env.fund(XRP(1000), issuer, minter, buyer);
3076 env(token::setMinter(issuer, minter));
3079 UInt256 const nftokenID0 = token::getNextID(env, issuer, 0, tfTransferable);
3080 env(token::mint(minter, 0), token::Issuer(issuer), Txflags(tfTransferable));
3083 UInt256 const nftokenID1 = token::getNextID(env, issuer, 0, tfTransferable);
3084 env(token::mint(minter, 0), token::Issuer(issuer), Txflags(tfTransferable));
3086 uint8_t issuerCount = 0, minterCount = 0, buyerCount = 0;
3093 UInt256 const offerMinterToIssuer =
3095 env(token::createOffer(minter, nftokenID0, drops(1)),
3096 token::Destination(issuer),
3097 token::Expiration(expiration),
3098 Txflags(tfSellNFToken));
3100 UInt256 const offerMinterToAnyone =
3102 env(token::createOffer(minter, nftokenID0, drops(1)),
3103 token::Expiration(expiration),
3104 Txflags(tfSellNFToken));
3106 UInt256 const offerIssuerToMinter =
3108 env(token::createOffer(issuer, nftokenID0, drops(1)),
3109 token::Owner(minter),
3110 token::Expiration(expiration));
3112 UInt256 const offerBuyerToMinter =
3114 env(token::createOffer(buyer, nftokenID0, drops(1)),
3115 token::Owner(minter),
3116 token::Expiration(expiration));
3121 BEAST_EXPECT(
ownerCount(env, issuer) == issuerCount);
3122 BEAST_EXPECT(
ownerCount(env, minter) == minterCount);
3123 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
3131 env(token::cancelOffer(issuer, {offerMinterToAnyone}), Ter(
tecNO_PERMISSION));
3132 env(token::cancelOffer(buyer, {offerIssuerToMinter}), Ter(
tecNO_PERMISSION));
3134 BEAST_EXPECT(
lastClose(env) < expiration);
3135 BEAST_EXPECT(
ownerCount(env, issuer) == issuerCount);
3136 BEAST_EXPECT(
ownerCount(env, minter) == minterCount);
3137 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
3140 env(token::cancelOffer(minter, {offerMinterToAnyone}));
3145 env(token::cancelOffer(issuer, {offerMinterToIssuer}));
3152 BEAST_EXPECT(
ownerCount(env, issuer) == issuerCount);
3153 BEAST_EXPECT(
ownerCount(env, minter) == minterCount);
3154 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
3157 env(token::cancelOffer(issuer, {offerBuyerToMinter}));
3159 env(token::cancelOffer(buyer, {offerIssuerToMinter}));
3162 BEAST_EXPECT(
ownerCount(env, issuer) == issuerCount);
3163 BEAST_EXPECT(
ownerCount(env, minter) == minterCount);
3164 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
3175 env(token::createOffer(minter, nftokenID0, drops(1)),
3176 token::Expiration(expiration),
3177 Txflags(tfSellNFToken));
3182 env(token::createOffer(minter, nftokenID1, drops(1)),
3183 token::Expiration(expiration),
3184 Txflags(tfSellNFToken));
3187 BEAST_EXPECT(
lastClose(env) < expiration);
3188 BEAST_EXPECT(
ownerCount(env, issuer) == issuerCount);
3189 BEAST_EXPECT(
ownerCount(env, minter) == minterCount);
3190 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
3193 env(token::acceptSellOffer(buyer, offer0));
3201 BEAST_EXPECT(
ownerCount(env, issuer) == issuerCount);
3202 BEAST_EXPECT(
ownerCount(env, minter) == minterCount);
3203 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
3206 env(token::acceptSellOffer(buyer, offer1), Ter(
tecEXPIRED));
3211 if (features[fixCleanup3_1_3])
3221 env(token::acceptSellOffer(issuer, offer1), Ter(
tecEXPIRED));
3226 BEAST_EXPECT(
ownerCount(env, issuer) == issuerCount);
3227 BEAST_EXPECT(
ownerCount(env, minter) == minterCount);
3228 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
3230 if (!features[fixCleanup3_1_3])
3234 env(token::cancelOffer(issuer, {offer1}));
3240 BEAST_EXPECT(
ownerCount(env, issuer) == 0 && issuerCount == 0);
3241 BEAST_EXPECT(
ownerCount(env, minter) == 1 && minterCount == 1);
3242 BEAST_EXPECT(
ownerCount(env, buyer) == 1 && buyerCount == 1);
3248 env(token::createOffer(buyer, nftokenID0, XRP(0)),
3249 Txflags(tfSellNFToken),
3250 token::Destination(minter));
3252 env(token::acceptSellOffer(minter, offerSellBack));
3255 BEAST_EXPECT(
ownerCount(env, issuer) == issuerCount);
3256 BEAST_EXPECT(
ownerCount(env, minter) == minterCount);
3257 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
3268 env(token::createOffer(buyer, nftokenID0, drops(1)),
3269 token::Owner(minter),
3270 token::Expiration(expiration));
3275 env(token::createOffer(buyer, nftokenID1, drops(1)),
3276 token::Owner(minter),
3277 token::Expiration(expiration));
3280 BEAST_EXPECT(
lastClose(env) < expiration);
3281 BEAST_EXPECT(
ownerCount(env, issuer) == issuerCount);
3282 BEAST_EXPECT(
ownerCount(env, minter) == minterCount);
3283 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
3286 env(token::acceptBuyOffer(minter, offer0));
3292 BEAST_EXPECT(
ownerCount(env, issuer) == issuerCount);
3293 BEAST_EXPECT(
ownerCount(env, minter) == minterCount);
3294 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
3297 env(token::acceptBuyOffer(minter, offer1), Ter(
tecEXPIRED));
3302 if (features[fixCleanup3_1_3])
3312 env(token::acceptBuyOffer(issuer, offer1), Ter(
tecEXPIRED));
3317 BEAST_EXPECT(
ownerCount(env, issuer) == issuerCount);
3318 BEAST_EXPECT(
ownerCount(env, minter) == minterCount);
3319 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
3321 if (!features[fixCleanup3_1_3])
3325 env(token::cancelOffer(issuer, {offer1}));
3331 BEAST_EXPECT(
ownerCount(env, issuer) == 0 && issuerCount == 0);
3332 BEAST_EXPECT(
ownerCount(env, minter) == 1 && minterCount == 1);
3333 BEAST_EXPECT(
ownerCount(env, buyer) == 1 && buyerCount == 1);
3339 env(token::createOffer(buyer, nftokenID0, XRP(0)),
3340 Txflags(tfSellNFToken),
3341 token::Destination(minter));
3343 env(token::acceptSellOffer(minter, offerSellBack));
3346 BEAST_EXPECT(
ownerCount(env, issuer) == issuerCount);
3347 BEAST_EXPECT(
ownerCount(env, minter) == minterCount);
3348 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
3359 env(token::createOffer(minter, nftokenID0, drops(1)),
3360 token::Expiration(expiration),
3361 Txflags(tfSellNFToken));
3366 env(token::createOffer(minter, nftokenID1, drops(1)),
3367 token::Expiration(expiration),
3368 Txflags(tfSellNFToken));
3373 env(token::createOffer(buyer, nftokenID0, drops(1)), token::Owner(minter));
3378 env(token::createOffer(buyer, nftokenID1, drops(1)), token::Owner(minter));
3382 BEAST_EXPECT(
lastClose(env) < expiration);
3383 BEAST_EXPECT(
ownerCount(env, issuer) == issuerCount);
3384 BEAST_EXPECT(
ownerCount(env, minter) == minterCount);
3385 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
3388 env(token::brokerOffers(issuer, buyOffer0, sellOffer0));
3395 BEAST_EXPECT(
ownerCount(env, issuer) == issuerCount);
3396 BEAST_EXPECT(
ownerCount(env, minter) == minterCount);
3397 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
3400 env(token::brokerOffers(issuer, buyOffer1, sellOffer1), Ter(
tecEXPIRED));
3403 if (features[fixCleanup3_1_3])
3409 BEAST_EXPECT(
ownerCount(env, issuer) == issuerCount);
3410 BEAST_EXPECT(
ownerCount(env, minter) == minterCount);
3411 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
3413 if (features[fixCleanup3_1_3])
3417 env(token::cancelOffer(buyer, {buyOffer1}));
3423 env(token::cancelOffer(buyer, {buyOffer1, sellOffer1}));
3430 BEAST_EXPECT(
ownerCount(env, issuer) == 0 && issuerCount == 0);
3431 BEAST_EXPECT(
ownerCount(env, minter) == 1 && minterCount == 1);
3432 BEAST_EXPECT(
ownerCount(env, buyer) == 1 && buyerCount == 1);
3438 env(token::createOffer(buyer, nftokenID0, XRP(0)),
3439 Txflags(tfSellNFToken),
3440 token::Destination(minter));
3442 env(token::acceptSellOffer(minter, offerSellBack));
3445 BEAST_EXPECT(
ownerCount(env, issuer) == issuerCount);
3446 BEAST_EXPECT(
ownerCount(env, minter) == minterCount);
3447 BEAST_EXPECT(
ownerCount(env, buyer) == buyerCount);
3458 env(token::createOffer(minter, nftokenID0, drops(1)), Txflags(tfSellNFToken));
3462 env(token::createOffer(minter, nftokenID1, drops(1)), Txflags(tfSellNFToken));
3466 env(token::createOffer(buyer, nftokenID0, drops(1)),
3467 token::Expiration(expiration),
3468 token::Owner(minter));
3472 env(token::createOffer(buyer, nftokenID1, drops(1)),
3473 token::Expiration(expiration),
3474 token::Owner(minter));
3477 BEAST_EXPECT(
lastClose(env) < expiration);
3483 env(token::brokerOffers(issuer, buyOffer0, sellOffer0));
3493 env(token::brokerOffers(issuer, buyOffer1, sellOffer1), Ter(
tecEXPIRED));
3497 if (features[fixCleanup3_1_3])
3505 env(token::cancelOffer(minter, {sellOffer1}));
3513 env(token::cancelOffer(minter, {buyOffer1, sellOffer1}));
3524 env(token::createOffer(buyer, nftokenID0, XRP(0)),
3525 Txflags(tfSellNFToken),
3526 token::Destination(minter));
3528 env(token::acceptSellOffer(minter, offerSellBack));
3544 env(token::createOffer(minter, nftokenID0, drops(1)),
3545 token::Expiration(expiration),
3546 Txflags(tfSellNFToken));
3550 env(token::createOffer(minter, nftokenID1, drops(1)),
3551 token::Expiration(expiration),
3552 Txflags(tfSellNFToken));
3556 env(token::createOffer(buyer, nftokenID0, drops(1)),
3557 token::Expiration(expiration),
3558 token::Owner(minter));
3562 env(token::createOffer(buyer, nftokenID1, drops(1)),
3563 token::Expiration(expiration),
3564 token::Owner(minter));
3567 BEAST_EXPECT(
lastClose(env) < expiration);
3573 env(token::brokerOffers(issuer, buyOffer0, sellOffer0));
3583 env(token::brokerOffers(issuer, buyOffer1, sellOffer1), Ter(
tecEXPIRED));
3588 if (!features[fixCleanup3_1_3])
3594 env(token::cancelOffer(issuer, {buyOffer1, sellOffer1}));
3605 env(token::createOffer(buyer, nftokenID0, XRP(0)),
3606 Txflags(tfSellNFToken),
3607 token::Destination(minter));
3609 env(token::acceptSellOffer(minter, offerSellBack));
3838 testcase(
"Brokered NFT offer accept");
3843 Env env{*
this, features};
3844 auto const baseFee = env.current()->fees().base;
3852 Account const issuer{
"issuer"};
3853 Account const minter{
"minter"};
3855 Account const broker{
"broker"};
3857 IOU
const gwXAU(gw[
"XAU"]);
3859 env.fund(XRP(1000), issuer, minter, buyer, broker, gw);
3862 env(trust(issuer, gwXAU(2000)));
3863 env(trust(minter, gwXAU(2000)));
3864 env(trust(buyer, gwXAU(2000)));
3865 env(trust(broker, gwXAU(2000)));
3868 env(token::setMinter(issuer, minter));
3872 auto const checkOwnerCountIsOne =
3876 for (
Account const& acct : accounts)
3882 ss <<
"Account " << acct.human() <<
" expected ownerCount == 1. Got "
3884 fail(ss.
str(), __FILE__, line);
3890 auto const mintNFT = [&env, &issuer, &minter](
std::uint16_t xferFee = 0) {
3891 UInt256 const nftID = token::getNextID(env, issuer, 0, tfTransferable, xferFee);
3892 env(token::mint(minter, 0),
3893 token::Issuer(issuer),
3894 token::XferFee(xferFee),
3895 Txflags(tfTransferable));
3906 checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__);
3908 UInt256 const nftID = mintNFT();
3911 UInt256 const minterOfferIndex =
3913 env(token::createOffer(minter, nftID, XRP(0)), Txflags(tfSellNFToken));
3920 env(token::createOffer(buyer, nftID, XRP(1)), token::Owner(minter));
3923 auto const minterBalance = env.balance(minter);
3924 auto const buyerBalance = env.balance(buyer);
3925 auto const brokerBalance = env.balance(broker);
3926 auto const issuerBalance = env.balance(issuer);
3929 env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex));
3934 BEAST_EXPECT(env.balance(minter) == minterBalance + XRP(1));
3935 BEAST_EXPECT(env.balance(buyer) == buyerBalance - XRP(1));
3936 BEAST_EXPECT(env.balance(broker) == brokerBalance - baseFee);
3937 BEAST_EXPECT(env.balance(issuer) == issuerBalance);
3940 env(token::burn(buyer, nftID));
3950 checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__);
3952 UInt256 const nftID = mintNFT();
3955 UInt256 const minterOfferIndex =
3957 env(token::createOffer(minter, nftID, XRP(0)), Txflags(tfSellNFToken));
3964 env(token::createOffer(buyer, nftID, XRP(1)), token::Owner(minter));
3968 env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
3969 token::BrokerFee(XRP(1.1)),
3973 auto const minterBalance = env.balance(minter);
3974 auto const buyerBalance = env.balance(buyer);
3975 auto const brokerBalance = env.balance(broker);
3976 auto const issuerBalance = env.balance(issuer);
3979 env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
3980 token::BrokerFee(XRP(0.5)));
3985 BEAST_EXPECT(env.balance(minter) == minterBalance + XRP(0.5));
3986 BEAST_EXPECT(env.balance(buyer) == buyerBalance - XRP(1));
3987 BEAST_EXPECT(env.balance(broker) == brokerBalance + XRP(0.5) - baseFee);
3988 BEAST_EXPECT(env.balance(issuer) == issuerBalance);
3991 env(token::burn(buyer, nftID));
4001 checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__);
4006 UInt256 const minterOfferIndex =
4008 env(token::createOffer(minter, nftID, XRP(0)), Txflags(tfSellNFToken));
4015 env(token::createOffer(buyer, nftID, XRP(1)), token::Owner(minter));
4018 auto const minterBalance = env.balance(minter);
4019 auto const buyerBalance = env.balance(buyer);
4020 auto const brokerBalance = env.balance(broker);
4021 auto const issuerBalance = env.balance(issuer);
4024 env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex));
4029 BEAST_EXPECT(env.balance(minter) == minterBalance + XRP(0.5));
4030 BEAST_EXPECT(env.balance(buyer) == buyerBalance - XRP(1));
4031 BEAST_EXPECT(env.balance(broker) == brokerBalance - baseFee);
4032 BEAST_EXPECT(env.balance(issuer) == issuerBalance + XRP(0.5));
4035 env(token::burn(buyer, nftID));
4045 checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__);
4050 UInt256 const minterOfferIndex =
4052 env(token::createOffer(minter, nftID, XRP(0)), Txflags(tfSellNFToken));
4059 env(token::createOffer(buyer, nftID, XRP(1)), token::Owner(minter));
4062 auto const minterBalance = env.balance(minter);
4063 auto const buyerBalance = env.balance(buyer);
4064 auto const brokerBalance = env.balance(broker);
4065 auto const issuerBalance = env.balance(issuer);
4068 env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
4069 token::BrokerFee(XRP(0.75)));
4075 BEAST_EXPECT(env.balance(minter) == minterBalance + XRP(0.125));
4076 BEAST_EXPECT(env.balance(buyer) == buyerBalance - XRP(1));
4077 BEAST_EXPECT(env.balance(broker) == brokerBalance + XRP(0.75) - baseFee);
4078 BEAST_EXPECT(env.balance(issuer) == issuerBalance + XRP(0.125));
4081 env(token::burn(buyer, nftID));
4087 auto const setXAUBalance =
4088 [
this, &gw, &gwXAU, &env](
4092 for (
Account const& acct : accounts)
4094 auto const xauAmt = gwXAU(amount);
4095 auto const balance = env.balance(acct, gwXAU);
4096 if (balance < xauAmt)
4098 env(pay(gw, acct, xauAmt - balance));
4101 else if (balance > xauAmt)
4103 env(pay(acct, gw, balance - xauAmt));
4106 if (env.balance(acct, gwXAU) != xauAmt)
4109 ss <<
"Unable to set " << acct.human() <<
" account balance to gwXAU("
4111 this->
fail(ss.
str(), __FILE__, line);
4119 checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__);
4120 setXAUBalance({issuer, minter, buyer, broker}, 1000, __LINE__);
4122 UInt256 const nftID = mintNFT();
4125 UInt256 const minterOfferIndex =
4127 env(token::createOffer(minter, nftID, gwXAU(1000)), Txflags(tfSellNFToken));
4135 env(token::createOffer(buyer, nftID, gwXAU(1001)), token::Owner(minter));
4139 env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
4145 env(token::cancelOffer(buyer, {buyOfferIndex}));
4153 env(token::createOffer(buyer, nftID, gwXAU(999)), token::Owner(minter));
4157 env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
4163 env(token::cancelOffer(buyer, {buyOfferIndex}));
4170 env(token::createOffer(buyer, nftID, gwXAU(1000)), token::Owner(minter));
4174 env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
4175 token::BrokerFee(gwXAU(0.1)),
4180 env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex));
4187 BEAST_EXPECT(env.balance(issuer, gwXAU) == gwXAU(1000));
4188 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(2000));
4189 BEAST_EXPECT(env.balance(buyer, gwXAU) == gwXAU(0));
4190 BEAST_EXPECT(env.balance(broker, gwXAU) == gwXAU(1000));
4193 env(token::burn(buyer, nftID));
4200 checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__);
4201 setXAUBalance({issuer, minter, buyer, broker}, 1000, __LINE__);
4206 UInt256 const minterOfferIndex =
4208 env(token::createOffer(minter, nftID, gwXAU(900)), Txflags(tfSellNFToken));
4215 env(token::createOffer(buyer, nftID, gwXAU(1001)), token::Owner(minter));
4219 env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
4225 env(token::cancelOffer(buyer, {buyOfferIndex}));
4233 env(token::createOffer(buyer, nftID, gwXAU(899)), token::Owner(minter));
4237 env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
4243 env(token::cancelOffer(buyer, {buyOfferIndex}));
4249 env(token::createOffer(buyer, nftID, gwXAU(1000)), token::Owner(minter));
4254 env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
4255 token::BrokerFee(gwXAU(101)),
4261 env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
4262 token::BrokerFee(gwXAU(100)));
4269 BEAST_EXPECT(env.balance(issuer, gwXAU) == gwXAU(1450));
4270 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(1450));
4271 BEAST_EXPECT(env.balance(buyer, gwXAU) == gwXAU(0));
4272 BEAST_EXPECT(env.balance(broker, gwXAU) == gwXAU(1100));
4275 env(token::burn(buyer, nftID));
4282 checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__);
4283 setXAUBalance({issuer, minter, buyer, broker}, 1000, __LINE__);
4288 UInt256 const minterOfferIndex =
4290 env(token::createOffer(minter, nftID, gwXAU(900)), Txflags(tfSellNFToken));
4296 env(token::createOffer(buyer, nftID, gwXAU(1000)), token::Owner(minter));
4302 env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
4303 token::BrokerFee(gwXAU(50)));
4310 BEAST_EXPECT(env.balance(issuer, gwXAU) == gwXAU(1237.5));
4311 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(1712.5));
4312 BEAST_EXPECT(env.balance(buyer, gwXAU) == gwXAU(0));
4313 BEAST_EXPECT(env.balance(broker, gwXAU) == gwXAU(1050));
4316 env(token::burn(buyer, nftID));
4321 checkOwnerCountIsOne({issuer, minter, buyer, broker}, __LINE__);
4322 setXAUBalance({issuer, minter, buyer}, 1000, __LINE__);
4323 setXAUBalance({broker}, 500, __LINE__);
4327 UInt256 const minterOfferIndex =
4329 env(token::createOffer(minter, nftID, gwXAU(900)), Txflags(tfSellNFToken));
4335 env(token::createOffer(buyer, nftID, gwXAU(1000)), token::Owner(minter));
4338 env(token::brokerOffers(broker, buyOfferIndex, minterOfferIndex),
4339 token::BrokerFee(gwXAU(50)));
4345 BEAST_EXPECT(env.balance(issuer, gwXAU) == gwXAU(1237.5));
4346 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(1712.5));
4347 BEAST_EXPECT(env.balance(buyer, gwXAU) == gwXAU(0));
4348 BEAST_EXPECT(env.balance(broker, gwXAU) == gwXAU(550));
4351 env(token::burn(buyer, nftID));
5193 testcase(
"Payments with IOU transfer fees");
5196 Env env{*
this, features};
5198 Account const minter{
"minter"};
5199 Account const secondarySeller{
"seller"};
5202 Account const broker{
"broker"};
5203 IOU
const gwXAU(gw[
"XAU"]);
5204 IOU
const gwXPB(gw[
"XPB"]);
5206 env.fund(XRP(1000), gw, minter, secondarySeller, buyer, broker);
5209 env(trust(minter, gwXAU(2000)));
5210 env(trust(secondarySeller, gwXAU(2000)));
5211 env(trust(broker, gwXAU(10000)));
5212 env(trust(buyer, gwXAU(2000)));
5213 env(trust(buyer, gwXPB(2000)));
5217 env(rate(gw, 1.02));
5220 auto expectInitialState =
5221 [
this, &env, &buyer, &minter, &secondarySeller, &broker, &gw, &gwXAU, &gwXPB] {
5226 BEAST_EXPECT(env.balance(buyer, gwXAU) == gwXAU(1000));
5227 BEAST_EXPECT(env.balance(buyer, gwXPB) == gwXPB(0));
5228 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(0));
5229 BEAST_EXPECT(env.balance(minter, gwXPB) == gwXPB(0));
5230 BEAST_EXPECT(env.balance(secondarySeller, gwXAU) == gwXAU(0));
5231 BEAST_EXPECT(env.balance(secondarySeller, gwXPB) == gwXPB(0));
5232 BEAST_EXPECT(env.balance(broker, gwXAU) == gwXAU(5000));
5233 BEAST_EXPECT(env.balance(broker, gwXPB) == gwXPB(0));
5234 BEAST_EXPECT(env.balance(gw, buyer[
"XAU"]) == gwXAU(-1000));
5235 BEAST_EXPECT(env.balance(gw, buyer[
"XPB"]) == gwXPB(0));
5236 BEAST_EXPECT(env.balance(gw, minter[
"XAU"]) == gwXAU(0));
5237 BEAST_EXPECT(env.balance(gw, minter[
"XPB"]) == gwXPB(0));
5238 BEAST_EXPECT(env.balance(gw, secondarySeller[
"XAU"]) == gwXAU(0));
5239 BEAST_EXPECT(env.balance(gw, secondarySeller[
"XPB"]) == gwXPB(0));
5240 BEAST_EXPECT(env.balance(gw, broker[
"XAU"]) == gwXAU(-5000));
5241 BEAST_EXPECT(env.balance(gw, broker[
"XPB"]) == gwXPB(0));
5244 auto const reinitializeTrustLineBalances = [&expectInitialState,
5253 if (
auto const difference = gwXAU(1000) - env.balance(buyer, gwXAU);
5254 difference > gwXAU(0))
5255 env(pay(gw, buyer, difference));
5256 if (env.balance(buyer, gwXPB) > gwXPB(0))
5257 env(pay(buyer, gw, env.balance(buyer, gwXPB)));
5258 if (env.balance(minter, gwXAU) > gwXAU(0))
5259 env(pay(minter, gw, env.balance(minter, gwXAU)));
5260 if (env.balance(minter, gwXPB) > gwXPB(0))
5261 env(pay(minter, gw, env.balance(minter, gwXPB)));
5262 if (env.balance(secondarySeller, gwXAU) > gwXAU(0))
5263 env(pay(secondarySeller, gw, env.balance(secondarySeller, gwXAU)));
5264 if (env.balance(secondarySeller, gwXPB) > gwXPB(0))
5265 env(pay(secondarySeller, gw, env.balance(secondarySeller, gwXPB)));
5266 auto brokerDiff = gwXAU(5000) - env.balance(broker, gwXAU);
5267 if (brokerDiff > gwXAU(0))
5269 env(pay(gw, broker, brokerDiff));
5271 else if (brokerDiff < gwXAU(0))
5273 brokerDiff.negate();
5274 env(pay(broker, gw, brokerDiff));
5276 if (env.balance(broker, gwXPB) > gwXPB(0))
5277 env(pay(broker, gw, env.balance(broker, gwXPB)));
5279 expectInitialState();
5282 auto const mintNFT = [&env](
Account const& minter,
int transferFee = 0) {
5283 UInt256 const nftID = token::getNextID(env, minter, 0, tfTransferable, transferFee);
5284 env(token::mint(minter), token::XferFee(transferFee), Txflags(tfTransferable));
5289 auto const createBuyOffer = [&env](
5297 env(token::createOffer(offerer, nftID, amount),
5298 token::Owner(owner),
5299 terCode ? Ter(*terCode) : Ter(
static_cast<TER>(
tesSUCCESS)));
5304 auto const createSellOffer = [&env](
5311 env(token::createOffer(offerer, nftID, amount),
5312 Txflags(tfSellNFToken),
5313 terCode ? Ter(*terCode) : Ter(
static_cast<TER>(
tesSUCCESS)));
5321 reinitializeTrustLineBalances();
5322 auto const nftID = mintNFT(minter);
5323 auto const offerID = createSellOffer(minter, nftID, gwXAU(1000));
5325 env(token::acceptSellOffer(buyer, offerID), Ter(sellTER));
5328 expectInitialState();
5333 reinitializeTrustLineBalances();
5334 auto const nftID = mintNFT(minter);
5335 auto const offerID = createBuyOffer(buyer, minter, nftID, gwXAU(1000));
5337 env(token::acceptBuyOffer(minter, offerID), Ter(sellTER));
5340 expectInitialState();
5346 reinitializeTrustLineBalances();
5347 auto const nftID = mintNFT(minter);
5348 auto const offerID = createSellOffer(minter, nftID, gwXAU(995));
5350 env(token::acceptSellOffer(buyer, offerID), Ter(sellTER));
5353 expectInitialState();
5359 reinitializeTrustLineBalances();
5360 auto const nftID = mintNFT(minter);
5361 auto const offerID = createBuyOffer(buyer, minter, nftID, gwXAU(995));
5363 env(token::acceptBuyOffer(minter, offerID), Ter(sellTER));
5366 expectInitialState();
5373 reinitializeTrustLineBalances();
5374 auto const nftID = mintNFT(minter);
5375 auto const offerID = createSellOffer(minter, nftID, gwXAU(900));
5376 env(token::acceptSellOffer(buyer, offerID));
5379 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(900));
5380 BEAST_EXPECT(env.balance(buyer, gwXAU) == gwXAU(82));
5381 BEAST_EXPECT(env.balance(gw, minter[
"XAU"]) == gwXAU(-900));
5382 BEAST_EXPECT(env.balance(gw, buyer[
"XAU"]) == gwXAU(-82));
5389 reinitializeTrustLineBalances();
5390 auto const nftID = mintNFT(minter);
5391 auto const offerID = createBuyOffer(buyer, minter, nftID, gwXAU(900));
5392 env(token::acceptBuyOffer(minter, offerID));
5395 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(900));
5396 BEAST_EXPECT(env.balance(buyer, gwXAU) == gwXAU(82));
5397 BEAST_EXPECT(env.balance(gw, minter[
"XAU"]) == gwXAU(-900));
5398 BEAST_EXPECT(env.balance(gw, buyer[
"XAU"]) == gwXAU(-82));
5405 reinitializeTrustLineBalances();
5408 env(pay(gw, buyer, gwXAU(20)));
5411 auto const nftID = mintNFT(minter);
5412 auto const offerID = createSellOffer(minter, nftID, gwXAU(1000));
5413 env(token::acceptSellOffer(buyer, offerID));
5416 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(1000));
5417 BEAST_EXPECT(env.balance(buyer, gwXAU) == gwXAU(0));
5418 BEAST_EXPECT(env.balance(gw, minter[
"XAU"]) == gwXAU(-1000));
5419 BEAST_EXPECT(env.balance(gw, buyer[
"XAU"]) == gwXAU(0));
5426 reinitializeTrustLineBalances();
5429 env(pay(gw, buyer, gwXAU(20)));
5432 auto const nftID = mintNFT(minter);
5433 auto const offerID = createBuyOffer(buyer, minter, nftID, gwXAU(1000));
5434 env(token::acceptBuyOffer(minter, offerID));
5437 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(1000));
5438 BEAST_EXPECT(env.balance(buyer, gwXAU) == gwXAU(0));
5439 BEAST_EXPECT(env.balance(gw, minter[
"XAU"]) == gwXAU(-1000));
5440 BEAST_EXPECT(env.balance(gw, buyer[
"XAU"]) == gwXAU(0));
5445 reinitializeTrustLineBalances();
5447 auto const nftID = mintNFT(minter);
5448 auto const offerID = createSellOffer(minter, nftID, gwXAU(1000));
5450 env(token::acceptSellOffer(gw, offerID), Ter(sellTER));
5453 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(1000));
5454 BEAST_EXPECT(env.balance(gw, minter[
"XAU"]) == gwXAU(-1000));
5459 reinitializeTrustLineBalances();
5461 auto const nftID = mintNFT(minter);
5463 auto const offerID = createBuyOffer(gw, minter, nftID, gwXAU(1000), {offerTER});
5465 env(token::acceptBuyOffer(minter, offerID), Ter(sellTER));
5468 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(1000));
5469 BEAST_EXPECT(env.balance(gw, minter[
"XAU"]) == gwXAU(-1000));
5474 reinitializeTrustLineBalances();
5475 auto const nftID = mintNFT(minter);
5476 auto const offerID = createSellOffer(minter, nftID, gwXAU(5000));
5478 env(token::acceptSellOffer(gw, offerID), Ter(sellTER));
5481 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(5000));
5482 BEAST_EXPECT(env.balance(gw, minter[
"XAU"]) == gwXAU(-5000));
5487 reinitializeTrustLineBalances();
5489 auto const nftID = mintNFT(minter);
5491 auto const offerID = createBuyOffer(gw, minter, nftID, gwXAU(5000), {offerTER});
5493 env(token::acceptBuyOffer(minter, offerID), Ter(sellTER));
5496 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(5000));
5497 BEAST_EXPECT(env.balance(gw, minter[
"XAU"]) == gwXAU(-5000));
5503 reinitializeTrustLineBalances();
5504 auto const nftID = mintNFT(gw);
5505 auto const offerID = createSellOffer(gw, nftID, gwXAU(1000));
5506 env(token::acceptSellOffer(buyer, offerID));
5509 BEAST_EXPECT(env.balance(buyer, gwXAU) == gwXAU(0));
5510 BEAST_EXPECT(env.balance(gw, buyer[
"XAU"]) == gwXAU(0));
5516 reinitializeTrustLineBalances();
5518 auto const nftID = mintNFT(gw);
5519 auto const offerID = createBuyOffer(buyer, gw, nftID, gwXAU(1000));
5520 env(token::acceptBuyOffer(gw, offerID));
5523 BEAST_EXPECT(env.balance(buyer, gwXAU) == gwXAU(0));
5524 BEAST_EXPECT(env.balance(gw, buyer[
"XAU"]) == gwXAU(0));
5530 reinitializeTrustLineBalances();
5531 auto const nftID = mintNFT(gw);
5532 auto const offerID = createSellOffer(gw, nftID, gwXAU(2000));
5533 env(token::acceptSellOffer(buyer, offerID),
5536 expectInitialState();
5542 reinitializeTrustLineBalances();
5543 auto const nftID = mintNFT(gw);
5544 auto const offerID = createBuyOffer(buyer, gw, nftID, gwXAU(2000));
5545 env(token::acceptBuyOffer(gw, offerID),
5548 expectInitialState();
5553 reinitializeTrustLineBalances();
5554 auto const nftID = mintNFT(minter);
5555 auto const offerID = createSellOffer(minter, nftID, gwXPB(10));
5556 env(token::acceptSellOffer(buyer, offerID),
5559 expectInitialState();
5564 reinitializeTrustLineBalances();
5565 auto const nftID = mintNFT(minter);
5566 auto const offerID = createBuyOffer(
5568 env(token::acceptBuyOffer(minter, offerID),
5571 expectInitialState();
5577 reinitializeTrustLineBalances();
5578 env(pay(gw, buyer, gwXPB(100)));
5581 auto const nftID = mintNFT(minter);
5582 auto const offerID = createSellOffer(minter, nftID, gwXPB(10));
5583 env(token::acceptSellOffer(buyer, offerID));
5586 BEAST_EXPECT(env.balance(minter, gwXPB) == gwXPB(10));
5587 BEAST_EXPECT(env.balance(buyer, gwXPB) == gwXPB(89.8));
5588 BEAST_EXPECT(env.balance(gw, minter[
"XPB"]) == gwXPB(-10));
5589 BEAST_EXPECT(env.balance(gw, buyer[
"XPB"]) == gwXPB(-89.8));
5595 reinitializeTrustLineBalances();
5596 env(pay(gw, buyer, gwXPB(100)));
5599 auto const nftID = mintNFT(minter);
5600 auto const offerID = createBuyOffer(buyer, minter, nftID, gwXPB(10));
5601 env(token::acceptBuyOffer(minter, offerID));
5604 BEAST_EXPECT(env.balance(minter, gwXPB) == gwXPB(10));
5605 BEAST_EXPECT(env.balance(buyer, gwXPB) == gwXPB(89.8));
5606 BEAST_EXPECT(env.balance(gw, minter[
"XPB"]) == gwXPB(-10));
5607 BEAST_EXPECT(env.balance(gw, buyer[
"XPB"]) == gwXPB(-89.8));
5612 reinitializeTrustLineBalances();
5616 auto const nftID = mintNFT(minter, 3000);
5617 auto const primaryOfferID = createSellOffer(minter, nftID, XRP(0));
5618 env(token::acceptSellOffer(secondarySeller, primaryOfferID));
5622 auto const offerID = createSellOffer(secondarySeller, nftID, gwXAU(1000));
5624 env(token::acceptSellOffer(buyer, offerID), Ter(sellTER));
5627 expectInitialState();
5632 reinitializeTrustLineBalances();
5636 auto const nftID = mintNFT(minter, 3000);
5637 auto const primaryOfferID = createSellOffer(minter, nftID, XRP(0));
5638 env(token::acceptSellOffer(secondarySeller, primaryOfferID));
5642 auto const offerID = createBuyOffer(buyer, secondarySeller, nftID, gwXAU(1000));
5644 env(token::acceptBuyOffer(secondarySeller, offerID), Ter(sellTER));
5647 expectInitialState();
5652 reinitializeTrustLineBalances();
5656 auto const nftID = mintNFT(minter, 3000);
5657 auto const primaryOfferID = createSellOffer(minter, nftID, XRP(0));
5658 env(token::acceptSellOffer(secondarySeller, primaryOfferID));
5662 auto const offerID = createSellOffer(secondarySeller, nftID, gwXAU(900));
5663 env(token::acceptSellOffer(buyer, offerID));
5666 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(27));
5667 BEAST_EXPECT(env.balance(secondarySeller, gwXAU) == gwXAU(873));
5668 BEAST_EXPECT(env.balance(buyer, gwXAU) == gwXAU(82));
5669 BEAST_EXPECT(env.balance(gw, minter[
"XAU"]) == gwXAU(-27));
5670 BEAST_EXPECT(env.balance(gw, secondarySeller[
"XAU"]) == gwXAU(-873));
5671 BEAST_EXPECT(env.balance(gw, buyer[
"XAU"]) == gwXAU(-82));
5676 reinitializeTrustLineBalances();
5680 auto const nftID = mintNFT(minter, 3000);
5681 auto const primaryOfferID = createSellOffer(minter, nftID, XRP(0));
5682 env(token::acceptSellOffer(secondarySeller, primaryOfferID));
5686 auto const offerID = createBuyOffer(buyer, secondarySeller, nftID, gwXAU(900));
5687 env(token::acceptBuyOffer(secondarySeller, offerID));
5691 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(27));
5693 BEAST_EXPECT(env.balance(secondarySeller, gwXAU) == gwXAU(873));
5695 BEAST_EXPECT(env.balance(buyer, gwXAU) == gwXAU(82));
5696 BEAST_EXPECT(env.balance(gw, minter[
"XAU"]) == gwXAU(-27));
5697 BEAST_EXPECT(env.balance(gw, secondarySeller[
"XAU"]) == gwXAU(-873));
5698 BEAST_EXPECT(env.balance(gw, buyer[
"XAU"]) == gwXAU(-82));
5716 reinitializeTrustLineBalances();
5718 auto const nftID = mintNFT(minter);
5719 auto const sellOffer = createSellOffer(minter, nftID, gwXAU(300));
5720 auto const buyOffer = createBuyOffer(buyer, minter, nftID, gwXAU(500));
5721 env(token::brokerOffers(broker, buyOffer, sellOffer), token::BrokerFee(gwXAU(100)));
5724 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(400));
5725 BEAST_EXPECT(env.balance(buyer, gwXAU) == gwXAU(490));
5726 BEAST_EXPECT(env.balance(broker, gwXAU) == gwXAU(5100));
5727 BEAST_EXPECT(env.balance(gw, minter[
"XAU"]) == gwXAU(-400));
5728 BEAST_EXPECT(env.balance(gw, buyer[
"XAU"]) == gwXAU(-490));
5729 BEAST_EXPECT(env.balance(gw, broker[
"XAU"]) == gwXAU(-5100));
5747 reinitializeTrustLineBalances();
5751 auto const nftID = mintNFT(minter, 3000);
5752 auto const primaryOfferID = createSellOffer(minter, nftID, XRP(0));
5753 env(token::acceptSellOffer(secondarySeller, primaryOfferID));
5757 auto const sellOffer = createSellOffer(secondarySeller, nftID, gwXAU(300));
5758 auto const buyOffer = createBuyOffer(buyer, secondarySeller, nftID, gwXAU(500));
5759 env(token::brokerOffers(broker, buyOffer, sellOffer), token::BrokerFee(gwXAU(100)));
5762 BEAST_EXPECT(env.balance(minter, gwXAU) == gwXAU(12));
5763 BEAST_EXPECT(env.balance(buyer, gwXAU) == gwXAU(490));
5764 BEAST_EXPECT(env.balance(secondarySeller, gwXAU) == gwXAU(388));
5765 BEAST_EXPECT(env.balance(broker, gwXAU) == gwXAU(5100));
5766 BEAST_EXPECT(env.balance(gw, minter[
"XAU"]) == gwXAU(-12));
5767 BEAST_EXPECT(env.balance(gw, buyer[
"XAU"]) == gwXAU(-490));
5768 BEAST_EXPECT(env.balance(gw, secondarySeller[
"XAU"]) == gwXAU(-388));
5769 BEAST_EXPECT(env.balance(gw, broker[
"XAU"]) == gwXAU(-5100));
5872 auto openLedgerSeq = [](Env& env) {
return env.current()->seq(); };
5876 auto const incLgrSeqForAcctDel = [&](Env& env,
Account const& acct) {
5877 int const delta = [&] ->
int {
5878 if (env.seq(acct) + 255 > openLedgerSeq(env))
5879 return env.seq(acct) - openLedgerSeq(env) + 255;
5882 BEAST_EXPECT(delta >= 0);
5883 for (
int i = 0; i < delta; ++i)
5885 BEAST_EXPECT(openLedgerSeq(env) == env.seq(acct) + 255);
5890 auto const incLgrSeqForFixNftRemint = [&](Env& env,
Account const& acct) {
5892 auto const deletableLgrSeq = (*env.le(acct))[~sfFirstNFTokenSequence].value_or(0) +
5893 (*env.le(acct))[sfMintedNFTokens] + 255;
5895 if (deletableLgrSeq > openLedgerSeq(env))
5896 delta = deletableLgrSeq - openLedgerSeq(env);
5898 BEAST_EXPECT(delta >= 0);
5899 for (
int i = 0; i < delta; ++i)
5901 BEAST_EXPECT(openLedgerSeq(env) == deletableLgrSeq);
5907 Env env{*
this, features};
5911 env.fund(XRP(10000), alice, becky);
5915 UInt256 const prevNFTokenID = token::getNextID(env, alice, 0u);
5916 env(token::mint(alice));
5918 env(token::burn(alice, prevNFTokenID));
5922 BEAST_EXPECT((*env.le(alice))[sfMintedNFTokens] == 1);
5925 incLgrSeqForAcctDel(env, alice);
5929 auto const acctDelFee{drops(env.current()->fees().increment)};
5930 env(acctdelete(alice, becky), Fee(acctDelFee));
5935 BEAST_EXPECT(!env.closed()->exists(aliceAcctKey));
5936 BEAST_EXPECT(!env.current()->exists(aliceAcctKey));
5939 env.fund(XRP(10000), alice);
5943 BEAST_EXPECT(env.closed()->exists(aliceAcctKey));
5944 BEAST_EXPECT(env.current()->exists(aliceAcctKey));
5945 BEAST_EXPECT((*env.le(alice))[sfMintedNFTokens] == 0);
5948 UInt256 const remintNFTokenID = token::getNextID(env, alice, 0u);
5949 env(token::mint(alice));
5953 env(token::burn(alice, remintNFTokenID));
5957 BEAST_EXPECT(remintNFTokenID != prevNFTokenID);
5963 Env env{*
this, features};
5966 Account const minter{
"minter"};
5968 env.fund(XRP(10000), alice, becky, minter);
5972 env(token::setMinter(alice, minter));
5978 for (
int i = 0; i < 500; i++)
5980 UInt256 const nftokenID = token::getNextID(env, alice, 0u);
5982 env(token::mint(minter), token::Issuer(alice));
5987 for (
auto const nftokenID : nftIDs)
5989 env(token::burn(minter, nftokenID));
5993 incLgrSeqForAcctDel(env, alice);
5997 BEAST_EXPECT(env.closed()->exists(aliceAcctKey));
5998 BEAST_EXPECT(env.current()->exists(aliceAcctKey));
6000 auto const acctDelFee{drops(env.current()->fees().increment)};
6009 env(acctdelete(alice, becky), Fee(acctDelFee), Ter(
tecTOO_SOON));
6013 BEAST_EXPECT(env.current()->exists(aliceAcctKey));
6018 incLgrSeqForFixNftRemint(env, alice);
6021 env(acctdelete(alice, becky), Fee(acctDelFee));
6026 BEAST_EXPECT(!env.closed()->exists(aliceAcctKey));
6027 BEAST_EXPECT(!env.current()->exists(aliceAcctKey));
6030 env.fund(XRP(10000), alice);
6034 BEAST_EXPECT(env.closed()->exists(aliceAcctKey));
6035 BEAST_EXPECT(env.current()->exists(aliceAcctKey));
6036 BEAST_EXPECT((*env.le(alice))[sfMintedNFTokens] == 0);
6040 UInt256 const remintNFTokenID = token::getNextID(env, alice, 0u);
6041 env(token::mint(alice));
6045 env(token::burn(alice, remintNFTokenID));
6056 Env env{*
this, features};
6060 env.fund(XRP(10000), alice, becky);
6067 env(ticket::create(alice, 100));
6076 for (
int i = 0; i < 50; i++)
6078 nftIDs.
push_back(token::getNextID(env, alice, 0u));
6079 env(token::mint(alice, 0u), ticket::Use(aliceTicketSeq++));
6084 for (
auto const nftokenID : nftIDs)
6086 env(token::burn(alice, nftokenID), ticket::Use(aliceTicketSeq++));
6092 incLgrSeqForAcctDel(env, alice);
6096 BEAST_EXPECT(env.closed()->exists(aliceAcctKey));
6097 BEAST_EXPECT(env.current()->exists(aliceAcctKey));
6099 auto const acctDelFee{drops(env.current()->fees().increment)};
6108 env(acctdelete(alice, becky), Fee(acctDelFee), Ter(
tecTOO_SOON));
6112 BEAST_EXPECT(env.current()->exists(aliceAcctKey));
6117 incLgrSeqForFixNftRemint(env, alice);
6120 env(acctdelete(alice, becky), Fee(acctDelFee));
6125 BEAST_EXPECT(!env.closed()->exists(aliceAcctKey));
6126 BEAST_EXPECT(!env.current()->exists(aliceAcctKey));
6129 env.fund(XRP(10000), alice);
6133 BEAST_EXPECT(env.closed()->exists(aliceAcctKey));
6134 BEAST_EXPECT(env.current()->exists(aliceAcctKey));
6135 BEAST_EXPECT((*env.le(alice))[sfMintedNFTokens] == 0);
6139 UInt256 const remintNFTokenID = token::getNextID(env, alice, 0u);
6140 env(token::mint(alice));
6144 env(token::burn(alice, remintNFTokenID));
6156 Env env{*
this, features};
6159 Account const minter{
"minter"};
6161 env.fund(XRP(10000), alice, becky, minter);
6165 env(token::setMinter(alice, minter));
6170 env(ticket::create(minter, 100));
6174 BEAST_EXPECT(
ownerCount(env, minter) == 100);
6179 for (
int i = 0; i < 50; i++)
6181 UInt256 const nftokenID = token::getNextID(env, alice, 0u);
6183 env(token::mint(minter), token::Issuer(alice), ticket::Use(minterTicketSeq++));
6188 for (
auto const nftokenID : nftIDs)
6190 env(token::burn(minter, nftokenID), ticket::Use(minterTicketSeq++));
6196 incLgrSeqForAcctDel(env, alice);
6200 BEAST_EXPECT(env.closed()->exists(aliceAcctKey));
6201 BEAST_EXPECT(env.current()->exists(aliceAcctKey));
6210 auto const acctDelFee{drops(env.current()->fees().increment)};
6211 env(acctdelete(alice, becky), Fee(acctDelFee), Ter(
tecTOO_SOON));
6215 BEAST_EXPECT(env.current()->exists(aliceAcctKey));
6220 incLgrSeqForFixNftRemint(env, alice);
6223 env(acctdelete(alice, becky), Fee(acctDelFee));
6228 BEAST_EXPECT(!env.closed()->exists(aliceAcctKey));
6229 BEAST_EXPECT(!env.current()->exists(aliceAcctKey));
6232 env.fund(XRP(10000), alice);
6236 BEAST_EXPECT(env.closed()->exists(aliceAcctKey));
6237 BEAST_EXPECT(env.current()->exists(aliceAcctKey));
6238 BEAST_EXPECT((*env.le(alice))[sfMintedNFTokens] == 0);
6242 UInt256 const remintNFTokenID = token::getNextID(env, alice, 0u);
6243 env(token::mint(alice));
6247 env(token::burn(alice, remintNFTokenID));
6513 testcase(
"Test synthetic fields from JSON response");
6519 Account const broker{
"broker"};
6521 Env env{*
this, features};
6522 env.fund(XRP(10000), alice, bob, broker);
6528 if (tx.isMember(jss::meta))
6529 return &tx[jss::meta];
6530 if (tx.isMember(jss::metaData))
6531 return &tx[jss::metaData];
6540 return entry[jss::tx][jss::hash].
asString();
6541 if (entry.
isMember(jss::tx_json) && entry[jss::tx_json].
isMember(jss::hash))
6542 return entry[jss::tx_json][jss::hash].
asString();
6543 return entry[jss::hash].
asString();
6552 auto verifyMetaInAllResponses = [&](
auto verifyMeta) {
6560 for (
unsigned const apiVersion : {
6566 json::Value const txResult = env.rpc(apiVersion,
"tx", txHash)[jss::result];
6567 verifyMeta(txResult[jss::meta]);
6572 ledgerParams[jss::ledger_index] = txResult[jss::ledger_index].
asUInt();
6573 ledgerParams[jss::transactions] =
true;
6574 ledgerParams[jss::expand] =
true;
6576 auto const ledgerResult =
6577 env.rpc(apiVersion,
"json",
"ledger",
to_string(ledgerParams));
6578 auto const& ledgerTx =
6579 ledgerResult[jss::result][jss::ledger][jss::transactions][0u];
6582 BEAST_EXPECT(getHash(ledgerTx) == txHash);
6584 if (
auto const* meta = getMeta(ledgerTx); BEAST_EXPECT(meta !=
nullptr))
6591 accountTxParams[jss::account] = txResult.
isMember(jss::tx_json)
6592 ? txResult[jss::tx_json][jss::Account].
asString()
6593 : txResult[jss::Account].
asString();
6595 auto const accountTxResult =
6596 env.rpc(apiVersion,
"json",
"account_tx",
to_string(accountTxParams));
6602 for (
auto const& entry : accountTxResult[jss::result][jss::transactions])
6604 if (getHash(entry) == txHash)
6611 if (!BEAST_EXPECT(accountTx !=
nullptr))
6614 if (
auto const* meta = getMeta(*accountTx); BEAST_EXPECT(meta !=
nullptr))
6622 auto const verifyNFTokenID = [&](
UInt256 const& actualNftID) {
6623 verifyMetaInAllResponses([&](
json::Value const& meta) {
6625 if (!BEAST_EXPECT(meta.
isMember(jss::nftoken_id)))
6631 BEAST_EXPECT(nftID == actualNftID);
6641 verifyMetaInAllResponses([&](
json::Value const& meta) {
6643 if (!BEAST_EXPECT(meta.
isMember(jss::nftoken_ids)))
6649 meta[jss::nftoken_ids].begin(),
6650 meta[jss::nftoken_ids].end(),
6654 BEAST_EXPECT(nftID.
parseHex(
id.asString()));
6661 if (!BEAST_EXPECT(metaIDs.
size() == actualNftIDs.size()))
6666 for (
size_t i = 0; i < metaIDs.
size(); ++i)
6667 BEAST_EXPECT(metaIDs[i] == actualNftIDs[i]);
6673 auto const verifyNFTokenOfferID = [&](
UInt256 const& offerID) {
6674 verifyMetaInAllResponses([&](
json::Value const& meta) {
6676 if (!BEAST_EXPECT(meta.
isMember(jss::offer_id)))
6681 BEAST_EXPECT(metaOfferID == offerID);
6689 UInt256 const nftId1{token::getNextID(env, alice, 0u, tfTransferable)};
6690 env(token::mint(alice, 0u), Txflags(tfTransferable));
6692 verifyNFTokenID(nftId1);
6694 UInt256 const nftId2{token::getNextID(env, alice, 0u, tfTransferable)};
6695 env(token::mint(alice, 0u), Txflags(tfTransferable));
6697 verifyNFTokenID(nftId2);
6702 UInt256 const aliceOfferIndex1 =
6704 env(token::createOffer(alice, nftId1, drops(1)), Txflags(tfSellNFToken));
6706 verifyNFTokenOfferID(aliceOfferIndex1);
6708 UInt256 const aliceOfferIndex2 =
6710 env(token::createOffer(alice, nftId2, drops(1)), Txflags(tfSellNFToken));
6712 verifyNFTokenOfferID(aliceOfferIndex2);
6717 env(token::cancelOffer(alice, {aliceOfferIndex1, aliceOfferIndex2}));
6719 verifyNFTokenIDsInCancelOffer({nftId1, nftId2});
6723 auto const bobBuyOfferIndex =
6725 env(token::createOffer(bob, nftId1, drops(1)), token::Owner(alice));
6727 verifyNFTokenOfferID(bobBuyOfferIndex);
6731 env(token::acceptBuyOffer(alice, bobBuyOfferIndex));
6733 verifyNFTokenID(nftId1);
6739 UInt256 const nftId{token::getNextID(env, alice, 0u, tfTransferable)};
6740 env(token::mint(alice, 0u), Txflags(tfTransferable));
6742 verifyNFTokenID(nftId);
6745 UInt256 const offerAliceToBroker =
6747 env(token::createOffer(alice, nftId, drops(1)),
6748 token::Destination(broker),
6749 Txflags(tfSellNFToken));
6751 verifyNFTokenOfferID(offerAliceToBroker);
6754 UInt256 const offerBobToBroker =
6756 env(token::createOffer(bob, nftId, drops(1)), token::Owner(alice));
6758 verifyNFTokenOfferID(offerBobToBroker);
6761 env(token::brokerOffers(broker, offerBobToBroker, offerAliceToBroker));
6763 verifyNFTokenID(nftId);
6770 UInt256 const nftId{token::getNextID(env, alice, 0u, tfTransferable)};
6771 env(token::mint(alice, 0u), Txflags(tfTransferable));
6773 verifyNFTokenID(nftId);
6776 UInt256 const aliceOfferIndex1 =
6778 env(token::createOffer(alice, nftId, drops(1)), Txflags(tfSellNFToken));
6780 verifyNFTokenOfferID(aliceOfferIndex1);
6782 UInt256 const aliceOfferIndex2 =
6784 env(token::createOffer(alice, nftId, drops(1)), Txflags(tfSellNFToken));
6786 verifyNFTokenOfferID(aliceOfferIndex2);
6790 env(token::cancelOffer(alice, {aliceOfferIndex1, aliceOfferIndex2}));
6792 verifyNFTokenIDsInCancelOffer({nftId});
6795 if (features[featureNFTokenMintOffer])
6797 UInt256 const aliceMintWithOfferIndex1 =
6799 env(token::mint(alice), token::Amount(XRP(0)));
6801 verifyNFTokenOfferID(aliceMintWithOfferIndex1);
6808 testcase(
"Test buyer reserve when accepting an offer");
6813 auto const mintAndCreateSellOffer =
6816 UInt256 const nftId{token::getNextID(env, acct, 0u, tfTransferable)};
6817 env(token::mint(acct, 0u), Txflags(tfTransferable));
6821 UInt256 const sellOfferIndex =
6823 env(token::createOffer(acct, nftId, amt), Txflags(tfSellNFToken));
6826 return sellOfferIndex;
6836 Env env{*
this, features};
6837 auto const acctReserve = env.
current()->fees().reserve;
6838 auto const incReserve = env.current()->fees().increment;
6839 auto const baseFee = env.current()->fees().base;
6841 env.fund(XRP(10000), alice);
6845 env.fund(acctReserve, bob);
6849 auto const sellOfferIndex = mintAndCreateSellOffer(env, alice, XRP(0));
6874 env(pay(env.master, bob, incReserve + drops(baseFee)));
6884 env(pay(env.master, bob, drops(baseFee * 2)));
6888 env(token::acceptSellOffer(bob, sellOfferIndex));
6900 Env env{*
this, features};
6901 auto const acctReserve = env.
current()->fees().reserve;
6902 auto const incReserve = env.current()->fees().increment;
6904 env.fund(XRP(10000), alice);
6907 env.fund(acctReserve + XRP(1), bob);
6911 auto const sellOfferIndex1 = mintAndCreateSellOffer(env, alice, XRP(0));
6919 env(pay(env.master, bob, drops(incReserve)));
6925 env(token::acceptSellOffer(bob, sellOfferIndex1));
6932 for (
size_t i = 0; i < 31; i++)
6935 auto const sellOfferIndex = mintAndCreateSellOffer(env, alice, XRP(0));
6939 env(token::acceptSellOffer(bob, sellOfferIndex));
6947 auto const sellOfferIndex33 = mintAndCreateSellOffer(env, alice, XRP(0));
6955 env(pay(env.master, bob, drops(incReserve)));
6960 env(token::acceptSellOffer(bob, sellOfferIndex33));
6971 Env env{*
this, features};
6972 auto const acctReserve = env.
current()->fees().reserve;
6973 auto const incReserve = env.current()->fees().increment;
6974 auto const baseFee = env.current()->fees().base;
6976 env.fund(XRP(10000), alice);
6982 env.fund(acctReserve + incReserve + XRP(1), bob);
6986 UInt256 const nftId{token::getNextID(env, alice, 0u, tfTransferable)};
6987 env(token::mint(alice, 0u), Txflags(tfTransferable));
6991 auto const buyOfferIndex =
6993 env(token::createOffer(bob, nftId, XRP(1)), token::Owner(alice));
7003 env(pay(env.master, bob, drops(baseFee)));
7007 env(token::acceptBuyOffer(alice, buyOfferIndex));
7015 Account const broker{
"broker"};
7017 Env env{*
this, features};
7018 auto const acctReserve = env.
current()->fees().reserve;
7019 auto const incReserve = env.current()->fees().increment;
7020 auto const baseFee = env.current()->fees().base;
7022 env.fund(XRP(10000), alice, broker);
7027 env.fund(acctReserve + incReserve + XRP(1), bob);
7031 UInt256 const nftId{token::getNextID(env, alice, 0u, tfTransferable)};
7032 env(token::mint(alice, 0u), Txflags(tfTransferable));
7036 UInt256 const offerAliceToBroker =
7038 env(token::createOffer(alice, nftId, XRP(1)),
7039 token::Destination(broker),
7040 Txflags(tfSellNFToken));
7044 UInt256 const offerBobToBroker =
7046 env(token::createOffer(bob, nftId, XRP(1)), token::Owner(alice));
7053 env(token::brokerOffers(broker, offerBobToBroker, offerAliceToBroker),
7058 env(pay(env.master, bob, drops(baseFee)));
7062 env(token::brokerOffers(broker, offerBobToBroker, offerAliceToBroker));
7389 Account const issuer{
"issuer"};
7393 bool const modifyEnabled = features[featureDynamicNFT];
7397 Env env{*
this, features};
7398 env.fund(XRP(10000), issuer);
7402 env(token::mint(issuer, 0u), Txflags(tfMutable), Ter(expectedTer));
7406 Env env{*
this, features};
7407 env.fund(XRP(10000), issuer);
7411 UInt256 const nftId{token::getNextID(env, issuer, 0u, tfMutable)};
7414 env(token::mint(issuer, 0u), Txflags(tfMutable));
7417 env(token::modify(issuer, nftId));
7422 env(token::mint(issuer, 0u));
7424 env(token::modify(issuer, nftId), Ter(
temDISABLED));
7432 Env env{*
this, features};
7433 env.fund(XRP(10000), issuer);
7436 UInt256 const nftId{token::getNextID(env, issuer, 0u, tfMutable)};
7437 env(token::mint(issuer, 0u), Txflags(tfMutable));
7445 env(token::modify(issuer, nftId), Txflags(0x00000001), Ter(
temINVALID_FLAG));
7448 env(token::modify(issuer, nftId), token::Owner(issuer), Ter(
temMALFORMED));
7452 env(token::modify(issuer, nftId), token::Uri(
""), Ter(
temMALFORMED));
7456 env(token::modify(issuer, nftId),
7462 Env env{*
this, features};
7463 env.fund(XRP(10000), issuer, alice, bob);
7468 UInt256 const nftIDNotExists{token::getNextID(env, issuer, 0u, tfMutable)};
7471 env(token::modify(issuer, nftIDNotExists), Ter(
tecNO_ENTRY));
7476 UInt256 const nftIDNotModifiable{token::getNextID(env, issuer, 0u)};
7477 env(token::mint(issuer, 0u));
7485 UInt256 const nftId{token::getNextID(env, issuer, 0u, tfMutable)};
7486 env(token::mint(issuer, 0u), Txflags(tfMutable));
7489 env(token::modify(bob, nftId), token::Owner(issuer), Ter(
tecNO_PERMISSION));
7492 env(token::setMinter(issuer, alice));
7495 env(token::modify(bob, nftId), token::Owner(issuer), Ter(
tecNO_PERMISSION));
7500 Env env{*
this, features};
7501 env.fund(XRP(10000), issuer, alice, bob);
7505 UInt256 const nftId{token::getNextID(env, issuer, 0u, tfMutable)};
7506 env(token::mint(issuer, 0u), Txflags(tfMutable), token::Uri(
"uri"));
7513 Env env{*
this, features};
7514 env.fund(XRP(10000), issuer, alice, bob);
7518 auto accountNFTs = [&env](
Account const& acct) {
7520 params[jss::account] = acct.human();
7521 params[jss::type] =
"state";
7522 auto response = env.rpc(
"json",
"account_nfts",
to_string(params));
7523 return response[jss::result][jss::account_nfts];
7527 auto const checkURI = [&accountNFTs,
this](
7528 Account const& acct,
char const* uri,
int line) {
7529 auto const nfts = accountNFTs(acct);
7530 if (nfts.size() == 1)
7537 text <<
"checkURI: unexpected NFT count on line " << line;
7538 fail(text.
str(), __FILE__, line);
7544 if (!nfts[0u].isMember(sfURI.jsonName))
7551 text <<
"checkURI: unexpected URI present on line " << line;
7552 fail(text.
str(), __FILE__, line);
7564 text <<
"checkURI: unexpected URI contents on line " << line;
7565 fail(text.
str(), __FILE__, line);
7569 UInt256 const nftId{token::getNextID(env, issuer, 0u, tfMutable)};
7572 env(token::mint(issuer, 0u), Txflags(tfMutable), token::Uri(
"uri"));
7574 checkURI(issuer,
"uri", __LINE__);
7577 env(token::modify(issuer, nftId), token::Uri(
"new_uri"));
7579 checkURI(issuer,
"new_uri", __LINE__);
7582 env(token::modify(issuer, nftId));
7584 checkURI(issuer,
nullptr, __LINE__);
7587 env(token::modify(issuer, nftId), token::Uri(
"uri"));
7589 checkURI(issuer,
"uri", __LINE__);
7594 env(token::createOffer(issuer, nftId, XRP(0)), Txflags(tfSellNFToken));
7596 env(token::acceptSellOffer(alice, offerID));
7600 checkURI(alice,
"uri", __LINE__);
7603 env(token::modify(alice, nftId), token::Uri(
"new_uri"), Ter(
tecNO_PERMISSION));
7607 checkURI(alice,
"uri", __LINE__);
7609 env(token::modify(issuer, nftId), token::Owner(alice), token::Uri(
"new_uri"));
7613 checkURI(alice,
"new_uri", __LINE__);
7615 env(token::modify(issuer, nftId), token::Owner(alice));
7617 checkURI(alice,
nullptr, __LINE__);
7619 env(token::modify(issuer, nftId), token::Owner(alice), token::Uri(
"uri"));
7621 checkURI(alice,
"uri", __LINE__);
7624 env(token::setMinter(issuer, bob));
7626 env(token::modify(bob, nftId), token::Owner(alice), token::Uri(
"new_uri"));
7628 checkURI(alice,
"new_uri", __LINE__);
7630 env(token::modify(bob, nftId), token::Owner(alice));
7632 checkURI(alice,
nullptr, __LINE__);
7634 env(token::modify(bob, nftId), token::Owner(alice), token::Uri(
"uri"));
7636 checkURI(alice,
"uri", __LINE__);