XLS-46: DynamicNFT

include/xrpl/protocol/Feature.h

@@ -80,7 +80,7 @@ namespace detail {
 // Feature.cpp. Because it's only used to reserve storage, and determine how
 // large to make the FeatureBitset, it MAY be larger. It MUST NOT be less than
 // the actual number of amendments. A LogicError on startup will verify this.
-static constexpr std::size_t numFeatures = 76;
+static constexpr std::size_t numFeatures = 77;
 
 /** Amendments that this server supports and the default voting behavior.
    Whether they are enabled depends on the Rules defined in the validated
@@ -369,6 +369,7 @@ extern uint256 const fixAMMv1_1;
 extern uint256 const featureNFTokenMintOffer;
 extern uint256 const fixReducedOffersV2;
 extern uint256 const fixEnforceNFTokenTrustline;
+extern uint256 const featureDynamicNFT;
 
 }  // namespace ripple
 

include/xrpl/protocol/TxFlags.h

@@ -129,6 +129,7 @@ constexpr std::uint32_t const tfBurnable                   = 0x00000001;
 constexpr std::uint32_t const tfOnlyXRP                    = 0x00000002;
 constexpr std::uint32_t const tfTrustLine                  = 0x00000004;
 constexpr std::uint32_t const tfTransferable               = 0x00000008;
+constexpr std::uint32_t const tfMutable                    = 0x00000010;
 
 // Prior to fixRemoveNFTokenAutoTrustLine, transfer of an NFToken between
 // accounts allowed a TrustLine to be added to the issuer of that token
@@ -149,6 +150,12 @@ constexpr std::uint32_t const tfNFTokenMintOldMask =
 constexpr std::uint32_t const tfNFTokenMintMask =
     ~(tfUniversal | tfBurnable | tfOnlyXRP | tfTransferable);
 
+// if featureDynamicNFT enabled then new flag allowing mutable URI available.
+constexpr std::uint32_t const tfNFTokenMintOldMaskWithMutable =
+    ~(tfUniversal | tfBurnable | tfOnlyXRP | tfTrustLine | tfTransferable | tfMutable);
+constexpr std::uint32_t const tfNFTokenMintMaskWithMutable =
+    ~(tfUniversal | tfBurnable | tfOnlyXRP | tfTransferable | tfMutable);
+
 // NFTokenCreateOffer flags:
 constexpr std::uint32_t const tfSellNFToken                = 0x00000001;
 constexpr std::uint32_t const tfNFTokenCreateOfferMask =

include/xrpl/protocol/TxFormats.h

@@ -190,13 +190,15 @@ enum TxType : std::uint16_t
     /** This transaction type deletes a DID */
     ttDID_DELETE = 50,
 
-
     /** This transaction type creates an Oracle instance */
     ttORACLE_SET = 51,
 
     /** This transaction type deletes an Oracle instance */
     ttORACLE_DELETE = 52,
 
+    /** This transaction type modify a NFToken */
+    ttNFTOKEN_MODIFY = 53,
+
     /** This system-generated transaction type is used to update the status of the various amendments.
 
         For details, see: https://xrpl.org/amendments.html

include/xrpl/protocol/jss.h

@@ -104,6 +104,7 @@ JSS(NFTokenOffer);         // ledger type.
 JSS(NFTokenAcceptOffer);   // transaction type.
 JSS(NFTokenCancelOffer);   // transaction type.
 JSS(NFTokenCreateOffer);   // transaction type.
+JSS(NFTokenModify);        // transaction type.
 JSS(NFTokenPage);          // ledger type.
 JSS(LPTokenOut);           // in: AMM Liquidity Provider deposit tokens
 JSS(LPTokenIn);            // in: AMM Liquidity Provider withdraw tokens

include/xrpl/protocol/nft.h

@@ -54,6 +54,7 @@ constexpr std::uint16_t const flagBurnable = 0x0001;
 constexpr std::uint16_t const flagOnlyXRP = 0x0002;
 constexpr std::uint16_t const flagCreateTrustLines = 0x0004;
 constexpr std::uint16_t const flagTransferable = 0x0008;
+constexpr std::uint16_t const flagMutable = 0x0010;
 
 inline std::uint16_t
 getFlags(uint256 const& id)

src/libxrpl/protocol/Feature.cpp

@@ -496,6 +496,7 @@ REGISTER_FIX    (fixAMMv1_1,                    Supported::yes, VoteBehavior::De
 REGISTER_FEATURE(NFTokenMintOffer,              Supported::yes, VoteBehavior::DefaultNo);
 REGISTER_FIX    (fixReducedOffersV2,            Supported::yes, VoteBehavior::DefaultNo);
 REGISTER_FIX    (fixEnforceNFTokenTrustline,    Supported::yes, VoteBehavior::DefaultNo);
+REGISTER_FEATURE(DynamicNFT,                    Supported::yes, VoteBehavior::DefaultNo);
 
 // The following amendments are obsolete, but must remain supported
 // because they could potentially get enabled.

src/libxrpl/protocol/TxFormats.cpp

@@ -374,6 +374,15 @@ TxFormats::TxFormats()
         },
         commonFields);
 
+    add(jss::NFTokenModify,
+        ttNFTOKEN_MODIFY,
+        {
+            {sfNFTokenID, soeREQUIRED},
+            {sfOwner, soeOPTIONAL},
+            {sfURI, soeOPTIONAL},
+        },
+        commonFields);
+
     add(jss::Clawback,
         ttCLAWBACK,
         {

src/test/app/NFToken_test.cpp

@@ -7744,6 +7744,205 @@ class NFTokenBaseUtil_test : public beast::unit_test::suite
         }
     }
 
+    void
+    testNFTokenModify(FeatureBitset features)
+    {
+        testcase("Test modify");
+
+        using namespace test::jtx;
+
+        Account const minter{"minter"};
+        Account const alice("alice");
+        Account const bob("bob");
+
+        bool modifyEnabled = features[featureDynamicNFT];
+
+        {
+            // Mint with tfMutable
+            Env env{*this, features};
+            env.fund(XRP(10000), minter);
+            env.close();
+
+            auto const expectedTer =
+                modifyEnabled ? TER{tesSUCCESS} : TER{temINVALID_FLAG};
+            env(token::mint(minter, 0u), txflags(tfMutable), ter(expectedTer));
+            env.close();
+        }
+        {
+            Env env{*this, features};
+            env.fund(XRP(10000), minter);
+            env.close();
+
+            // Modify a nftoken
+            uint256 const nftId{token::getNextID(env, minter, 0u, tfMutable)};
+            if (modifyEnabled)
+            {
+                env(token::mint(minter, 0u), txflags(tfMutable));
+                env.close();
+                BEAST_EXPECT(ownerCount(env, minter) == 1);
+                env(token::modify(minter, nftId));
+                BEAST_EXPECT(ownerCount(env, minter) == 1);
+            }
+            else
+            {
+                env(token::mint(minter, 0u));
+                env.close();
+                env(token::modify(minter, nftId), ter(temDISABLED));
+                env.close();
+            }
+        }
+        if (!modifyEnabled)
+            return;
+
+        {
+            Env env{*this, features};
+            env.fund(XRP(10000), minter);
+            env.close();
+
+            uint256 const nftId{token::getNextID(env, minter, 0u, tfMutable)};
+            env(token::mint(minter, 0u), txflags(tfMutable));
+            env.close();
+
+            // Invalid Owner
+            env(token::modify(minter, nftId),
+                token::owner(minter),
+                ter(temMALFORMED));
+            env.close();
+
+            // Invalid URI length = 0
+            env(token::modify(minter, nftId),
+                token::uri(""),
+                ter(temMALFORMED));
+            env.close();
+
+            // Invalid URI length > 256
+            env(token::modify(minter, nftId),
+                token::uri(std::string(maxTokenURILength + 1, 'q')),
+                ter(temMALFORMED));
+            env.close();
+        }
+        {
+            Env env{*this, features};
+            env.fund(XRP(10000), minter, alice);
+            env.close();
+
+            uint256 const nftId_not_exists{
+                token::getNextID(env, minter, 0u, tfMutable)};
+            env.close();
+
+            // NFToken not exists
+            env(token::modify(minter, nftId_not_exists), ter(tecNO_ENTRY));
+            env.close();
+
+            uint256 const nftId_not_modifiable{
+                token::getNextID(env, minter, 0u)};
+            env(token::mint(minter, 0u));
+            env.close();
+
+            // Invalid NFToken flag
+            env(token::modify(minter, nftId_not_modifiable),
+                ter(tecNO_PERMISSION));
+            env.close();
+
+            // Invalid NFTokenMinter
+            env(token::modify(alice, nftId_not_modifiable),
+                token::owner(minter),
+                ter(tecNO_PERMISSION));
+            env.close();
+        }
+        {
+            Env env{*this, features};
+            env.fund(XRP(10000), minter, alice, bob);
+            env.close();
+
+            auto accountNFTs = [&](Env& env, Account const& acct) {
+                Json::Value params;
+                params[jss::account] = acct.human();
+                params[jss::type] = "state";
+                auto response =
+                    env.rpc("json", "account_nfts", to_string(params));
+                return response[jss::result][jss::account_nfts];
+            };
+
+            uint256 const nftId{token::getNextID(env, minter, 0u, tfMutable)};
+            env.close();
+
+            env(token::mint(minter, 0u), txflags(tfMutable), token::uri("uri"));
+            env.close();
+            {
+                auto nfts = accountNFTs(env, minter);
+                BEAST_EXPECT(nfts.size() == 1);
+                BEAST_EXPECT(
+                    nfts[0u][sfURI.jsonName] == strHex(std::string("uri")));
+            }
+
+            // set URI Field
+            env(token::modify(minter, nftId), token::uri("new_uri"));
+            env.close();
+            {
+                auto nfts = accountNFTs(env, minter);
+                BEAST_EXPECT(nfts.size() == 1);
+                BEAST_EXPECT(
+                    nfts[0u][sfURI.jsonName] == strHex(std::string("new_uri")));
+            }
+            // unset URI Field
+            env(token::modify(minter, nftId));
+            env.close();
+            {
+                auto nfts = accountNFTs(env, minter);
+                BEAST_EXPECT(nfts.size() == 1);
+                BEAST_EXPECT(!nfts[0u].isMember(sfURI.jsonName));
+            }
+            // set URI Field
+            env(token::modify(minter, nftId), token::uri("uri"));
+            env.close();
+            {
+                auto nfts = accountNFTs(env, minter);
+                BEAST_EXPECT(nfts.size() == 1);
+                BEAST_EXPECT(
+                    nfts[0u][sfURI.jsonName] == strHex(std::string("uri")));
+            }
+
+            // Account != Owner
+            uint256 const offerID =
+                keylet::nftoffer(minter, env.seq(minter)).key;
+            env(token::createOffer(minter, nftId, XRP(0)),
+                txflags(tfSellNFToken));
+            env.close();
+            env(token::acceptSellOffer(alice, offerID));
+            env.close();
+
+            BEAST_EXPECT(ownerCount(env, minter) == 0);
+            BEAST_EXPECT(ownerCount(env, alice) == 1);
+            env(token::modify(minter, nftId),
+                token::owner(alice),
+                token::uri("new_uri"));
+            env.close();
+            BEAST_EXPECT(ownerCount(env, minter) == 0);
+            BEAST_EXPECT(ownerCount(env, alice) == 1);
+
+            env(token::modify(minter, nftId), token::owner(alice));
+            env.close();
+
+            env(token::modify(minter, nftId),
+                token::owner(alice),
+                token::uri("uri"));
+            env.close();
+
+            // Modify by Issuer
+            env(token::setMinter(minter, bob));
+            env.close();
+            env(token::modify(bob, nftId),
+                token::owner(alice),
+                token::uri("new_uri"));
+            env(token::modify(bob, nftId), token::owner(alice));
+            env(token::modify(bob, nftId),
+                token::owner(alice),
+                token::uri("uri"));
+            env.close();
+        }
+    }
+
     void
     testWithFeats(FeatureBitset features)
     {
@@ -7781,6 +7980,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::suite
         testFixNFTokenBuyerReserve(features);
         testUnaskedForAutoTrustline(features);
         testNFTIssuerIsIOUIssuer(features);
+        testNFTokenModify(features);
     }
 
 public:
@@ -7791,17 +7991,20 @@ class NFTokenBaseUtil_test : public beast::unit_test::suite
         static FeatureBitset const all{supported_amendments()};
         static FeatureBitset const fixNFTDir{fixNFTokenDirV1};
 
-        static std::array<FeatureBitset, 7> const feats{
+        static std::array<FeatureBitset, 8> const feats{
             all - fixNFTDir - fixNonFungibleTokensV1_2 - fixNFTokenRemint -
-                fixNFTokenReserve - featureNFTokenMintOffer,
+                fixNFTokenReserve - featureNFTokenMintOffer - featureDynamicNFT,
             all - disallowIncoming - fixNonFungibleTokensV1_2 -
-                fixNFTokenRemint - fixNFTokenReserve - featureNFTokenMintOffer,
+                fixNFTokenRemint - fixNFTokenReserve - featureNFTokenMintOffer -
+                featureDynamicNFT,
             all - fixNonFungibleTokensV1_2 - fixNFTokenRemint -
-                fixNFTokenReserve - featureNFTokenMintOffer,
+                fixNFTokenReserve - featureNFTokenMintOffer - featureDynamicNFT,
             all - fixNFTokenRemint - fixNFTokenReserve -
-                featureNFTokenMintOffer,
-            all - fixNFTokenReserve - featureNFTokenMintOffer,
-            all - featureNFTokenMintOffer,
+                featureNFTokenMintOffer - featureDynamicNFT,
+            all - fixNFTokenReserve - featureNFTokenMintOffer -
+                featureDynamicNFT,
+            all - featureNFTokenMintOffer - featureDynamicNFT,
+            all - featureDynamicNFT,
             all};
 
         if (BEAST_EXPECT(instance < feats.size()))
@@ -7863,12 +8066,21 @@ class NFTokenWOMintOffer_test : public NFTokenBaseUtil_test
     }
 };
 
+class NFTokenWOModify_test : public NFTokenBaseUtil_test
+{
+    void
+    run() override
+    {
+        NFTokenBaseUtil_test::run(6);
+    }
+};
+
 class NFTokenAllFeatures_test : public NFTokenBaseUtil_test
 {
     void
     run() override
     {
-        NFTokenBaseUtil_test::run(6, true);
+        NFTokenBaseUtil_test::run(7, true);
     }
 };
 
@@ -7877,6 +8089,7 @@ BEAST_DEFINE_TESTSUITE_PRIO(NFTokenDisallowIncoming, tx, ripple, 2);
 BEAST_DEFINE_TESTSUITE_PRIO(NFTokenWOfixV1, tx, ripple, 2);
 BEAST_DEFINE_TESTSUITE_PRIO(NFTokenWOTokenRemint, tx, ripple, 2);
 BEAST_DEFINE_TESTSUITE_PRIO(NFTokenWOTokenReserve, tx, ripple, 2);
+BEAST_DEFINE_TESTSUITE_PRIO(NFTokenWOModify, tx, ripple, 2);
 BEAST_DEFINE_TESTSUITE_PRIO(NFTokenWOMintOffer, tx, ripple, 2);
 BEAST_DEFINE_TESTSUITE_PRIO(NFTokenAllFeatures, tx, ripple, 2);
 

src/test/jtx/impl/token.cpp

@@ -232,6 +232,16 @@ clearMinter(jtx::Account const& account)
     return fclear(account, asfAuthorizedNFTokenMinter);
 }
 
+Json::Value
+modify(jtx::Account const& account, uint256 const& nftokenID)
+{
+    Json::Value jv;
+    jv[sfAccount.jsonName] = account.human();
+    jv[sfNFTokenID.jsonName] = to_string(nftokenID);
+    jv[jss::TransactionType] = jss::NFTokenModify;
+    return jv;
+}
+
 }  // namespace token
 }  // namespace jtx
 }  // namespace test

src/test/jtx/token.h

@@ -237,6 +237,10 @@ setMinter(jtx::Account const& account, jtx::Account const& minter);
 Json::Value
 clearMinter(jtx::Account const& account);
 
+/** Modify an NFToken. */
+Json::Value
+modify(jtx::Account const& account, uint256 const& nftokenID);
+
 }  // namespace token
 
 }  // namespace jtx