git.delta.rocks / unique-network / refs/commits / 415353264b69

no syntactic changes

no syntactic changes

646			.into_iter()664			.into_iter()
647			.map(|(key, permission)| PropertyKeyPermission {665			.map(|(key, permission)| PropertyKeyPermission { key, permission })
648				key,
649				permission,
650			})
651			.collect();666			.collect();
652667
653		let properties = <CollectionProperties<T>>::get(collection)668		let properties = <CollectionProperties<T>>::get(collection)
654			.into_iter()669			.into_iter()
655			.map(|(key, value)| Property {670			.map(|(key, value)| Property { key, value })
656				key,
657				value,
658			})
659			.collect();671			.collect();
660672
751				.unwrap_or_else(|| Ok(CollectionLimits::default()))?,763				.unwrap_or_else(|| Ok(CollectionLimits::default()))?,
752			permissions: data764			permissions: data
753				.permissions765				.permissions
754				.map(|permissions| Self::clamp_permissions(data.mode.clone(), &Default::default(), permissions))766				.map(|permissions| {
767					Self::clamp_permissions(data.mode.clone(), &Default::default(), permissions)
768				})
755				.unwrap_or_else(|| Ok(CollectionPermissions::default()))?,769				.unwrap_or_else(|| Ok(CollectionPermissions::default()))?,
756		};770		};
757771
1007					.into_iter()1021					.into_iter()
1008					.map(|(key, value)| Property {1022					.map(|(key, value)| Property { key, value })
1009						key,
1010						value,
1011					})
1012					.collect()1023					.collect()
1013			});1024			});
1039					.into_iter()1050					.into_iter()
1040					.map(|(key, permission)| PropertyKeyPermission {1051					.map(|(key, permission)| PropertyKeyPermission { key, permission })
1041						key,
1042						permission,
1043					})
1044					.collect()1052					.collect()
1045			});1053			});

no syntactic changes

no syntactic changes

22	PropertyKeyPermission, PropertyValue,22	PropertyKeyPermission, PropertyValue,
23};23};
24use pallet_common::{24use pallet_common::{
25	CommonCollectionOperations, CommonWeightInfo, with_weight, weights::WeightInfo as _25	CommonCollectionOperations, CommonWeightInfo, with_weight, weights::WeightInfo as _,
26};26};
27use sp_runtime::DispatchError;27use sp_runtime::DispatchError;
28use sp_std::vec::Vec;28use sp_std::vec::Vec;
417				.into_iter()409				.into_iter()
418				.map(|(key, value)| Property {410				.map(|(key, value)| Property { key, value })
419					key,
420					value,
421				})
422				.collect()411				.collect()
423		})412		})

no syntactic changes

no syntactic changes

22use sp_std::vec::Vec;22use sp_std::vec::Vec;
23use up_data_structs::*;23use up_data_structs::*;
24use pallet_common::{Pallet as PalletCommon, Error as CommonError, CollectionHandle, CommonCollectionOperations};24use pallet_common::{
25	Pallet as PalletCommon, Error as CommonError, CollectionHandle, CommonCollectionOperations,
26};
25use pallet_nonfungible::{Pallet as PalletNft, NonfungibleHandle, TokenData};27use pallet_nonfungible::{Pallet as PalletNft, NonfungibleHandle, TokenData};
26use pallet_evm::account::CrossAccountId;28use pallet_evm::account::CrossAccountId;
158161
159            Self::deposit_event(Event::CollectionCreated {162			Self::deposit_event(Event::CollectionCreated {
160                issuer: sender,163				issuer: sender,
161                collection_id: collection_id.0164				collection_id: collection_id.0,
162            });165			});
163166
164            Ok(())167			Ok(())
184193
185            Self::deposit_event(Event::CollectionDestroyed { issuer: sender, collection_id });194			Self::deposit_event(Event::CollectionDestroyed {
195				issuer: sender,
196				collection_id,
197			});
186198
187            Ok(())199			Ok(())
238250
239			Self::deposit_event(Event::CollectionLocked { issuer: sender, collection_id });251			Self::deposit_event(Event::CollectionLocked {
252				issuer: sender,
253				collection_id,
254			});
240255
241            Ok(())256			Ok(())
257272
258            let royalty_info = royalty_amount.map(|amount| rmrk::RoyaltyInfo {273			let royalty_info = royalty_amount.map(|amount| rmrk::RoyaltyInfo {
259                recipient: recipient.unwrap_or_else(|| owner.clone()),274				recipient: recipient.unwrap_or_else(|| owner.clone()),
260                amount275				amount,
261            });276			});
262277
263            let collection = Self::get_typed_nft_collection(278			let collection = Self::get_typed_nft_collection(
280            ).map_err(|err| match err {296			)
297			.map_err(|err| match err {
281                DispatchError::Arithmetic(_) => <Error<T>>::NoAvailableNftId.into(),298				DispatchError::Arithmetic(_) => <Error<T>>::NoAvailableNftId.into(),
282                err => Self::map_common_err_to_proxy(err)299				err => Self::map_common_err_to_proxy(err),
283            })?;300			})?;
284301
285            Self::deposit_event(Event::NftMinted {302			Self::deposit_event(Event::NftMinted {
286                owner,303				owner,
287                collection_id,304				collection_id,
288                nft_id: nft_id.0305				nft_id: nft_id.0,
289            });306			});
290307
291            Ok(())308			Ok(())
310327
311            Self::deposit_event(Event::NFTBurned { owner: sender, nft_id });328			Self::deposit_event(Event::NFTBurned {
329				owner: sender,
330				nft_id,
331			});
312332
313            Ok(())333			Ok(())
340                        PropertyScope::Rmrk,360						PropertyScope::Rmrk,
341                        Self::rmrk_property(UserProperty(key.as_slice()), &value)?361						Self::rmrk_property(UserProperty(key.as_slice()), &value)?,
342                    )?;362					)?;
343                },363				}
344                None => {364				None => {
345                    let collection = Self::get_typed_nft_collection(365					let collection = Self::get_typed_nft_collection(
346                        collection_id,366						collection_id,
362                    collection_id: rmrk_collection_id,381				collection_id: rmrk_collection_id,
363                    maybe_nft_id,382				maybe_nft_id,
364                    key,383				key,
365                    value384				value,
366                }385			});
367            );
368386
390413
391        let property = Property {414		let property = Property { key, value };
392            key,
393            value,
394        };
395415
396        Ok(property)416		Ok(property)
480495
481        match collection.mode {496		match collection.mode {
482            CollectionMode::NFT => Ok(NonfungibleHandle::cast(collection)),497			CollectionMode::NFT => Ok(NonfungibleHandle::cast(collection)),
483            _ => Err(<Error<T>>::CollectionUnknown.into())498			_ => Err(<Error<T>>::CollectionUnknown.into()),
484        }499		}
485    }500	}
486501
559    where599	where
560        Key: TryFrom<RmrkPropertyKey> + AsRef<[u8]>,600		Key: TryFrom<RmrkPropertyKey> + AsRef<[u8]>,
561        Value: Decode + Default,601		Value: Decode + Default,
562        Mapper: Fn(Key, Value) -> R602		Mapper: Fn(Key, Value) -> R,
563    {603	{
564        filter_keys.map(|keys| {604		filter_keys
605			.map(|keys| {
575                        None => Self::get_collection_property(617							None => Self::get_collection_property(
576                            collection_id,618								collection_id,
577                            UserProperty(key.as_ref())619								UserProperty(key.as_ref()),
578                        )620							),
579                    }.ok()?.decode_or_default();621						}
622						.ok()?
623						.decode_or_default();
599    where644	where
600        Key: TryFrom<RmrkPropertyKey> + AsRef<[u8]>,645		Key: TryFrom<RmrkPropertyKey> + AsRef<[u8]>,
601        Value: Decode + Default,646		Value: Decode + Default,
602        Mapper: Fn(Key, Value) -> R647		Mapper: Fn(Key, Value) -> R,
603    {648	{
604        let key_prefix = Self::rmrk_property_key(UserProperty(b""))?;649		let key_prefix = Self::rmrk_property_key(UserProperty(b""))?;
605650
606        let properties = match token_id {651		let properties = match token_id {
607            Some(token_id) => <PalletNft<T>>::token_properties((collection_id, token_id)),652			Some(token_id) => <PalletNft<T>>::token_properties((collection_id, token_id)),
608            None => <PalletCommon<T>>::collection_properties(collection_id)653			None => <PalletCommon<T>>::collection_properties(collection_id),
609        };654		};
610655
611        let properties = properties656		let properties = properties.into_iter().filter_map(move |(key, value)| {

3232
33impl<T, S> RmrkRebind<T, S> for BoundedVec<u8, T> where BoundedVec<u8, S>: TryFrom<Vec<u8>> {33impl<T, S> RmrkRebind<T, S> for BoundedVec<u8, T>
34where
35	BoundedVec<u8, S>: TryFrom<Vec<u8>>,
36{
34    fn rebind(&self) -> BoundedVec<u8, S> {37	fn rebind(&self) -> BoundedVec<u8, S> {
35        BoundedVec::<u8, S>::try_from(38		BoundedVec::<u8, S>::try_from(self.clone().into_inner()).unwrap_or_default()
51    Resource,52	Resource,
52    FixedPart,53	FixedPart,
53    SlotPart,54	SlotPart,
54    Theme55	Theme,
55}56}
5657

no syntactic changes

24use pallet_rmrk_core::{Pallet as PalletCore, misc::{self, *}, property::RmrkProperty::*};24use pallet_rmrk_core::{
25	Pallet as PalletCore,
26	misc::{self, *},
27	property::RmrkProperty::*,
28};
25use pallet_nonfungible::{Pallet as PalletNft, NonfungibleHandle};29use pallet_nonfungible::{Pallet as PalletNft, NonfungibleHandle};
26use pallet_evm::account::CrossAccountId;30use pallet_evm::account::CrossAccountId;
140130
141            Self::deposit_event(Event::BaseCreated { issuer: sender, base_id: collection_id.0 });131			Self::deposit_event(Event::BaseCreated {
132				issuer: sender,
133				base_id: collection_id.0,
134			});
142135
143            Ok(())136			Ok(())
175                NftType::Theme,169				NftType::Theme,
176                [170				[
177                    <PalletCore<T>>::rmrk_property(ThemeName, &theme.name)?,171					<PalletCore<T>>::rmrk_property(ThemeName, &theme.name)?,
178                    <PalletCore<T>>::rmrk_property(ThemeInherit, &theme.inherit)?172					<PalletCore<T>>::rmrk_property(ThemeInherit, &theme.inherit)?,
179                ].into_iter()173				]
174				.into_iter(),
180            ).map_err(|_| <Error<T>>::PermissionError)?;175			)
176			.map_err(|_| <Error<T>>::PermissionError)?;
181177
219            nft_type,215			nft_type,
220            [216			[
221                <PalletCore<T>>::rmrk_property(Src, &src)?,217				<PalletCore<T>>::rmrk_property(Src, &src)?,
222                <PalletCore<T>>::rmrk_property(ZIndex, &z_index)?218				<PalletCore<T>>::rmrk_property(ZIndex, &z_index)?,
223            ].into_iter()219			]
220			.into_iter(),
224        ).map_err(|err| match err {221		)
222		.map_err(|err| match err {
225            DispatchError::Arithmetic(_) => <Error<T>>::NoAvailablePartId.into(),223			DispatchError::Arithmetic(_) => <Error<T>>::NoAvailablePartId.into(),
226            err => err224			err => err,
227        })?;225		})?;
228226
229        if let RmrkPartType::SlotPart(part) = part {227		if let RmrkPartType::SlotPart(part) = part {

no syntactic changes

23};23};
24use pallet_evm::account::CrossAccountId;24use pallet_evm::account::CrossAccountId;
25use pallet_common::{25use pallet_common::{Error as CommonError, Event as CommonEvent, Pallet as PalletCommon};
26	Error as CommonError, Event as CommonEvent, Pallet as PalletCommon,
27};
28use pallet_structure::Pallet as PalletStructure;26use pallet_structure::Pallet as PalletStructure;
29use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};27use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};

191		token_id: TokenId,191		token_id: TokenId,
192		nesting_budget: &dyn Budget192		nesting_budget: &dyn Budget,
193	) -> DispatchResult {193	) -> DispatchResult {
194		Self::try_exec_if_owner_is_valid_nft(194		Self::try_exec_if_owner_is_valid_nft(under, |d, parent_id| {
195			under,
196			|d, parent_id| d.check_nesting(195			d.check_nesting(from, (collection_id, token_id), parent_id, nesting_budget)
197				from,
198				(collection_id, token_id),
199				parent_id,
200				nesting_budget
201			)
202		)196		})
203	}197	}
204198
205	pub fn nest_if_sent_to_token(199	pub fn nest_if_sent_to_token(
231		collection_id: CollectionId,217		collection_id: CollectionId,
232		token_id: TokenId218		token_id: TokenId,
233	) {219	) {
234		Self::exec_if_owner_is_valid_nft(220		Self::exec_if_owner_is_valid_nft(owner, |d, parent_id| {
235			owner,
236			|d, parent_id| d.nest(221			d.nest(parent_id, (collection_id, token_id))
237				parent_id,
238				(collection_id, token_id)
239			)
240		);222		});
241	}223	}
242224
243	pub fn unnest_if_nested(225	pub fn unnest_if_nested(
244		owner: &T::CrossAccountId,226		owner: &T::CrossAccountId,
245		collection_id: CollectionId,227		collection_id: CollectionId,
246		token_id: TokenId228		token_id: TokenId,
247	) {229	) {
248		Self::exec_if_owner_is_valid_nft(230		Self::exec_if_owner_is_valid_nft(owner, |d, parent_id| {
249			owner,
250			|d, parent_id| d.unnest(231			d.unnest(parent_id, (collection_id, token_id))
251			parent_id,
252			(collection_id, token_id)
253			)
254		);232		});
255	}233	}
256234
257	fn exec_if_owner_is_valid_nft(235	fn exec_if_owner_is_valid_nft(

no syntactic changes

935pub type RmrkResourceInfo = ResourceInfo<935pub type RmrkResourceInfo = ResourceInfo<RmrkBoundedResource, RmrkString, RmrkBoundedParts>;
936	RmrkBoundedResource,
937	RmrkString,
938	RmrkBoundedParts,
939>;
940pub type RmrkPropertyInfo = PropertyInfo<RmrkKeyString, RmrkValueString>;936pub type RmrkPropertyInfo = PropertyInfo<RmrkKeyString, RmrkValueString>;
941pub type RmrkBaseInfo<AccountId> = BaseInfo<AccountId, RmrkString>;937pub type RmrkBaseInfo<AccountId> = BaseInfo<AccountId, RmrkString>;

47        {47		{
48            match value {48			match value {
49                Some(value) => super::vec::serialize(value, serializer),49				Some(value) => super::vec::serialize(value, serializer),
50                None => serializer.serialize_none()50				None => serializer.serialize_none(),
51            }51			}
52        }52		}
53    }53	}
422	pub fn id(&self) -> PartId {390	pub fn id(&self) -> PartId {
423		match self {391		match self {
424			Self::FixedPart(part) => part.id,392			Self::FixedPart(part) => part.id,
425			Self::SlotPart(part) => part.id393			Self::SlotPart(part) => part.id,
426		}394		}
427	}395	}
428396
429	pub fn src(&self) -> &BoundedString {397	pub fn src(&self) -> &BoundedString {
430		match self {398		match self {
431			Self::FixedPart(part) => &part.src,399			Self::FixedPart(part) => &part.src,
432			Self::SlotPart(part) => &part.src400			Self::SlotPart(part) => &part.src,
433		}401		}
434	}402	}
435403
436	pub fn z_index(&self) -> ZIndex {404	pub fn z_index(&self) -> ZIndex {
437		match self {405		match self {
438			Self::FixedPart(part) => part.z,406			Self::FixedPart(part) => part.z,
439			Self::SlotPart(part) => part.z407			Self::SlotPart(part) => part.z,
440		}408		}
441	}409	}
442}410}

152		.into_iter()153		.into_iter()
153		.map(|(key, permission)| PropertyKeyPermission {154		.map(|(key, permission)| PropertyKeyPermission { key, permission })
154			key,
155			permission,
156		})
157		.collect()155		.collect()
158}156}
162		.into_iter()160		.into_iter()
163		.map(|(key, value)| Property {161		.map(|(key, value)| Property { key, value })
164			key,
165			value,
166		})
167		.collect()162		.collect()
168}163}
172		.into_iter()167		.into_iter()
173		.map(|(key, value)| Property {168		.map(|(key, value)| Property { key, value })
174			key,
175			value,
176		})
177		.collect()169		.collect()
178}170}