ARCHIVE/clio
1
0
Fork 0
mirror of https://github.com/XRPLF/clio.git synced 2025-11-19 03:05:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: Support Dynamic NFT (#1525)

Browse Source 
Fix #1471
Clio's changes for supporting DNFT
https://github.com/XRPLF/rippled/pull/5048/files
This commit is contained in:
cyan317
2025-01-31 13:33:20 +00:00
committed by GitHub
parent e7702e9c11
commit 1753c95910
16 changed files with 952 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

423
tests/unit/etl/NFTHelpersTests.cpp
View File

@@ -22,56 +22,306 @@
#include "util/LoggerFixtures.hpp"
#include "util/TestObject.hpp"
#include <boost/asio/io_context.hpp>
#include <boost/asio/spawn.hpp>
#include <boost/json/array.hpp>
#include <boost/json/object.hpp>
#include <boost/json/parse.hpp>
#include <boost/json/value.hpp>
#include <gmock/gmock.h>
#include <grpcpp/support/status.h>
#include <gtest/gtest.h>
#include <xrpl/basics/Blob.h>
#include <xrpl/basics/Slice.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STObject.h>
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/Serializer.h>
#include <xrpl/protocol/TER.h>
#include <xrpl/protocol/TxFormats.h>
#include <xrpl/protocol/TxMeta.h>
#include <xrpl/protocol/UintTypes.h>
#include <xrpl/protocol/tokens.h>
#include <cstdint>
#include <optional>
#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
namespace {
constexpr auto kACCOUNT = "rM2AGCCCRb373FRuD8wHyUwUsh2dV4BW5Q";
constexpr auto kACCOUNT2 = "rnd1nHuzceyQDqnLH8urWNr4QBKt4v7WVk";
constexpr auto kNFT_ID = "0008013AE1CD8B79A8BCB52335CD40DE97401B2D60A828720000099B00000000";
constexpr auto kNFT_ID2 = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DA";
constexpr auto kOFFER1 = "23F1A95D7AAB7108D5CE7EEAF504B2894B8C674E6D68499076441C4837282BF8";
constexpr auto kTX = "13F1A95D7AAB7108D5CE7EEAF504B2894B8C674E6D68499076441C4837282BF8";
// Page index is a valid nft page for ACCOUNT
constexpr auto kPAGE_INDEX = "E1CD8B79A8BCB52335CD40DE97401B2D60A82872FFFFFFFFFFFFFFFFFFFFFFFF";
constexpr auto kOFFER_ID = "AA86CBF29770F72FA3FF4A5D9A9FA54D6F399A8E038F72393EF782224865E27F";
} // namespace
struct NFTHelpersTests : public NoLoggerFixture {};
struct NFTHelpersTest : NoLoggerFixture {
protected:
static void
verifyNFTTransactionsData(
NFTTransactionsData const& data,
ripple::STTx const& sttx,
ripple::TxMeta const& txMeta,
std::string_view nftId
)
{
EXPECT_EQ(data.tokenID, ripple::uint256(nftId));
EXPECT_EQ(data.ledgerSequence, txMeta.getLgrSeq());
EXPECT_EQ(data.transactionIndex, txMeta.getIndex());
EXPECT_EQ(data.txHash, sttx.getTransactionID());
}
TEST_F(NFTHelpersTests, ConvertDataFromNFTCancelOfferTx)
static void
verifyNFTsData(
NFTsData const& data,
ripple::STTx const& sttx,
ripple::TxMeta const& txMeta,
std::string_view nftId,
std::optional<std::string> const& owner
)
{
EXPECT_EQ(data.tokenID, ripple::uint256(nftId));
EXPECT_EQ(data.ledgerSequence, txMeta.getLgrSeq());
EXPECT_EQ(data.transactionIndex, txMeta.getIndex());
if (owner)
EXPECT_EQ(data.owner, getAccountIdWithString(*owner));
if (sttx.getTxnType() == ripple::ttNFTOKEN_MINT || sttx.getTxnType() == ripple::ttNFTOKEN_MODIFY) {
EXPECT_TRUE(data.uri.has_value());
EXPECT_EQ(*data.uri, sttx.getFieldVL(ripple::sfURI));
} else {
EXPECT_FALSE(data.uri.has_value());
}
if (sttx.getTxnType() == ripple::ttNFTOKEN_BURN) {
EXPECT_TRUE(data.isBurned);
} else {
EXPECT_FALSE(data.isBurned);
}
if (sttx.getTxnType() == ripple::ttNFTOKEN_MODIFY) {
EXPECT_TRUE(data.onlyUriChanged);
} else {
EXPECT_FALSE(data.onlyUriChanged);
}
}
};
TEST_F(NFTHelpersTest, NFTDataFromFailedTx)
{
auto const tx = createCancelNftOffersTxWithMetadata(kACCOUNT, 1, 2, std::vector<std::string>{kNFT_ID2, kNFT_ID});
ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata);
auto const tx = createNftModifyTxWithMetadata(kACCOUNT, kNFT_ID, ripple::Blob{});
// Inject a failed result
ripple::SerialIter sitMeta(ripple::makeSlice(tx.metadata));
ripple::STObject objMeta(sitMeta, ripple::sfMetadata);
objMeta.setFieldU8(ripple::sfTransactionResult, ripple::tecINCOMPLETE);
ripple::TxMeta txMeta(ripple::uint256(kTX), 1, objMeta.getSerializer().peekData());
auto const [nftTxs, nftDatas] =
etl::getNFTDataFromTx(txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}));
EXPECT_EQ(nftTxs.size(), 2);
EXPECT_EQ(nftTxs.size(), 0);
EXPECT_FALSE(nftDatas);
}
TEST_F(NFTHelpersTests, ConvertDataFromNFTCancelOfferTxContainingDuplicateNFT)
TEST_F(NFTHelpersTest, NotNFTTx)
{
auto const tx = createOracleSetTxWithMetadata(
kACCOUNT,
1,
123,
1,
4321u,
createPriceDataSeries({createOraclePriceData(1e3, ripple::to_currency("EUR"), ripple::to_currency("XRP"), 2)}),
kPAGE_INDEX,
false,
kTX
);
ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata);
auto const [nftTxs, nftDatas] =
etl::getNFTDataFromTx(txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}));
EXPECT_EQ(nftTxs.size(), 0);
EXPECT_FALSE(nftDatas);
}
TEST_F(NFTHelpersTest, NFTModifyWithURI)
{
std::string const uri("1234567890A");
ripple::Blob const uriBlob(uri.begin(), uri.end());
auto const tx = createNftModifyTxWithMetadata(kACCOUNT, kNFT_ID, uriBlob);
ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata);
auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()});
auto const [nftTxs, nftDatas] =
etl::getNFTDataFromTx(txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}));
EXPECT_EQ(nftTxs.size(), 1);
verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID);
verifyNFTsData(*nftDatas, sttx, txMeta, kNFT_ID, std::nullopt);
}
TEST_F(NFTHelpersTest, NFTModifyWithoutURI)
{
auto const tx = createNftModifyTxWithMetadata(kACCOUNT, kNFT_ID, ripple::Blob{});
ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata);
auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()});
auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx);
EXPECT_EQ(nftTxs.size(), 1);
verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID);
verifyNFTsData(*nftDatas, sttx, txMeta, kNFT_ID, std::nullopt);
}
TEST_F(NFTHelpersTest, NFTMintFromModifedNode)
{
auto const tx = createMintNftTxWithMetadata(kACCOUNT, 1, 20, 1, kNFT_ID);
ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata);
txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX));
auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()});
auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx);
EXPECT_EQ(nftTxs.size(), 1);
verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID);
verifyNFTsData(*nftDatas, sttx, txMeta, kNFT_ID, kACCOUNT);
}
TEST_F(NFTHelpersTest, NFTMintCantFindNewNFT)
{
// No NFT added to the page
auto const tx =
createMintNftTxWithMetadataOfCreatedNode(kACCOUNT, 1, 20, 1, std::nullopt, std::nullopt, kPAGE_INDEX);
ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata);
EXPECT_THROW(
etl::getNFTDataFromTx(txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()})),
std::runtime_error
);
}
TEST_F(NFTHelpersTest, NFTMintFromCreatedNode)
{
std::string const uri("1234567890A");
ripple::Blob const uriBlob(uri.begin(), uri.end());
auto const tx = createMintNftTxWithMetadataOfCreatedNode(kACCOUNT, 1, 20, 1, kNFT_ID, uri, kPAGE_INDEX);
ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata);
auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()});
auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx);
EXPECT_EQ(nftTxs.size(), 1);
verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID);
verifyNFTsData(*nftDatas, sttx, txMeta, kNFT_ID, kACCOUNT);
}
TEST_F(NFTHelpersTest, NFTMintWithoutUriField)
{
auto const tx = createMintNftTxWithMetadataOfCreatedNode(kACCOUNT, 1, 20, 1, kNFT_ID, std::nullopt, kPAGE_INDEX);
ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata);
auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()});
auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx);
EXPECT_EQ(nftTxs.size(), 1);
verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID);
verifyNFTsData(*nftDatas, sttx, txMeta, kNFT_ID, kACCOUNT);
}
TEST_F(NFTHelpersTest, NFTMintZeroMetaNode)
{
auto const tx = createMintNftTxWithMetadataOfCreatedNode(kACCOUNT, 1, 20, 1, kNFT_ID, std::nullopt, kPAGE_INDEX);
ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata);
txMeta.getNodes().clear();
EXPECT_THROW(
etl::getNFTDataFromTx(txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()})),
std::runtime_error
);
}
TEST_F(NFTHelpersTest, NFTBurnFromDeletedNode)
{
auto const tx = createNftBurnTxWithMetadataOfDeletedNode(kACCOUNT, kNFT_ID);
ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata);
txMeta.getNodes()[1].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX));
auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()});
auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx);
EXPECT_EQ(nftTxs.size(), 1);
verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID);
verifyNFTsData(*nftDatas, sttx, txMeta, kNFT_ID, kACCOUNT);
}
TEST_F(NFTHelpersTest, NFTBurnZeroMetaNode)
{
auto const tx = createNftBurnTxWithMetadataOfDeletedNode(kACCOUNT, kNFT_ID);
ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata);
txMeta.getNodes().clear();
EXPECT_THROW(
etl::getNFTDataFromTx(txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()})),
std::runtime_error
);
}
TEST_F(NFTHelpersTest, NFTBurnFromModifiedNode)
{
auto const tx = createNftBurnTxWithMetadataOfModifiedNode(kACCOUNT, kNFT_ID);
ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata);
txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX));
auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()});
auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx);
EXPECT_EQ(nftTxs.size(), 1);
verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID);
verifyNFTsData(*nftDatas, sttx, txMeta, kNFT_ID, kACCOUNT);
}
TEST_F(NFTHelpersTest, NFTCancelOffer)
{
auto const tx = createCancelNftOffersTxWithMetadata(kACCOUNT, 1, 2, std::vector<std::string>{kNFT_ID, kNFT_ID2});
ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata);
txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX));
auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()});
auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx);
EXPECT_EQ(nftTxs.size(), 2);
EXPECT_FALSE(nftDatas);
verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID);
verifyNFTTransactionsData(nftTxs[1], sttx, txMeta, kNFT_ID2);
}
TEST_F(NFTHelpersTest, NFTCancelOfferContainsDuplicateNFTs)
{
auto const tx = createCancelNftOffersTxWithMetadata(
kACCOUNT, 1, 2, std::vector<std::string>{kNFT_ID2, kNFT_ID, kNFT_ID2, kNFT_ID}
);
ripple::TxMeta const txMeta(ripple::uint256(kTX), 1, tx.metadata);
auto const [nftTxs, nftDatas] =
etl::getNFTDataFromTx(txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()}));
ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata);
auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()});
auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx);
EXPECT_EQ(nftTxs.size(), 2);
EXPECT_FALSE(nftDatas);
verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID);
verifyNFTTransactionsData(nftTxs[1], sttx, txMeta, kNFT_ID2);
}
TEST_F(NFTHelpersTests, UniqueNFTDatas)
TEST_F(NFTHelpersTest, UniqueNFTDatas)
{
std::vector<NFTsData> nftDatas;
@@ -104,3 +354,156 @@ TEST_F(NFTHelpersTests, UniqueNFTDatas)
EXPECT_EQ(uniqueNFTDatas[0].tokenID, ripple::uint256(kNFT_ID2));
EXPECT_EQ(uniqueNFTDatas[1].tokenID, ripple::uint256(kNFT_ID));
}
TEST_F(NFTHelpersTest, NFTAcceptBuyerOffer)
{
auto const tx = createAcceptNftBuyerOfferTxWithMetadata(kACCOUNT, 1, 2, kNFT_ID, kOFFER_ID);
ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata);
auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()});
auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx);
EXPECT_EQ(nftTxs.size(), 1);
EXPECT_TRUE(nftDatas);
verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID);
verifyNFTsData(*nftDatas, sttx, txMeta, kNFT_ID, kACCOUNT);
}
// The offer id in tx is different from the offer id in deleted node in metadata
TEST_F(NFTHelpersTest, NFTAcceptBuyerOfferCheckOfferIDFail)
{
auto const tx = createAcceptNftBuyerOfferTxWithMetadata(kACCOUNT, 1, 2, kNFT_ID, kOFFER_ID);
ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata);
// inject a different offer id
txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX));
EXPECT_THROW(
etl::getNFTDataFromTx(txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()})),
std::runtime_error
);
}
TEST_F(NFTHelpersTest, NFTAcceptSellerOfferFromCreatedNode)
{
auto const tx = createAcceptNftSellerOfferTxWithMetadata(kACCOUNT2, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, true);
ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata);
auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()});
auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx);
EXPECT_EQ(nftTxs.size(), 1);
EXPECT_TRUE(nftDatas);
verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID);
verifyNFTsData(*nftDatas, sttx, txMeta, kNFT_ID, kACCOUNT);
}
TEST_F(NFTHelpersTest, NFTAcceptSellerOfferFromModifiedNode)
{
auto const tx = createAcceptNftSellerOfferTxWithMetadata(kACCOUNT2, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, false);
ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata);
auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()});
auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx);
EXPECT_EQ(nftTxs.size(), 1);
EXPECT_TRUE(nftDatas);
verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID);
verifyNFTsData(*nftDatas, sttx, txMeta, kNFT_ID, kACCOUNT);
}
TEST_F(NFTHelpersTest, NFTAcceptSellerOfferCheckFail)
{
// The only changed nft page is owned by ACCOUNT, thus can't find the new owner
auto const tx = createAcceptNftSellerOfferTxWithMetadata(kACCOUNT, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, true);
ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata);
EXPECT_THROW(
etl::getNFTDataFromTx(txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()})),
std::runtime_error
);
}
TEST_F(NFTHelpersTest, NFTAcceptSellerOfferNotInMeta)
{
auto const tx = createAcceptNftSellerOfferTxWithMetadata(kACCOUNT, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, true);
ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata);
// inject a different offer id
txMeta.getNodes()[0].setFieldH256(ripple::sfLedgerIndex, ripple::uint256(kPAGE_INDEX));
EXPECT_THROW(
etl::getNFTDataFromTx(txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()})),
std::runtime_error
);
}
TEST_F(NFTHelpersTest, NFTAcceptSellerOfferZeroMetaNode)
{
auto const tx = createAcceptNftSellerOfferTxWithMetadata(kACCOUNT2, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, true);
ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata);
txMeta.getNodes().clear();
EXPECT_THROW(
etl::getNFTDataFromTx(txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()})),
std::runtime_error
);
}
TEST_F(NFTHelpersTest, NFTAcceptSellerOfferIDNotInMetaData)
{
auto const tx = createAcceptNftSellerOfferTxWithMetadata(kACCOUNT2, 1, 2, kNFT_ID, kOFFER_ID, kPAGE_INDEX, true);
ripple::TxMeta txMeta(ripple::uint256(kTX), 1, tx.metadata);
// The first node is offer, the second is nft page. Change the offer id to something else
txMeta.getNodes()[0]
.getField(ripple::sfFinalFields)
.downcast<ripple::STObject>()
.setFieldH256(ripple::sfNFTokenID, ripple::uint256(kNFT_ID2));
EXPECT_THROW(
etl::getNFTDataFromTx(txMeta, ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()})),
std::runtime_error
);
}
TEST_F(NFTHelpersTest, NFTCreateOffer)
{
auto const tx = createCreateNftOfferTxWithMetadata(kACCOUNT, 1, 2, kNFT_ID, 1, kOFFER_ID);
ripple::TxMeta txMeta(ripple::uint256(kTX), 5, tx.metadata);
auto const sttx = ripple::STTx(ripple::SerialIter{tx.transaction.data(), tx.transaction.size()});
auto const [nftTxs, nftDatas] = etl::getNFTDataFromTx(txMeta, sttx);
EXPECT_EQ(nftTxs.size(), 1);
EXPECT_FALSE(nftDatas);
verifyNFTTransactionsData(nftTxs[0], sttx, txMeta, kNFT_ID);
}
TEST_F(NFTHelpersTest, NFTDataFromLedgerObject)
{
std::string const url1 = "abcd1";
std::string const url2 = "abcd2";
ripple::Blob const uri1Blob(url1.begin(), url1.end());
ripple::Blob const uri2Blob(url2.begin(), url2.end());
auto const nftPage = createNftTokenPage({{kNFT_ID, url1}, {kNFT_ID2, url2}}, std::nullopt);
auto const serializerNftPage = nftPage.getSerializer();
int constexpr kSEQ{5};
auto const account = getAccountIdWithString(kACCOUNT);
auto const nftDatas = etl::getNFTDataFromObj(
kSEQ,
std::string(static_cast<char const*>(static_cast<void const*>(account.data())), ripple::AccountID::size()),
std::string(static_cast<char const*>(serializerNftPage.getDataPtr()), serializerNftPage.getDataLength())
);
EXPECT_EQ(nftDatas.size(), 2);
EXPECT_EQ(nftDatas[0].tokenID, ripple::uint256(kNFT_ID));
EXPECT_EQ(*(nftDatas[0].uri), uri1Blob);
EXPECT_FALSE(nftDatas[0].onlyUriChanged);
EXPECT_EQ(nftDatas[0].owner, account);
EXPECT_EQ(nftDatas[0].ledgerSequence, kSEQ);
EXPECT_FALSE(nftDatas[0].isBurned);
EXPECT_EQ(nftDatas[1].tokenID, ripple::uint256(kNFT_ID2));
EXPECT_EQ(*(nftDatas[1].uri), uri2Blob);
EXPECT_FALSE(nftDatas[1].onlyUriChanged);
EXPECT_EQ(nftDatas[1].owner, account);
EXPECT_EQ(nftDatas[1].ledgerSequence, kSEQ);
EXPECT_FALSE(nftDatas[1].isBurned);
}