Merge pull request #129 from rmrk-team/bug/121-add-royalty-struct

implement royalty struct

Author: bmacer

pallets/rmrk-core/src/functions.rs

@@ -270,8 +270,8 @@ where
 		_sender: T::AccountId,
 		owner: T::AccountId,
 		collection_id: CollectionId,
-		recipient: Option<T::AccountId>,
-		royalty: Option<Permill>,
+		royalty_recipient: Option<T::AccountId>,
+		royalty_amount: Option<Permill>,
 		metadata: StringLimitOf<T>,
 	) -> sp_std::result::Result<(CollectionId, NftId), DispatchError> {
 		let nft_id = Self::get_next_nft_id(collection_id)?;
@@ -282,14 +282,23 @@ where
 			ensure!(nft_id < max, Error::<T>::CollectionFullOrLocked);
 		}
 
-		let recipient = recipient.unwrap_or_else(|| owner.clone());
-		let royalty = royalty.unwrap_or_default();
+		let mut royalty: Option<RoyaltyInfo::<T::AccountId>> = None;
+
+		if let Some(amount) = royalty_amount {
+			match royalty_recipient {
+				Some(recipient) => {
+					royalty = Some(RoyaltyInfo::<T::AccountId> { recipient, amount });
+				},
+				None => {
+					royalty = Some(RoyaltyInfo::<T::AccountId> { recipient: owner.clone(), amount });
+				}
+			}
+		};
 
 		let owner_as_maybe_account = AccountIdOrCollectionNftTuple::AccountId(owner.clone());
 
 		let nft = NftInfo {
 			owner: owner_as_maybe_account,
-			recipient,
 			royalty,
 			metadata,
 			equipped: false,

pallets/rmrk-core/src/lib.rs

@@ -12,7 +12,7 @@ use sp_std::convert::TryInto;
 
 use rmrk_traits::{
 	primitives::*, AccountIdOrCollectionNftTuple, Collection, CollectionInfo, Nft, NftInfo,
-	Priority, Property, Resource, ResourceInfo,
+	Priority, Property, Resource, ResourceInfo, RoyaltyInfo
 };
 use sp_std::result::Result;
 

pallets/rmrk-core/src/tests.rs

@@ -274,6 +274,59 @@ fn mint_collection_max_logic_works() {
 	});
 }
 
+/// NFT: Royalty defaults to self when amount provided but no recipient
+#[test]
+fn royalty_recipient_default_works() {
+	ExtBuilder::default().build().execute_with(|| {
+		// Create a basic collection
+		assert_ok!(basic_collection());
+		// Mint an NFT
+		assert_ok!(RMRKCore::mint_nft(
+			Origin::signed(ALICE),
+			ALICE,
+			COLLECTION_ID_0,
+			None, // No royalty recipient
+			Some(Permill::from_float(20.525)),
+			bvec![0u8; 20]
+		));
+		// Royalty recipient should default to issuer (ALICE)
+		assert_eq!(RmrkCore::nfts(0, 0).unwrap().royalty.unwrap().recipient, ALICE);
+		// Mint another NFT
+		assert_ok!(RMRKCore::mint_nft(
+			Origin::signed(ALICE),
+			ALICE,
+			COLLECTION_ID_0,
+			Some(BOB), // Royalty recipient is BOB
+			Some(Permill::from_float(20.525)),
+			bvec![0u8; 20]
+		));
+		// Royalty recipient should be BOB
+		assert_eq!(RmrkCore::nfts(0, 1).unwrap().royalty.unwrap().recipient, BOB);
+		// Mint another NFT
+		assert_ok!(RMRKCore::mint_nft(
+			Origin::signed(ALICE),
+			ALICE,
+			COLLECTION_ID_0,
+			None, // No royalty recipient is BOB
+			None, // No royalty amount
+			bvec![0u8; 20]
+		));
+		// Royalty should not exist
+		assert!(RmrkCore::nfts(0, 2).unwrap().royalty.is_none());
+		// Mint another NFT
+		assert_ok!(RMRKCore::mint_nft(
+			Origin::signed(ALICE),
+			ALICE,
+			COLLECTION_ID_0,
+			Some(ALICE), // Royalty recipient is ALICE
+			None, // No royalty amount
+			bvec![0u8; 20]
+		));
+		// Royalty should not exist
+		assert!(RmrkCore::nfts(0, 3).unwrap().royalty.is_none());
+	});
+}
+
 /// NFT: Send tests (RMRK2.0 spec: SEND)
 #[test]
 fn send_nft_to_minted_nft_works() {

traits/src/lib.rs

@@ -14,7 +14,7 @@ pub use part::{EquippableList, FixedPart, PartType, SlotPart};
 pub use theme::{Theme, ThemeProperty};
 // pub use part::{PartInfo};
 pub use collection::{Collection, CollectionInfo};
-pub use nft::{AccountIdOrCollectionNftTuple, Nft, NftInfo};
+pub use nft::{AccountIdOrCollectionNftTuple, Nft, NftInfo, RoyaltyInfo};
 pub use priority::Priority;
 pub use property::Property;
 pub use resource::{Resource, ResourceInfo};

traits/src/nft.rs

@@ -19,16 +19,24 @@ pub enum AccountIdOrCollectionNftTuple<AccountId> {
 	CollectionAndNftTuple(CollectionId, NftId),
 }
 
+/// Royalty information (recipient and amount)
+#[cfg_attr(feature = "std", derive(PartialEq, Eq))]
+#[derive(Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct RoyaltyInfo<AccountId> {
+	/// Recipient (AccountId) of the royalty
+    pub recipient: AccountId,
+	/// Amount (Permill) of the royalty
+    pub amount: Permill,
+}
+
 /// Nft info.
 #[cfg_attr(feature = "std", derive(PartialEq, Eq))]
 #[derive(Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen)]
 pub struct NftInfo<AccountId, BoundedString> {
 	/// The owner of the NFT, can be either an Account or a tuple (CollectionId, NftId)
 	pub owner: AccountIdOrCollectionNftTuple<AccountId>,
-	/// The user account which receives the royalty
-	pub recipient: AccountId,
-	/// Royalty in per mille (1/1000)
-	pub royalty: Permill,
+	/// Royalty (optional)
+	pub royalty: Option<RoyaltyInfo<AccountId>>,
 	/// Arbitrary data about an instance, e.g. IPFS hash
 	pub metadata: BoundedString,
 	/// Equipped state
@@ -46,8 +54,8 @@ pub trait Nft<AccountId, BoundedString> {
 		sender: AccountId,
 		owner: AccountId,
 		collection_id: CollectionId,
-		recipient: Option<AccountId>,
-		royalty: Option<Permill>,
+		royalty_recipient: Option<AccountId>,
+		royalty_amount: Option<Permill>,
 		metadata: BoundedString,
 	) -> Result<(CollectionId, NftId), DispatchError>;
 	fn nft_burn(