git.delta.rocks / unique-network / refs/commits / 22128f82de1c

--- a/client/rpc/src/lib.rs
+++ b/client/rpc/src/lib.rs
@@ -276,14 +276,15 @@
 			at: Option<BlockHash>,
 		) -> Result<Vec<ResourceInfo>>;
 
-		#[method(name = "rmrk_nftResourcePriorities")]
-		/// Get NFT resource priorities
-		fn nft_resource_priorities(
+		#[method(name = "rmrk_nftResourcePriority")]
+		/// Get NFT resource priority
+		fn nft_resource_priority(
 			&self,
 			collection_id: RmrkCollectionId,
 			nft_id: RmrkNftId,
+			resource_id: RmrkResourceId,
 			at: Option<BlockHash>,
-		) -> Result<Vec<RmrkResourceId>>;
+		) -> Result<Option<u32>>;
 
 		#[method(name = "rmrk_base")]
 		/// Get base info
@@ -522,7 +523,7 @@
 		rmrk_api
 	);
 	pass_method!(nft_resources(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Vec<ResourceInfo>, rmrk_api);
-	pass_method!(nft_resource_priorities(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Vec<RmrkResourceId>, rmrk_api);
+	pass_method!(nft_resource_priority(collection_id: RmrkCollectionId, nft_id: RmrkNftId, resource_id: RmrkResourceId) -> Option<u32>, rmrk_api);
 	pass_method!(base(base_id: RmrkBaseId) -> Option<BaseInfo>, rmrk_api);
 	pass_method!(base_parts(base_id: RmrkBaseId) -> Vec<PartType>, rmrk_api);
 	pass_method!(theme_names(base_id: RmrkBaseId) -> Vec<RmrkThemeName>, rmrk_api);

--- a/pallets/proxy-rmrk-core/src/lib.rs
+++ b/pallets/proxy-rmrk-core/src/lib.rs
@@ -695,6 +695,34 @@
 
 		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
 		#[transactional]
+		pub fn set_priority(
+			origin: OriginFor<T>,
+			rmrk_collection_id: RmrkCollectionId,
+			rmrk_nft_id: RmrkNftId,
+			priorities: BoundedVec<RmrkResourceId, RmrkMaxPriorities>,
+		) -> DispatchResult {
+			let sender = ensure_signed(origin)?;
+			let sender = T::CrossAccountId::from_sub(sender);
+
+			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
+			let nft_id = rmrk_nft_id.into();
+			let budget = budget::Value::new(NESTING_BUDGET);
+
+			Self::ensure_nft_type(collection_id, nft_id, NftType::Regular)?;
+			Self::ensure_nft_owner(collection_id, nft_id, &sender, &budget)?;
+
+			<PalletNft<T>>::set_scoped_token_property(
+				collection_id,
+				nft_id,
+				PropertyScope::Rmrk,
+				Self::rmrk_property(ResourcePriorities, &priorities.into_inner())?
+			)?;
+
+			Ok(())
+		}
+
+		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
+		#[transactional]
 		pub fn add_basic_resource(
 			origin: OriginFor<T>,
 			collection_id: RmrkCollectionId,
@@ -1160,7 +1188,7 @@
 		token_id: TokenId,
 	) -> Result<NftType, DispatchError> {
 		Self::get_nft_property_decoded(collection_id, token_id, TokenType)
-			.map_err(|_| <Error<T>>::NftTypeEncodeError.into())
+			.map_err(|_| <Error<T>>::NoAvailableNftId.into())
 	}
 
 	pub fn ensure_nft_type(

--- a/primitives/data-structs/src/lib.rs
+++ b/primitives/data-structs/src/lib.rs
@@ -929,6 +929,8 @@
 	pub const RmrkMaxCollectionsEquippablePerPart: u32 = 100;
 	#[derive(PartialEq)]
 	pub const RmrkPartsLimit: u32 = 3;
+	#[derive(PartialEq)]
+	pub const RmrkMaxPriorities: u32 = 3;
 }
 
 impl From<RmrkCollectionId> for CollectionId {

5050
51		fn nft_resources(collection_id: CollectionId, nft_id: NftId) -> Result<Vec<ResourceInfo>>;51		fn nft_resources(collection_id: CollectionId, nft_id: NftId) -> Result<Vec<ResourceInfo>>;
5252
53		fn nft_resource_priorities(collection_id: CollectionId, nft_id: NftId) -> Result<Vec<ResourceId>>;53		fn nft_resource_priority(collection_id: CollectionId, nft_id: NftId, resource_id: ResourceId) -> Result<Option<u32>>;
5454
55		fn base(base_id: BaseId) -> Result<Option<BaseInfo>>;55		fn base(base_id: BaseId) -> Result<Option<BaseInfo>>;
5656

--- a/runtime/common/src/runtime_apis.rs
+++ b/runtime/common/src/runtime_apis.rs
@@ -363,33 +363,25 @@
                     Ok(resources)
                 }
 
-                fn nft_resource_priorities(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkResourceId>, DispatchError> {
+                fn nft_resource_priority(collection_id: RmrkCollectionId, nft_id: RmrkNftId, resource_id: RmrkResourceId) -> Result<Option<u32>, DispatchError> {
                     use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType}};
 
                     let collection_id = match RmrkCore::unique_collection_id(collection_id) {
                         Ok(id) => id,
-                        Err(_) => return Ok(Vec::new())
+                        Err(_) => return Ok(None)
                     };
-                    if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(Vec::new()); }
+                    if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(None); }
 
                     let nft_id = TokenId(nft_id);
-                    if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(Vec::new()); }
+                    if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(None); }
 
-                    /*let resource_collection_id: CollectionId = RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::ResourceCollection)
-                        .unwrap();
-                    if RmrkCore::ensure_collection_type(collection_id, CollectionType::Resource).is_err() { return Ok(Vec::new()); }
-
-                    let resources = pallet_nonfungible::TokenProperties::<Runtime>::iter_prefix((resource_collection_id,))
-                        .filter_map(|(resource_id, properties)| Some((
-                            resource_id, // ResourceId property
-                            RmrkCore::get_nft_property_decoded(resource_collection_id, resource_id, RmrkProperty::Priority).unwrap(),
-                        )))
-                        .collect()
-                        .sort_by_key(|(_, index)| *index)
-                        .into_iter().map(|(resource_id, _)| resource_id)*/
-                    let priorities = RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::ResourcePriorities)?;
-
-                    Ok(priorities)
+                    let priorities: Vec<_> = RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::ResourcePriorities)?;
+                    Ok(
+                        priorities.into_iter()
+                            .enumerate()
+                            .find(|(_, id)| *id == resource_id)
+                            .map(|(priority, _): (usize, RmrkResourceId)| priority as u32)
+                    )
                 }
 
                 fn base(base_id: RmrkBaseId) -> Result<Option<RmrkBaseInfo<AccountId>>, DispatchError> {