Implement nextgen nft_info handler (#558)

Fixing #557

CMakeLists.txt

@@ -66,6 +66,7 @@ target_sources(clio PRIVATE
   src/rpc/ngHandlers/LedgerRange.cpp
   src/rpc/ngHandlers/BookOffers.cpp
   src/rpc/ngHandlers/TransactionEntry.cpp
+  src/rpc/ngHandlers/NFTInfo.cpp
   ## RPC Methods
   # Account
   src/rpc/handlers/AccountChannels.cpp
@@ -134,7 +135,8 @@ if(BUILD_TESTS)
     unittests/rpc/handlers/LedgerEntryTest.cpp
     unittests/rpc/handlers/LedgerRangeTest.cpp
     unittests/rpc/handlers/BookOffersTest.cpp
-    unittests/rpc/handlers/TransactionEntryTest.cpp)
+    unittests/rpc/handlers/TransactionEntryTest.cpp
+    unittests/rpc/handlers/NFTInfoTest.cpp)
   include(CMake/deps/gtest.cmake)
 
   # if CODE_COVERAGE enable, add clio_test-ccov

src/rpc/handlers/NFTInfo.cpp

@@ -54,8 +54,7 @@ doNFTInfo(Context const& context)
     response[JS(uri)] = ripple::strHex(dbResponse->uri);
 
     response[JS(flags)] = ripple::nft::getFlags(dbResponse->tokenID);
-    response["transfer_rate"] =
+    response["transfer_fee"] = ripple::nft::getTransferFee(dbResponse->tokenID);
-        ripple::nft::getTransferFee(dbResponse->tokenID);
     response[JS(issuer)] =
         ripple::toBase58(ripple::nft::getIssuer(dbResponse->tokenID));
     response["nft_taxon"] =

src/rpc/ngHandlers/NFTInfo.cpp

@@ -0,0 +1,129 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2023, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL,  DIRECT,  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#include <rpc/RPCHelpers.h>
+#include <rpc/ngHandlers/NFTInfo.h>
+
+#include <ripple/app/tx/impl/details/NFTokenUtils.h>
+#include <ripple/protocol/Indexes.h>
+
+using namespace ripple;
+using namespace ::RPC;
+
+namespace RPCng {
+
+NFTInfoHandler::Result
+NFTInfoHandler::process(
+    NFTInfoHandler::Input input,
+    boost::asio::yield_context& yield) const
+{
+    auto const tokenID = ripple::uint256{input.nftID.c_str()};
+    auto const range = sharedPtrBackend_->fetchLedgerRange();
+    auto const lgrInfoOrStatus = getLedgerInfoFromHashOrSeq(
+        *sharedPtrBackend_,
+        yield,
+        input.ledgerHash,
+        input.ledgerIndex,
+        range->maxSequence);
+    if (auto const status = std::get_if<Status>(&lgrInfoOrStatus))
+        return Error{*status};
+
+    auto const lgrInfo = std::get<LedgerInfo>(lgrInfoOrStatus);
+    auto const maybeNft =
+        sharedPtrBackend_->fetchNFT(tokenID, lgrInfo.seq, yield);
+    if (not maybeNft.has_value())
+        return Error{
+            Status{RippledError::rpcOBJECT_NOT_FOUND, "NFT not found"}};
+
+    auto const& nft = *maybeNft;
+    auto output = NFTInfoHandler::Output{};
+
+    output.nftID = strHex(nft.tokenID);
+    output.ledgerIndex = nft.ledgerSequence;
+    output.owner = toBase58(nft.owner);
+    output.isBurned = nft.isBurned;
+    output.flags = nft::getFlags(nft.tokenID);
+    output.transferFee = nft::getTransferFee(nft.tokenID);
+    output.issuer = toBase58(nft::getIssuer(nft.tokenID));
+    output.taxon = nft::toUInt32(nft::getTaxon(nft.tokenID));
+    output.serial = nft::getSerial(nft.tokenID);
+
+    if (not nft.isBurned)
+        output.uri = strHex(nft.uri);
+
+    return output;
+}
+
+void
+tag_invoke(
+    boost::json::value_from_tag,
+    boost::json::value& jv,
+    NFTInfoHandler::Output const& output)
+{
+    // TODO: use JStrings when they become available
+    auto object = boost::json::object{
+        {JS(nft_id), output.nftID},
+        {JS(ledger_index), output.ledgerIndex},
+        {JS(owner), output.owner},
+        {"is_burned", output.isBurned},
+        {JS(flags), output.flags},
+        {"transfer_fee", output.transferFee},
+        {JS(issuer), output.issuer},
+        {"nft_taxon", output.taxon},
+        {JS(nft_serial), output.serial},
+        {JS(validated), output.validated},
+    };
+
+    if (output.uri)
+        object[JS(uri)] = *(output.uri);
+
+    jv = std::move(object);
+}
+
+NFTInfoHandler::Input
+tag_invoke(
+    boost::json::value_to_tag<NFTInfoHandler::Input>,
+    boost::json::value const& jv)
+{
+    auto const& jsonObject = jv.as_object();
+    NFTInfoHandler::Input input;
+
+    input.nftID = jsonObject.at(JS(nft_id)).as_string().c_str();
+
+    if (jsonObject.contains(JS(ledger_hash)))
+    {
+        input.ledgerHash = jsonObject.at(JS(ledger_hash)).as_string().c_str();
+    }
+
+    if (jsonObject.contains(JS(ledger_index)))
+    {
+        if (!jsonObject.at(JS(ledger_index)).is_string())
+        {
+            input.ledgerIndex = jsonObject.at(JS(ledger_index)).as_int64();
+        }
+        else if (jsonObject.at(JS(ledger_index)).as_string() != "validated")
+        {
+            input.ledgerIndex =
+                std::stoi(jsonObject.at(JS(ledger_index)).as_string().c_str());
+        }
+    }
+
+    return input;
+}
+}  // namespace RPCng

src/rpc/ngHandlers/NFTInfo.h

@@ -0,0 +1,97 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2023, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL,  DIRECT,  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#pragma once
+
+#include <backend/BackendInterface.h>
+#include <rpc/RPCHelpers.h>
+#include <rpc/common/Types.h>
+#include <rpc/common/Validators.h>
+
+#include <boost/asio/spawn.hpp>
+
+namespace RPCng {
+class NFTInfoHandler
+{
+    std::shared_ptr<BackendInterface> sharedPtrBackend_;
+
+public:
+    struct Output
+    {
+        std::string nftID;
+        uint32_t ledgerIndex;
+        std::string owner;
+        bool isBurned;
+        uint32_t flags;
+        uint32_t transferFee;
+        std::string issuer;
+        uint32_t taxon;
+        uint32_t
+            serial;  // TODO: documented as 'nft_sequence' atm.
+                     // https://github.com/XRPLF/xrpl-dev-portal/issues/1841
+        std::optional<std::string>
+            uri;  // TODO: documented can be null vs. empty string
+                  // https://github.com/XRPLF/xrpl-dev-portal/issues/1841
+
+        // validated should be sent via framework
+        bool validated = true;
+    };
+
+    struct Input
+    {
+        std::string nftID;
+        std::optional<std::string> ledgerHash;
+        std::optional<uint32_t> ledgerIndex;
+    };
+
+    using Result = RPCng::HandlerReturnType<Output>;
+
+    NFTInfoHandler(std::shared_ptr<BackendInterface> const& sharedPtrBackend)
+        : sharedPtrBackend_(sharedPtrBackend)
+    {
+    }
+
+    RpcSpecConstRef
+    spec() const
+    {
+        static auto const rpcSpec = RpcSpec{
+            {JS(nft_id),
+             validation::Required{},
+             validation::Uint256HexStringValidator},
+            {JS(ledger_hash), validation::Uint256HexStringValidator},
+            {JS(ledger_index), validation::LedgerIndexValidator},
+        };
+        return rpcSpec;
+    }
+
+    Result
+    process(Input input, boost::asio::yield_context& yield) const;
+};
+
+void
+tag_invoke(
+    boost::json::value_from_tag,
+    boost::json::value& jv,
+    NFTInfoHandler::Output const& output);
+
+NFTInfoHandler::Input
+tag_invoke(
+    boost::json::value_to_tag<NFTInfoHandler::Input>,
+    boost::json::value const& jv);
+}  // namespace RPCng

unittests/rpc/handlers/NFTInfoTest.cpp

@@ -0,0 +1,454 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2023, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL,  DIRECT,  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#include <rpc/common/AnyHandler.h>
+#include <rpc/ngHandlers/NFTInfo.h>
+#include <util/Fixtures.h>
+#include <util/TestObject.h>
+
+#include <fmt/core.h>
+
+using namespace RPCng;
+namespace json = boost::json;
+using namespace testing;
+
+constexpr static auto ACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn";
+constexpr static auto LEDGERHASH =
+    "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652";
+constexpr static auto NFTID =
+    "00010000A7CAD27B688D14BA1A9FA5366554D6ADCF9CE0875B974D9F00000004";
+constexpr static auto NFTID2 =
+    "00081388319F12E15BCA13E1B933BF4C99C8E1BBC36BD4910A85D52F00000022";
+
+class RPCNFTInfoHandlerTest : public HandlerBaseTest
+{
+};
+
+TEST_F(RPCNFTInfoHandlerTest, NonHexLedgerHash)
+{
+    runSpawn([this](boost::asio::yield_context yield) {
+        auto const handler = AnyHandler{NFTInfoHandler{mockBackendPtr}};
+        auto const input = json::parse(fmt::format(
+            R"({{ 
+                "nft_id": "{}", 
+                "ledger_hash": "xxx"
+            }})",
+            NFTID));
+        auto const output = handler.process(input, yield);
+        ASSERT_FALSE(output);
+
+        auto const err = RPC::makeError(output.error());
+        EXPECT_EQ(err.at("error").as_string(), "invalidParams");
+        EXPECT_EQ(err.at("error_message").as_string(), "ledger_hashMalformed");
+    });
+}
+
+TEST_F(RPCNFTInfoHandlerTest, NonStringLedgerHash)
+{
+    runSpawn([this](boost::asio::yield_context yield) {
+        auto const handler = AnyHandler{NFTInfoHandler{mockBackendPtr}};
+        auto const input = json::parse(fmt::format(
+            R"({{
+                "nft_id": "{}", 
+                "ledger_hash": 123
+            }})",
+            NFTID));
+        auto const output = handler.process(input, yield);
+        ASSERT_FALSE(output);
+
+        auto const err = RPC::makeError(output.error());
+        EXPECT_EQ(err.at("error").as_string(), "invalidParams");
+        EXPECT_EQ(err.at("error_message").as_string(), "ledger_hashNotString");
+    });
+}
+
+TEST_F(RPCNFTInfoHandlerTest, InvalidLedgerIndexString)
+{
+    runSpawn([this](boost::asio::yield_context yield) {
+        auto const handler = AnyHandler{NFTInfoHandler{mockBackendPtr}};
+        auto const input = json::parse(fmt::format(
+            R"({{ 
+                "nft_id": "{}", 
+                "ledger_index": "notvalidated"
+            }})",
+            NFTID));
+        auto const output = handler.process(input, yield);
+        ASSERT_FALSE(output);
+
+        auto const err = RPC::makeError(output.error());
+        EXPECT_EQ(err.at("error").as_string(), "invalidParams");
+        EXPECT_EQ(err.at("error_message").as_string(), "ledgerIndexMalformed");
+    });
+}
+
+// error case: nft_id invalid format, length is incorrect
+TEST_F(RPCNFTInfoHandlerTest, NFTIDInvalidFormat)
+{
+    runSpawn([this](boost::asio::yield_context yield) {
+        auto const handler = AnyHandler{NFTInfoHandler{mockBackendPtr}};
+        auto const input = json::parse(R"({ 
+            "nft_id": "00080000B4F4AFC5FBCBD76873F18006173D2193467D3EE7"
+        })");
+        auto const output = handler.process(input, yield);
+        ASSERT_FALSE(output);
+        auto const err = RPC::makeError(output.error());
+        EXPECT_EQ(err.at("error").as_string(), "invalidParams");
+        EXPECT_EQ(err.at("error_message").as_string(), "nft_idMalformed");
+    });
+}
+
+// error case: nft_id invalid format
+TEST_F(RPCNFTInfoHandlerTest, NFTIDNotString)
+{
+    runSpawn([this](boost::asio::yield_context yield) {
+        auto const handler = AnyHandler{NFTInfoHandler{mockBackendPtr}};
+        auto const input = json::parse(R"({ 
+            "nft_id": 12
+        })");
+        auto const output = handler.process(input, yield);
+        ASSERT_FALSE(output);
+
+        auto const err = RPC::makeError(output.error());
+        EXPECT_EQ(err.at("error").as_string(), "invalidParams");
+        EXPECT_EQ(err.at("error_message").as_string(), "nft_idNotString");
+    });
+}
+
+// error case ledger non exist via hash
+TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerHash)
+{
+    MockBackend* rawBackendPtr =
+        static_cast<MockBackend*>(mockBackendPtr.get());
+    // mock fetchLedgerByHash return empty
+    ON_CALL(*rawBackendPtr, fetchLedgerByHash(ripple::uint256{LEDGERHASH}, _))
+        .WillByDefault(Return(std::optional<ripple::LedgerInfo>{}));
+    EXPECT_CALL(*rawBackendPtr, fetchLedgerByHash).Times(1);
+
+    auto const input = json::parse(fmt::format(
+        R"({{
+            "nft_id": "{}",
+            "ledger_hash": "{}"
+        }})",
+        NFTID,
+        LEDGERHASH));
+    runSpawn([&, this](boost::asio::yield_context yield) {
+        auto const handler = AnyHandler{NFTInfoHandler{mockBackendPtr}};
+        auto const output = handler.process(input, yield);
+        ASSERT_FALSE(output);
+
+        auto const err = RPC::makeError(output.error());
+        EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
+        EXPECT_EQ(err.at("error_message").as_string(), "ledgerNotFound");
+    });
+}
+
+// error case ledger non exist via index
+TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerIndex)
+{
+    MockBackend* rawBackendPtr =
+        static_cast<MockBackend*>(mockBackendPtr.get());
+    mockBackendPtr->updateRange(10);  // min
+    mockBackendPtr->updateRange(30);  // max
+    // mock fetchLedgerBySequence return empty
+    ON_CALL(*rawBackendPtr, fetchLedgerBySequence)
+        .WillByDefault(Return(std::optional<ripple::LedgerInfo>{}));
+    EXPECT_CALL(*rawBackendPtr, fetchLedgerBySequence).Times(1);
+    auto const input = json::parse(fmt::format(
+        R"({{ 
+            "nft_id": "{}",
+            "ledger_index": "4"
+        }})",
+        NFTID));
+    runSpawn([&, this](boost::asio::yield_context yield) {
+        auto const handler = AnyHandler{NFTInfoHandler{mockBackendPtr}};
+        auto const output = handler.process(input, yield);
+        ASSERT_FALSE(output);
+        auto const err = RPC::makeError(output.error());
+        EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
+        EXPECT_EQ(err.at("error_message").as_string(), "ledgerNotFound");
+    });
+}
+
+// error case ledger > max seq via hash
+// idk why this case will happen in reality
+TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerHash2)
+{
+    MockBackend* rawBackendPtr =
+        static_cast<MockBackend*>(mockBackendPtr.get());
+    mockBackendPtr->updateRange(10);  // min
+    mockBackendPtr->updateRange(30);  // max
+    // mock fetchLedgerByHash return ledger but seq is 31 > 30
+    auto ledgerinfo = CreateLedgerInfo(LEDGERHASH, 31);
+    ON_CALL(*rawBackendPtr, fetchLedgerByHash(ripple::uint256{LEDGERHASH}, _))
+        .WillByDefault(Return(ledgerinfo));
+    EXPECT_CALL(*rawBackendPtr, fetchLedgerByHash).Times(1);
+    auto const input = json::parse(fmt::format(
+        R"({{ 
+            "nft_id": "{}",
+            "ledger_hash": "{}"
+        }})",
+        NFTID,
+        LEDGERHASH));
+    runSpawn([&, this](boost::asio::yield_context yield) {
+        auto const handler = AnyHandler{NFTInfoHandler{mockBackendPtr}};
+        auto const output = handler.process(input, yield);
+        ASSERT_FALSE(output);
+        auto const err = RPC::makeError(output.error());
+        EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
+        EXPECT_EQ(err.at("error_message").as_string(), "ledgerNotFound");
+    });
+}
+
+// error case ledger > max seq via index
+TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerIndex2)
+{
+    MockBackend* rawBackendPtr =
+        static_cast<MockBackend*>(mockBackendPtr.get());
+    mockBackendPtr->updateRange(10);  // min
+    mockBackendPtr->updateRange(30);  // max
+    // no need to check from db,call fetchLedgerBySequence 0 time
+    // differ from previous logic
+    EXPECT_CALL(*rawBackendPtr, fetchLedgerBySequence).Times(0);
+    auto const input = json::parse(fmt::format(
+        R"({{ 
+            "nft_id": "{}",
+            "ledger_index": "31"
+        }})",
+        NFTID));
+    runSpawn([&, this](boost::asio::yield_context yield) {
+        auto const handler = AnyHandler{NFTInfoHandler{mockBackendPtr}};
+        auto const output = handler.process(input, yield);
+        ASSERT_FALSE(output);
+        auto const err = RPC::makeError(output.error());
+        EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
+        EXPECT_EQ(err.at("error_message").as_string(), "ledgerNotFound");
+    });
+}
+
+// error case nft does not exist
+TEST_F(RPCNFTInfoHandlerTest, NonExistNFT)
+{
+    MockBackend* rawBackendPtr =
+        static_cast<MockBackend*>(mockBackendPtr.get());
+    mockBackendPtr->updateRange(10);  // min
+    mockBackendPtr->updateRange(30);  // max
+    auto ledgerinfo = CreateLedgerInfo(LEDGERHASH, 30);
+    ON_CALL(*rawBackendPtr, fetchLedgerByHash(ripple::uint256{LEDGERHASH}, _))
+        .WillByDefault(Return(ledgerinfo));
+    EXPECT_CALL(*rawBackendPtr, fetchLedgerByHash).Times(1);
+    // fetch nft return emtpy
+    ON_CALL(*rawBackendPtr, fetchNFT)
+        .WillByDefault(Return(std::optional<NFT>{}));
+    EXPECT_CALL(*rawBackendPtr, fetchNFT(ripple::uint256{NFTID}, 30, _))
+        .Times(1);
+    auto const input = json::parse(fmt::format(
+        R"({{
+            "nft_id": "{}",
+            "ledger_hash": "{}"
+        }})",
+        NFTID,
+        LEDGERHASH));
+    runSpawn([&, this](boost::asio::yield_context yield) {
+        auto const handler = AnyHandler{NFTInfoHandler{mockBackendPtr}};
+        auto const output = handler.process(input, yield);
+        ASSERT_FALSE(output);
+        auto const err = RPC::makeError(output.error());
+        EXPECT_EQ(err.at("error").as_string(), "objectNotFound");
+        EXPECT_EQ(err.at("error_message").as_string(), "NFT not found");
+    });
+}
+
+// normal case when only provide nft_id
+TEST_F(RPCNFTInfoHandlerTest, DefaultParameters)
+{
+    constexpr static auto correntOutput = R"({
+        "nft_id": "00010000A7CAD27B688D14BA1A9FA5366554D6ADCF9CE0875B974D9F00000004",
+        "ledger_index": 30,
+        "owner": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
+        "is_burned": false,
+        "flags": 1,
+        "transfer_fee": 0,
+        "issuer": "rGJUF4PvVkMNxG6Bg6AKg3avhrtQyAffcm",
+        "nft_taxon": 0,
+        "nft_serial": 4,
+        "uri": "757269",
+        "validated": true
+    })";
+    MockBackend* rawBackendPtr =
+        static_cast<MockBackend*>(mockBackendPtr.get());
+    mockBackendPtr->updateRange(10);  // min
+    mockBackendPtr->updateRange(30);  // max
+    auto ledgerInfo = CreateLedgerInfo(LEDGERHASH, 30);
+    ON_CALL(*rawBackendPtr, fetchLedgerBySequence)
+        .WillByDefault(Return(ledgerInfo));
+    EXPECT_CALL(*rawBackendPtr, fetchLedgerBySequence).Times(1);
+
+    // fetch nft return something
+    auto const nft =
+        std::make_optional<NFT>(CreateNFT(NFTID, ACCOUNT, ledgerInfo.seq));
+    ON_CALL(*rawBackendPtr, fetchNFT).WillByDefault(Return(nft));
+    EXPECT_CALL(*rawBackendPtr, fetchNFT(ripple::uint256{NFTID}, 30, _))
+        .Times(1);
+
+    auto const input = json::parse(fmt::format(
+        R"({{
+            "nft_id": "{}"
+        }})",
+        NFTID));
+    runSpawn([&, this](auto& yield) {
+        auto handler = AnyHandler{NFTInfoHandler{this->mockBackendPtr}};
+        auto const output = handler.process(input, yield);
+        ASSERT_TRUE(output);
+        EXPECT_EQ(json::parse(correntOutput), *output);
+    });
+}
+
+// nft is burned -> should omit uri
+TEST_F(RPCNFTInfoHandlerTest, BurnedNFT)
+{
+    constexpr static auto correntOutput = R"({
+        "nft_id": "00010000A7CAD27B688D14BA1A9FA5366554D6ADCF9CE0875B974D9F00000004",
+        "ledger_index": 30,
+        "owner": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
+        "is_burned": true,
+        "flags": 1,
+        "transfer_fee": 0,
+        "issuer": "rGJUF4PvVkMNxG6Bg6AKg3avhrtQyAffcm",
+        "nft_taxon": 0,
+        "nft_serial": 4,
+        "validated": true
+    })";
+    MockBackend* rawBackendPtr =
+        static_cast<MockBackend*>(mockBackendPtr.get());
+    mockBackendPtr->updateRange(10);  // min
+    mockBackendPtr->updateRange(30);  // max
+    auto ledgerInfo = CreateLedgerInfo(LEDGERHASH, 30);
+    ON_CALL(*rawBackendPtr, fetchLedgerBySequence)
+        .WillByDefault(Return(ledgerInfo));
+    EXPECT_CALL(*rawBackendPtr, fetchLedgerBySequence).Times(1);
+
+    // fetch nft return something
+    auto const nft = std::make_optional<NFT>(CreateNFT(
+        NFTID, ACCOUNT, ledgerInfo.seq, ripple::Blob{'u', 'r', 'i'}, true));
+    ON_CALL(*rawBackendPtr, fetchNFT).WillByDefault(Return(nft));
+    EXPECT_CALL(*rawBackendPtr, fetchNFT(ripple::uint256{NFTID}, 30, _))
+        .Times(1);
+
+    auto const input = json::parse(fmt::format(
+        R"({{
+            "nft_id": "{}"
+        }})",
+        NFTID));
+    runSpawn([&, this](auto& yield) {
+        auto handler = AnyHandler{NFTInfoHandler{this->mockBackendPtr}};
+        auto const output = handler.process(input, yield);
+        ASSERT_TRUE(output);
+        EXPECT_EQ(json::parse(correntOutput), *output);
+    });
+}
+
+// nft is not burned and uri is not available -> should specify null
+TEST_F(RPCNFTInfoHandlerTest, NotBurnedNFTWithoutURI)
+{
+    constexpr static auto correntOutput = R"({
+        "nft_id": "00010000A7CAD27B688D14BA1A9FA5366554D6ADCF9CE0875B974D9F00000004",
+        "ledger_index": 30,
+        "owner": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
+        "is_burned": false,
+        "flags": 1,
+        "transfer_fee": 0,
+        "issuer": "rGJUF4PvVkMNxG6Bg6AKg3avhrtQyAffcm",
+        "nft_taxon": 0,
+        "nft_serial": 4,
+        "uri": "",
+        "validated": true
+    })";
+    MockBackend* rawBackendPtr =
+        static_cast<MockBackend*>(mockBackendPtr.get());
+    mockBackendPtr->updateRange(10);  // min
+    mockBackendPtr->updateRange(30);  // max
+    auto ledgerInfo = CreateLedgerInfo(LEDGERHASH, 30);
+    ON_CALL(*rawBackendPtr, fetchLedgerBySequence)
+        .WillByDefault(Return(ledgerInfo));
+    EXPECT_CALL(*rawBackendPtr, fetchLedgerBySequence).Times(1);
+
+    // fetch nft return something
+    auto const nft = std::make_optional<NFT>(
+        CreateNFT(NFTID, ACCOUNT, ledgerInfo.seq, ripple::Blob{}));
+    ON_CALL(*rawBackendPtr, fetchNFT).WillByDefault(Return(nft));
+    EXPECT_CALL(*rawBackendPtr, fetchNFT(ripple::uint256{NFTID}, 30, _))
+        .Times(1);
+
+    auto const input = json::parse(fmt::format(
+        R"({{
+            "nft_id": "{}"
+        }})",
+        NFTID));
+    runSpawn([&, this](auto& yield) {
+        auto handler = AnyHandler{NFTInfoHandler{this->mockBackendPtr}};
+        auto const output = handler.process(input, yield);
+        ASSERT_TRUE(output);
+        EXPECT_EQ(json::parse(correntOutput), *output);
+    });
+}
+
+// check taxon field, transfer fee and serial
+TEST_F(RPCNFTInfoHandlerTest, NFTWithExtraFieldsSet)
+{
+    constexpr static auto correntOutput = R"({
+        "nft_id": "00081388319F12E15BCA13E1B933BF4C99C8E1BBC36BD4910A85D52F00000022",
+        "ledger_index": 30,
+        "owner": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
+        "is_burned": false,
+        "flags": 8,
+        "transfer_fee": 5000,
+        "issuer": "rnX4gsB86NNrGV8xHcJ5hbR2aKtSetbuwg",
+        "nft_taxon": 7826,
+        "nft_serial": 34,
+        "uri": "757269",
+        "validated": true
+    })";
+    MockBackend* rawBackendPtr =
+        static_cast<MockBackend*>(mockBackendPtr.get());
+    mockBackendPtr->updateRange(10);  // min
+    mockBackendPtr->updateRange(30);  // max
+    auto ledgerInfo = CreateLedgerInfo(LEDGERHASH, 30);
+    ON_CALL(*rawBackendPtr, fetchLedgerBySequence)
+        .WillByDefault(Return(ledgerInfo));
+    EXPECT_CALL(*rawBackendPtr, fetchLedgerBySequence).Times(1);
+
+    // fetch nft return something
+    auto const nft =
+        std::make_optional<NFT>(CreateNFT(NFTID2, ACCOUNT, ledgerInfo.seq));
+    ON_CALL(*rawBackendPtr, fetchNFT).WillByDefault(Return(nft));
+    EXPECT_CALL(*rawBackendPtr, fetchNFT(ripple::uint256{NFTID2}, 30, _))
+        .Times(1);
+
+    auto const input = json::parse(fmt::format(
+        R"({{
+            "nft_id": "{}"
+        }})",
+        NFTID2));
+    runSpawn([&, this](auto& yield) {
+        auto handler = AnyHandler{NFTInfoHandler{this->mockBackendPtr}};
+        auto const output = handler.process(input, yield);
+        ASSERT_TRUE(output);
+        EXPECT_EQ(json::parse(correntOutput), *output);
+    });
+}

unittests/util/TestObject.cpp

@@ -420,3 +420,19 @@ CreateDepositPreauthLedgerObject(
     depositPreauth.setFieldU32(ripple::sfPreviousTxnLgrSeq, 0);
     return depositPreauth;
 }
+
+Backend::NFT
+CreateNFT(
+    std::string_view tokenID,
+    std::string_view account,
+    ripple::LedgerIndex seq,
+    ripple::Blob uri,
+    bool isBurned)
+{
+    return Backend::NFT{
+        ripple::uint256(tokenID),
+        seq,
+        GetAccountIDWithString(account),
+        uri,
+        isBurned};
+}

unittests/util/TestObject.h

@@ -19,6 +19,8 @@
 
 #pragma once
 
+#include <backend/Types.h>
+
 #include <ripple/ledger/ReadView.h>
 
 #include <string_view>
@@ -196,3 +198,11 @@ ripple::STObject
 CreateDepositPreauthLedgerObject(
     std::string_view account,
     std::string_view auth);
+
+[[nodiscard]] Backend::NFT
+CreateNFT(
+    std::string_view tokenID,
+    std::string_view account,
+    ripple::LedgerIndex seq = 1234u,
+    ripple::Blob uri = ripple::Blob{'u', 'r', 'i'},
+    bool isBurned = false);