[stdlib] Support update NFTTypeInfo metadata. (starcoinorg#2952)

* [stdlib] Support update NFTTypeInfo metadata.

* [test] Use NFT v2 function in functional test.

* [stdlib & genesis] Generate stdlib and genesis.

Author: jolestar

genesis/generated/halley/genesis

@@ -20,7 +20,7 @@ module creator::XMembership {
     use 0x1::Signer;
     use 0x1::Option;
 
-    struct XMembershipInfo has copy, store, drop{
+    struct XMembershipInfo has copy, store, drop, key{
         price_per_millis: u128,
     }
 
@@ -47,7 +47,9 @@ module creator::XMembership {
 
     public fun init(sender: &signer){
         assert(Signer::address_of(sender) == @creator, 1000);
-        NFT::register<XMembership,XMembershipInfo>(sender, XMembershipInfo{ price_per_millis:2 }, NFT::empty_meta());
+
+        NFT::register_v2<XMembership>(sender, NFT::empty_meta());
+        move_to(sender, XMembershipInfo{ price_per_millis:2 });
         let cap = NFT::remove_mint_capability<XMembership>(sender);
         move_to(sender, XMembershipMintCapability{ cap});
 
@@ -58,14 +60,14 @@ module creator::XMembership {
         move_to(sender, XMembershipUpdateCapability{ cap});
     }
 
-    public fun join(sender: &signer, fee: u128) acquires XMembershipMintCapability{
+    public fun join(sender: &signer, fee: u128) acquires XMembershipMintCapability, XMembershipInfo{
         let token = Account::withdraw<STC>(sender, fee);
         let cap = borrow_global_mut<XMembershipMintCapability>(@creator);
         let metadata = NFT::new_meta_with_image(b"xmembership", b"ipfs:://xxxxxx", b"This is a XMembership nft.");
-        let info = NFT::nft_type_info_ex_info<XMembership,XMembershipInfo>();
+        let info = borrow_global<XMembershipInfo>(@creator);
         let join_time = Timestamp::now_milliseconds();
         let end_time = join_time + ((Token::value(&token)/info.price_per_millis) as u64);
-        let nft = NFT::mint_with_cap<XMembership,XMembershipBody,XMembershipInfo>(@creator, &mut cap.cap, metadata, XMembership{ join_time, end_time}, XMembershipBody{ fee: token});
+        let nft = NFT::mint_with_cap_v2<XMembership,XMembershipBody>(@creator, &mut cap.cap, metadata, XMembership{ join_time, end_time}, XMembershipBody{ fee: token});
         IdentifierNFT::grant(&mut cap.cap, sender, nft);
     }
 

vm/functional-tests/tests/testsuite/nft/identifier_nft.move

@@ -8,12 +8,13 @@ module creator::BoxMiner {
     use 0x1::Account;
     use 0x1::NFTGallery;
     use 0x1::STC::STC;
+    use 0x1::Signer;
 
     struct BoxMiner has copy, store, drop{
         price: u128,
     }
 
-    struct NFTInfo has copy, store, drop{
+    struct NFTInfo has copy, store, drop, key{
         total_supply: u64,
         price: u128,
     }
@@ -24,8 +25,10 @@ module creator::BoxMiner {
     }
 
     public fun init(sender: &signer, total_supply:u64, price: u128){
+        assert(Signer::address_of(sender) == @creator, 1000);
         let meta = NFT::new_meta_with_image(b"stc_box_miner_nft", b"ipfs:://xxx", b"This is the starcoin boxminer nft");
-        NFT::register<BoxMiner, NFTInfo>(sender, NFTInfo{total_supply, price}, meta);
+        NFT::register_v2<BoxMiner>(sender, meta);
+        move_to(sender, NFTInfo{total_supply, price});
         let cap = NFT::remove_mint_capability<BoxMiner>(sender);
         move_to(sender, BoxMinerMintCapability{cap});
     }
@@ -34,17 +37,17 @@ module creator::BoxMiner {
         NFTGallery::accept<BoxMiner, BoxMinerBody>(sender);
     }
 
-    public fun mint(sender: &signer): NFT<BoxMiner, BoxMinerBody> acquires BoxMinerMintCapability{
-        let ex_info = NFT::nft_type_info_ex_info<BoxMiner, NFTInfo>();
-        let counter = NFT::nft_type_info_counter<BoxMiner, NFTInfo>();
+    public fun mint(sender: &signer): NFT<BoxMiner, BoxMinerBody> acquires BoxMinerMintCapability, NFTInfo{
+        let ex_info = borrow_global<NFTInfo>(@creator);
+        let counter = NFT::nft_type_info_counter_v2<BoxMiner>();
         let total_supply = ex_info.total_supply;
         let price = ex_info.price;
         assert(total_supply >= counter, 1000);
         let tokens = Account::withdraw<STC>(sender, price);
         Account::deposit<STC>(@creator, tokens);
         let cap = borrow_global_mut<BoxMinerMintCapability>(@creator);
         let metadata = NFT::new_meta(b"stc_box_miner", b"This is the starcoin boxminer.");
-        let nft = NFT::mint_with_cap<BoxMiner, BoxMinerBody, NFTInfo>(@creator, &mut cap.cap, metadata, BoxMiner{price}, BoxMinerBody{});
+        let nft = NFT::mint_with_cap_v2<BoxMiner, BoxMinerBody>(@creator, &mut cap.cap, metadata, BoxMiner{price}, BoxMinerBody{});
         return nft
     }
 }

vm/functional-tests/tests/testsuite/nft/nft_boxminer.move

@@ -20,8 +20,6 @@ module creator::Card {
         second: L1Card,
     }
 
-    struct NFTInfo has copy, store, drop{}
-
     struct L1CardMintCapability has key{
         cap: MintCapability<L1CardMeta>,
     }
@@ -39,13 +37,13 @@ module creator::Card {
     }
 
     public fun init(sender: &signer){
-        NFT::register<L1CardMeta, NFTInfo>(sender,NFTInfo{}, NFT::empty_meta());
+        NFT::register_v2<L1CardMeta>(sender, NFT::empty_meta());
         let cap = NFT::remove_mint_capability<L1CardMeta>(sender);
         move_to(sender, L1CardMintCapability{ cap});
 
         let cap = NFT::remove_burn_capability<L1CardMeta>(sender);
         move_to(sender, L1CardBurnCapability{ cap});
-        NFT::register<L2CardMeta, NFTInfo>(sender,NFTInfo{}, NFT::empty_meta());
+        NFT::register_v2<L2CardMeta>(sender, NFT::empty_meta());
         let cap = NFT::remove_mint_capability<L2CardMeta>(sender);
         move_to(sender, L2CardMintCapability{ cap});
 
@@ -56,7 +54,7 @@ module creator::Card {
     public fun mint_l1(_sender: &signer): NFT<L1CardMeta, L1Card> acquires L1CardMintCapability{
         let cap = borrow_global_mut<L1CardMintCapability>(@creator);
         let metadata = NFT::new_meta_with_image(b"l1_card", b"ipfs:://xxxxxx", b"This is a L1CardMeta nft.");
-        NFT::mint_with_cap<L1CardMeta, L1Card, NFTInfo>(@creator, &mut cap.cap, metadata, L1CardMeta{ gene: Timestamp::now_milliseconds()}, L1Card{})
+        NFT::mint_with_cap_v2<L1CardMeta, L1Card>(@creator, &mut cap.cap, metadata, L1CardMeta{ gene: Timestamp::now_milliseconds()}, L1Card{})
     }
 
     public fun mint_l2(_sender: &signer, first: NFT<L1CardMeta, L1Card>, second: NFT<L1CardMeta, L1Card>): NFT<L2CardMeta,L2Card> acquires L1CardBurnCapability, L2CardMintCapability {
@@ -70,7 +68,7 @@ module creator::Card {
         let s = NFT::burn_with_cap(&mut burn_cap.cap, second);
         let mint_cap = borrow_global_mut<L2CardMintCapability>(@creator);
         let metadata = NFT::new_meta_with_image(b"l2_card", b"ipfs:://xxxxxx", b"This is a L2CardMeta nft.");
-        NFT::mint_with_cap<L2CardMeta, L2Card, NFTInfo>(@creator, &mut mint_cap.cap, metadata, L2CardMeta{
+        NFT::mint_with_cap_v2<L2CardMeta, L2Card>(@creator, &mut mint_cap.cap, metadata, L2CardMeta{
             gene: new_gene,
         }, L2Card{
             first:f,

vm/functional-tests/tests/testsuite/nft/nft_card.move

@@ -5,7 +5,8 @@
 address creator = {{creator}};
 module creator::Card {
     use 0x1::Timestamp;
-    use 0x1::NFT::{Self, NFT, MintCapability, BurnCapability, UpdateCapability};
+    use 0x1::NFT::{Self, NFT, Metadata, MintCapability, BurnCapability, UpdateCapability};
+    use 0x1::Signer;
 
     struct Card has copy, store, drop{
         upgrade_time: u64,
@@ -23,8 +24,6 @@ module creator::Card {
         cap: BurnCapability<Card>,
     }
 
-    struct NFTInfo has copy, drop, store{}
-
     struct CardUpdateCapability has key{
         cap: UpdateCapability<Card>,
     }
@@ -38,7 +37,8 @@ module creator::Card {
     }
 
     public fun init(sender: &signer){
-        NFT::register<Card, NFTInfo>(sender, NFTInfo{}, NFT::empty_meta());
+        assert(Signer::address_of(sender) == @creator, 1000);
+        NFT::register_v2<Card>(sender, NFT::empty_meta());
         let cap = NFT::remove_mint_capability<Card>(sender);
         move_to(sender, CardMintCapability{ cap});
 
@@ -52,7 +52,7 @@ module creator::Card {
     public fun mint(_sender: &signer): NFT<Card, CardBody> acquires CardMintCapability{
         let cap = borrow_global_mut<CardMintCapability>(@creator);
         let metadata = NFT::new_meta_with_image(b"card", b"ipfs:://xxxxxx", b"This is a Card nft.");
-        NFT::mint_with_cap<Card, CardBody, NFTInfo>(@creator, &mut cap.cap, metadata, Card{ upgrade_time: Timestamp::now_milliseconds()}, CardBody{ level: 1})
+        NFT::mint_with_cap_v2<Card, CardBody>(@creator, &mut cap.cap, metadata, Card{ upgrade_time: Timestamp::now_milliseconds()}, CardBody{ level: 1})
     }
 
     /// upgrade the first card by burn the second card.
@@ -76,6 +76,12 @@ module creator::Card {
         let body = NFT::borrow_body_mut_with_cap(&mut update_cap.cap, first);
         body.level = level;
     }
+
+    public fun update_type_info_meta(sender: &signer, meta: Metadata) acquires CardUpdateCapability{
+        assert(Signer::address_of(sender) == @creator, 1000);
+        let update_cap = borrow_global_mut<CardUpdateCapability>(@creator);
+        NFT::update_nft_type_info_meta_with_cap(&mut update_cap.cap, meta);
+    }
 }
 
 // check: EXECUTED
@@ -152,4 +158,34 @@ script {
     }
 }
 
+// check: EXECUTED
+
+
+//! new-transaction
+//! sender: creator
+address creator = {{creator}};
+script {
+    use creator::Card::{Self, Card};
+    use 0x1::NFT;
+
+    fun main(sender: signer) {
+        let type_meta = NFT::nft_type_info_meta<Card>();
+        assert(NFT::meta_name(&type_meta) == b"", 1004);
+        assert(NFT::meta_image(&type_meta) == b"", 1005);
+        assert(NFT::meta_description(&type_meta) == b"", 1006);
+
+        let name = b"card";
+        let image = b"ipfs://image_hash";
+        let description = b"a card game nft";
+        let new_meta = NFT::new_meta_with_image(*&name, *&image, *&description);
+
+        Card::update_type_info_meta(&sender, new_meta);
+
+        let type_meta = NFT::nft_type_info_meta<Card>();
+        assert(NFT::meta_name(&type_meta) == name, 1007);
+        assert(NFT::meta_image(&type_meta) == image, 1008);
+        assert(NFT::meta_description(&type_meta) == description, 1009);
+    }
+}
+
 // check: EXECUTED

vm/functional-tests/tests/testsuite/nft/nft_metadata.move

@@ -10,7 +10,6 @@ module creator::AnyNFT {
     struct AnyNFT has copy, store, drop{}
     struct AnyNFTBody has store{
     }
-    struct AnyNFTInfo has copy,store,drop{}
 
     struct AnyNFTMintCapability has key{
         cap: MintCapability<AnyNFT>,
@@ -21,7 +20,7 @@ module creator::AnyNFT {
     }
 
     public fun init(sender: &signer){
-        NFT::register<AnyNFT,AnyNFTInfo>(sender, AnyNFTInfo{}, NFT::empty_meta());
+        NFT::register_v2<AnyNFT>(sender,NFT::empty_meta());
         let cap = NFT::remove_mint_capability<AnyNFT>(sender);
         move_to(sender, AnyNFTMintCapability{cap});
         let cap = NFT::remove_burn_capability<AnyNFT>(sender);
@@ -33,7 +32,7 @@ module creator::AnyNFT {
         let sender_addr = Signer::address_of(sender);
         let cap = borrow_global_mut<AnyNFTMintCapability>(@creator);
         let metadata = NFT::new_meta_with_image(b"test_nft_1", b"ipfs:://xxxxxx", b"This is a test nft.");
-        let nft = NFT::mint_with_cap<AnyNFT,AnyNFTBody,AnyNFTInfo>(sender_addr, &mut cap.cap, metadata, AnyNFT{}, AnyNFTBody{});
+        let nft = NFT::mint_with_cap_v2<AnyNFT,AnyNFTBody>(sender_addr, &mut cap.cap, metadata, AnyNFT{}, AnyNFTBody{});
         NFTGallery::deposit(sender, nft);
     }
 

vm/functional-tests/tests/testsuite/nft/test_gallery.move

@@ -9,15 +9,14 @@ module creator::TestNFT {
     struct TestNFT has copy, store, drop{}
     struct TestNFTBody has store{
     }
-    struct NFTInfo has copy,store,drop{}
     public fun init(sender: &signer){
-        NFT::register<TestNFT,NFTInfo>(sender, NFTInfo{},NFT::empty_meta());
+        NFT::register_v2<TestNFT>(sender, NFT::empty_meta());
         Self::do_accept(sender);
     }
 
     public fun mint(sender: &signer){
         let metadata = NFT::new_meta_with_image(b"test_nft_1", b"ipfs:://xxxxxx", b"This is a test nft.");
-        let nft = NFT::mint<TestNFT,TestNFTBody,NFTInfo>(sender, metadata, TestNFT{}, TestNFTBody{});
+        let nft = NFT::mint_v2<TestNFT,TestNFTBody>(sender, metadata, TestNFT{}, TestNFTBody{});
         NFTGallery::deposit(sender, nft);
     }
 

vm/functional-tests/tests/testsuite/nft/test_nft.move

@@ -82,6 +82,7 @@ module NFT {
         }
     }
 
+    /// Note: this function is deprecated, please use nft_type_info_counter_v2
     public fun nft_type_info_counter<NFTMeta: copy + store + drop, NFTTypeInfoExt: copy + store + drop>(): u64 acquires NFTTypeInfo, NFTTypeInfoV2 {
         if(exists<NFTTypeInfoV2<NFTMeta>>(CoreAddresses::GENESIS_ADDRESS())){
             Self::nft_type_info_counter_v2<NFTMeta>()
@@ -96,6 +97,11 @@ module NFT {
         *&info.counter
     }
 
+    public fun nft_type_info_meta<NFTMeta: copy + store + drop>(): Metadata acquires NFTTypeInfoV2 {
+        let info = borrow_global_mut<NFTTypeInfoV2<NFTMeta>>(CoreAddresses::GENESIS_ADDRESS());
+        *&info.meta
+    }
+
     public fun upgrade_nft_type_info_from_v1_to_v2<NFTMeta: copy + store + drop, NFTTypeInfoExt: copy + store + drop>(sender: &signer, _cap: &mut MintCapability<NFTMeta>) acquires NFTTypeInfo{
         if(exists<NFTTypeInfo<NFTMeta, NFTTypeInfoExt>>(CoreAddresses::GENESIS_ADDRESS())) {
             let nft_type_info = move_from<NFTTypeInfo<NFTMeta, NFTTypeInfoExt>>(CoreAddresses::GENESIS_ADDRESS());
@@ -120,7 +126,7 @@ module NFT {
         let NFTTypeInfoCompat{info} = compat_info;
         info
     }
-
+    /// deprecated.
     struct GenesisSignerCapability has key {
         cap: Account::SignerCapability,
     }
@@ -424,6 +430,20 @@ module NFT {
         let UpdateCapability {} = cap;
     }
 
+    /// Update the NFTTypeInfoV2 metadata with UpdateCapability<NFTMeta>
+    public fun update_nft_type_info_meta_with_cap<NFTMeta: copy + store + drop>(_cap: &mut UpdateCapability<NFTMeta>, new_meta: Metadata) acquires NFTTypeInfoV2{
+        let info = borrow_global_mut<NFTTypeInfoV2<NFTMeta>>(CoreAddresses::GENESIS_ADDRESS());
+        info.meta = new_meta;
+    }
+
+    /// Update the NFTTypeInfoV2 metadata, the `sender` must have UpdateCapability<NFTMeta>
+    public fun update_nft_type_info_meta<NFTMeta: copy + store + drop, NFTBody: store>(sender: &signer, new_meta: Metadata) acquires UpdateCapability, NFTTypeInfoV2 {
+        let addr = Signer::address_of(sender);
+        assert(exists<UpdateCapability<NFTMeta>>(addr), Errors::requires_capability(ERR_NO_UPDATE_CAPABILITY));
+        let cap = borrow_global_mut<UpdateCapability<NFTMeta>>(addr);
+        update_nft_type_info_meta_with_cap(cap, new_meta)
+    }
+
     /// Update the nft's base_meta and type_meta with UpdateCapability<NFTMeta>
     public fun update_meta_with_cap<NFTMeta: copy + store + drop, NFTBody: store>(_cap: &mut UpdateCapability<NFTMeta>, nft: &mut NFT<NFTMeta, NFTBody>, base_meta: Metadata, type_meta: NFTMeta) {
         nft.base_meta = base_meta;