git.delta.rocks / unique-network / refs/commits / c9b52e8d7f58

7sed -n '/=== SNIP START ===/, /=== SNIP END ===/{ /=== SNIP START ===/! { /=== SNIP END ===/! p } }' $tmp > $raw7sed -n '/=== SNIP START ===/, /=== SNIP END ===/{ /=== SNIP START ===/! { /=== SNIP END ===/! p } }' $tmp > $raw
8formatted=$(mktemp)8formatted=$(mktemp)
9prettier --use-tabs $raw > $formatted9prettier --use-tabs $raw > $formatted
10solhint --fix $formatted
1110
12mv $formatted $OUTPUT11mv $formatted $OUTPUT
1312

6391 "sp-core",6391 "sp-core",
6392 "sp-runtime",6392 "sp-runtime",
6393 "sp-std",6393 "sp-std",
6394 "struct-versioning",
6394 "up-data-structs",6395 "up-data-structs",
6395]6396]
63966397
6508 "sp-core",6509 "sp-core",
6509 "sp-runtime",6510 "sp-runtime",
6510 "sp-std",6511 "sp-std",
6512 "struct-versioning",
6511 "up-data-structs",6513 "up-data-structs",
6512]6514]
65136515

31use rmrk_rpc::RmrkApi as RmrkRuntimeApi;31use rmrk_rpc::RmrkApi as RmrkRuntimeApi;
32use up_data_structs::{32use up_data_structs::{
33	RmrkCollectionId, RmrkNftId, RmrkBaseId, RmrkNftChild,33	RmrkCollectionId, RmrkNftId, RmrkBaseId, RmrkNftChild, RmrkThemeName, RmrkPropertyKey,
34	RmrkThemeName, RmrkPropertyKey, RmrkResourceId34	RmrkResourceId,
35};35};
3636
37pub use rmrk_unique_rpc::RmrkApi;37pub use rmrk_unique_rpc::RmrkApi;
80		token: TokenId,80		token: TokenId,
81		at: Option<BlockHash>,81		at: Option<BlockHash>,
82	) -> Result<Vec<u8>>;82	) -> Result<Vec<u8>>;
83	#[rpc(name = "unique_variableMetadata")]
84	fn variable_metadata(
85		&self,
86		collection: CollectionId,
87		token: TokenId,
88		at: Option<BlockHash>,
89	) -> Result<Vec<u8>>;
9083
91	#[rpc(name = "unique_collectionProperties")]84	#[rpc(name = "unique_collectionProperties")]
92	fn collection_properties(85	fn collection_properties(
93		&self,86		&self,
94		collection: CollectionId,87		collection: CollectionId,
95		keys: Vec<String>,88		keys: Option<Vec<String>>,
96		at: Option<BlockHash>,89		at: Option<BlockHash>,
97	) -> Result<Vec<Property>>;90	) -> Result<Vec<Property>>;
9891
101		&self,94		&self,
102		collection: CollectionId,95		collection: CollectionId,
103		token_id: TokenId,96		token_id: TokenId,
104		properties: Vec<String>,97		keys: Option<Vec<String>>,
105		at: Option<BlockHash>,98		at: Option<BlockHash>,
106	) -> Result<Vec<Property>>;99	) -> Result<Vec<Property>>;
107100
108	#[rpc(name = "unique_propertyPermissions")]101	#[rpc(name = "unique_propertyPermissions")]
109	fn property_permissions(102	fn property_permissions(
110		&self,103		&self,
111		collection: CollectionId,104		collection: CollectionId,
112		keys: Vec<String>,105		keys: Option<Vec<String>>,
113		at: Option<BlockHash>,106		at: Option<BlockHash>,
114	) -> Result<Vec<PropertyKeyPermission>>;107	) -> Result<Vec<PropertyKeyPermission>>;
115108
118		&self,111		&self,
119		collection: CollectionId,112		collection: CollectionId,
120		token_id: TokenId,113		token_id: TokenId,
121		keys: Vec<String>,114		keys: Option<Vec<String>>,
122		at: Option<BlockHash>,115		at: Option<BlockHash>,
123	) -> Result<TokenData<CrossAccountId>>;116	) -> Result<TokenData<CrossAccountId>>;
124117
429	pass_method!(422	pass_method!(
430		const_metadata(collection: CollectionId, token: TokenId) -> Vec<u8>, unique_api423		const_metadata(collection: CollectionId, token: TokenId) -> Vec<u8>, unique_api
431	);424	);
432	pass_method!(
433		variable_metadata(collection: CollectionId, token: TokenId) -> Vec<u8>,
434		unique_api
435	);
436	pass_method!(total_supply(collection: CollectionId) -> u32, unique_api);425	pass_method!(total_supply(collection: CollectionId) -> u32, unique_api);
437	pass_method!(account_balance(collection: CollectionId, account: CrossAccountId) -> u32, unique_api);426	pass_method!(account_balance(collection: CollectionId, account: CrossAccountId) -> u32, unique_api);
438	pass_method!(balance(collection: CollectionId, account: CrossAccountId, token: TokenId) -> String => |v| v.to_string(), unique_api);427	pass_method!(balance(collection: CollectionId, account: CrossAccountId, token: TokenId) -> String => |v| v.to_string(), unique_api);
445		collection: CollectionId,434		collection: CollectionId,
446435
447		#[map(|keys| string_keys_to_bytes_keys(keys))]436		#[map(|keys| string_keys_to_bytes_keys(keys))]
448		keys: Vec<String>437		keys: Option<Vec<String>>
449	) -> Vec<Property>, unique_api);438	) -> Vec<Property>, unique_api);
450439
451	pass_method!(token_properties(440	pass_method!(token_properties(
452		collection: CollectionId,441		collection: CollectionId,
453		token_id: TokenId,442		token_id: TokenId,
454443
455		#[map(|keys| string_keys_to_bytes_keys(keys))]444		#[map(|keys| string_keys_to_bytes_keys(keys))]
456		properties: Vec<String>445		keys: Option<Vec<String>>
457	) -> Vec<Property>, unique_api);446	) -> Vec<Property>, unique_api);
458447
459	pass_method!(property_permissions(448	pass_method!(property_permissions(
460		collection: CollectionId,449		collection: CollectionId,
461450
462		#[map(|keys| string_keys_to_bytes_keys(keys))]451		#[map(|keys| string_keys_to_bytes_keys(keys))]
463		keys: Vec<String>452		keys: Option<Vec<String>>
464	) -> Vec<PropertyKeyPermission>, unique_api);453	) -> Vec<PropertyKeyPermission>, unique_api);
465454
466	pass_method!(token_data(455	pass_method!(token_data(
467		collection: CollectionId,456		collection: CollectionId,
468		token_id: TokenId,457		token_id: TokenId,
469458
470		#[map(|keys| string_keys_to_bytes_keys(keys))]459		#[map(|keys| string_keys_to_bytes_keys(keys))]
471		keys: Vec<String>,460		keys: Option<Vec<String>>,
472	) -> TokenData<CrossAccountId>, unique_api);461	) -> TokenData<CrossAccountId>, unique_api);
473462
474	pass_method!(adminlist(collection: CollectionId) -> Vec<CrossAccountId>, unique_api);463	pass_method!(adminlist(collection: CollectionId) -> Vec<CrossAccountId>, unique_api);
549	pass_method!(theme(base_id: RmrkBaseId, theme_name: RmrkThemeName, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Option<Theme>, rmrk_api);538	pass_method!(theme(base_id: RmrkBaseId, theme_name: RmrkThemeName, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Option<Theme>, rmrk_api);
550}539}
551540
552fn string_keys_to_bytes_keys(keys: Vec<String>) -> Vec<Vec<u8>> {541fn string_keys_to_bytes_keys(keys: Option<Vec<String>>) -> Option<Vec<Vec<u8>>> {
553	keys.into_iter().map(|key| key.into_bytes()).collect()542	keys.map(|keys| keys.into_iter().map(|key| key.into_bytes()).collect())
554}543}
555544

72	Balance,
73	Index,
74	Hash,
75	Block,
76};
7769
78// RMRK70// RMRK

no syntactic changes

21use sp_std::vec::Vec;21use sp_std::vec::Vec;
22use up_data_structs::Property;22use up_data_structs::Property;
2323
24use crate::{Pallet, CollectionHandle, Config};24use crate::{Pallet, CollectionHandle, Config, CollectionProperties};
2525
26/// Does not always represent a full collection, for RFT it is either26/// Does not always represent a full collection, for RFT it is either
27/// collection (Implementing ERC721), or specific collection token (Implementing ERC20)27/// collection (Implementing ERC721), or specific collection token (Implementing ERC20)
3333
34#[solidity_interface(name = "CollectionProperties")]34#[solidity_interface(name = "CollectionProperties")]
35impl<T: Config> CollectionHandle<T> {35impl<T: Config> CollectionHandle<T> {
36	fn set_property(&mut self, caller: caller, key: string, value: string) -> Result<()> {36	fn set_collection_property(&mut self, caller: caller, key: string, value: bytes) -> Result<()> {
37		<Pallet<T>>::set_collection_property(
38			self,
39			&T::CrossAccountId::from_eth(caller),37		let caller = T::CrossAccountId::from_eth(caller);
40			Property {
41				key: <Vec<u8>>::from(key)38		let key = <Vec<u8>>::from(key)
42					.try_into()39			.try_into()
43					.map_err(|_| "key too large")?,40			.map_err(|_| "key too large")?;
44				value: <Vec<u8>>::from(value)41		let value = value.try_into().map_err(|_| "value too large")?;
45					.try_into()42
46					.map_err(|_| "value too large")?,43		<Pallet<T>>::set_collection_property(self, &caller, Property { key, value })
47			},
48		)
49		.map_err(dispatch_to_evm::<T>)?;44			.map_err(dispatch_to_evm::<T>)
50		Ok(())
51	}45	}
5246
53	fn delete_property(&mut self, caller: caller, key: string) -> Result<()> {47	fn delete_collection_property(&mut self, caller: caller, key: string) -> Result<()> {
48		let caller = T::CrossAccountId::from_eth(caller);
49		let key = <Vec<u8>>::from(key)
50			.try_into()
51			.map_err(|_| "key too large")?;
52
53		<Pallet<T>>::delete_collection_property(self, &caller, key).map_err(dispatch_to_evm::<T>)
54	}
55
56	/// Throws error if key not found
54		self.set_property(caller, key, string::new())57	fn collection_property(&self, key: string) -> Result<bytes> {
55	}58		let key = <Vec<u8>>::from(key)
59			.try_into()
60			.map_err(|_| "key too large")?;
61
62		let props = <CollectionProperties<T>>::get(self.id);
63		let prop = props.get(&key).ok_or("key not found")?;
64
65		Ok(prop.to_vec())
66	}
56}67}
5768

22use pallet_evm::account::CrossAccountId;22use pallet_evm::account::CrossAccountId;
23use frame_support::{23use frame_support::{
24	dispatch::{DispatchErrorWithPostInfo, DispatchResultWithPostInfo, Weight, PostDispatchInfo},24	dispatch::{DispatchErrorWithPostInfo, DispatchResultWithPostInfo, Weight, PostDispatchInfo},
25	ensure, fail,25	ensure,
26	traits::{Imbalance, Get, Currency, WithdrawReasons, ExistenceRequirement},26	traits::{Imbalance, Get, Currency, WithdrawReasons, ExistenceRequirement},
27	BoundedVec,27	BoundedVec,
28	weights::Pays,28	weights::Pays,
29	transactional,
29};30};
30use pallet_evm::GasWeightMapping;31use pallet_evm::GasWeightMapping;
31use up_data_structs::{32use up_data_structs::{
32	COLLECTION_NUMBER_LIMIT, Collection, RpcCollection, CollectionId, CreateItemData,33	COLLECTION_NUMBER_LIMIT,
34	Collection,
35	RpcCollection,
36	CollectionId,
37	CreateItemData,
33	MAX_TOKEN_PREFIX_LENGTH, COLLECTION_ADMINS_LIMIT, MetaUpdatePermission, TokenId,38	MAX_TOKEN_PREFIX_LENGTH,
39	COLLECTION_ADMINS_LIMIT,
40	TokenId,
34	CollectionStats, MAX_TOKEN_OWNERSHIP, CollectionMode, NFT_SPONSOR_TRANSFER_TIMEOUT,41	CollectionStats,
42	MAX_TOKEN_OWNERSHIP,
43	CollectionMode,
44	NFT_SPONSOR_TRANSFER_TIMEOUT,
35	FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, MAX_SPONSOR_TIMEOUT,45	FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,
46	REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,
47	MAX_SPONSOR_TIMEOUT,
36	CUSTOM_DATA_LIMIT, CollectionLimits, CustomDataLimit, CreateCollectionData, SponsorshipState,48	CUSTOM_DATA_LIMIT,
49	CollectionLimits,
50	CreateCollectionData,
51	SponsorshipState,
37	CreateItemExData, SponsoringRateLimit, budget::Budget, COLLECTION_FIELD_LIMIT, CollectionField,52	CreateItemExData,
53	SponsoringRateLimit,
54	budget::Budget,
55	COLLECTION_FIELD_LIMIT,
56	CollectionField,
38	PhantomType, Property, Properties, PropertiesPermissionMap, PropertyKey, PropertyPermission,57	PhantomType,
58	Property,
59	Properties,
60	PropertiesPermissionMap,
61	PropertyKey,
62	PropertyPermission,
39	PropertiesError, PropertyKeyPermission, TokenData, TrySet,63	PropertiesError,
64	PropertyKeyPermission,
65	TokenData,
66	TrySetProperty,
40	// RMRK67	// RMRK
41	RmrkCollectionInfo, RmrkInstanceInfo, RmrkResourceInfo, RmrkPropertyInfo, RmrkBaseInfo, RmrkPartType, RmrkTheme,68	RmrkCollectionInfo,
69	RmrkInstanceInfo,
70	RmrkResourceInfo,
71	RmrkPropertyInfo,
72	RmrkBaseInfo,
73	RmrkPartType,
74	RmrkTheme,
42	RmrkNftChild,75	RmrkNftChild,
43};76};
4477
139		);172		);
140		Ok(())173		Ok(())
141	}174	}
142
143	pub fn check_can_update_meta(
144		&self,
145		subject: &T::CrossAccountId,
146		item_owner: &T::CrossAccountId,
147	) -> DispatchResult {
148		match self.meta_update_permission {
149			MetaUpdatePermission::ItemOwner => {
150				ensure!(subject == item_owner, <Error<T>>::NoPermission);
151				Ok(())
152			}
153			MetaUpdatePermission::Admin => self.check_is_owner_or_admin(subject),
154			MetaUpdatePermission::None => fail!(<Error<T>>::NoPermission),
155		}
156	}
157}175}
158176
159#[frame_support::pallet]177#[frame_support::pallet]
316		CollectionTokenPrefixLimitExceeded,334		CollectionTokenPrefixLimitExceeded,
317		/// Total collections bound exceeded.335		/// Total collections bound exceeded.
318		TotalCollectionsLimitExceeded,336		TotalCollectionsLimitExceeded,
319		/// variable_data exceeded data limit.
320		TokenVariableDataLimitExceeded,
321		/// Exceeded max admin count337		/// Exceeded max admin count
322		CollectionAdminCountExceeded,338		CollectionAdminCountExceeded,
323		/// Collection limit bounds per collection exceeded339		/// Collection limit bounds per collection exceeded
366		/// Tried to store more property keys than allowed382		/// Tried to store more property keys than allowed
367		PropertyLimitReached,383		PropertyLimitReached,
368384
369		/// Unable to read array of unbounded keys385		/// Property key is too long
370		UnableToReadUnboundedKeys,386		PropertyKeyIsTooLong,
371387
372		/// Only ASCII letters, digits, and '_', '-' are allowed388		/// Only ASCII letters, digits, and '_', '-' are allowed
373		InvalidCharacterInPropertyKey,389		InvalidCharacterInPropertyKey,
580			schema_version,596			schema_version,
581			sponsorship,597			sponsorship,
582			limits,598			limits,
583			meta_update_permission,
584		} = <CollectionById<T>>::get(collection)?;599		} = <CollectionById<T>>::get(collection)?;
585600
586		let token_property_permissions = <CollectionPropertyPermissions<T>>::get(collection)601		let token_property_permissions = <CollectionPropertyPermissions<T>>::get(collection)
610			schema_version,625			schema_version,
611			sponsorship,626			sponsorship,
612			limits,627			limits,
613			meta_update_permission,
614			offchain_schema: <CollectionData<T>>::get((628			offchain_schema: <CollectionData<T>>::get((
615				collection,629				collection,
616				CollectionField::OffchainSchema,630				CollectionField::OffchainSchema,
671				.limits685				.limits
672				.map(|limits| Self::clamp_limits(data.mode.clone(), &Default::default(), limits))686				.map(|limits| Self::clamp_limits(data.mode.clone(), &Default::default(), limits))
673				.unwrap_or_else(|| Ok(CollectionLimits::default()))?,687				.unwrap_or_else(|| Ok(CollectionLimits::default()))?,
674			meta_update_permission: data.meta_update_permission.unwrap_or_default(),
675		};688		};
676689
677		let mut collection_properties = up_data_structs::CollectionProperties::get();690		let mut collection_properties = up_data_structs::CollectionProperties::get();
775		Ok(())788		Ok(())
776	}789	}
777790
791	#[transactional]
778	pub fn set_collection_properties(792	pub fn set_collection_properties(
779		collection: &CollectionHandle<T>,793		collection: &CollectionHandle<T>,
780		sender: &T::CrossAccountId,794		sender: &T::CrossAccountId,
807		Ok(())821		Ok(())
808	}822	}
809823
824	#[transactional]
810	pub fn delete_collection_properties(825	pub fn delete_collection_properties(
811		collection: &CollectionHandle<T>,826		collection: &CollectionHandle<T>,
812		sender: &T::CrossAccountId,827		sender: &T::CrossAccountId,
849		Ok(())864		Ok(())
850	}865	}
851866
867	#[transactional]
852	pub fn set_property_permissions(868	pub fn set_property_permissions(
853		collection: &CollectionHandle<T>,869		collection: &CollectionHandle<T>,
854		sender: &T::CrossAccountId,870		sender: &T::CrossAccountId,
867		keys.into_iter()883		keys.into_iter()
868			.map(|key| -> Result<PropertyKey, DispatchError> {884			.map(|key| -> Result<PropertyKey, DispatchError> {
869				key.try_into()885				key.try_into()
870					.map_err(|_| <Error<T>>::UnableToReadUnboundedKeys.into())886					.map_err(|_| <Error<T>>::PropertyKeyIsTooLong.into())
871			})887			})
872			.collect::<Result<Vec<PropertyKey>, DispatchError>>()888			.collect::<Result<Vec<PropertyKey>, DispatchError>>()
873	}889	}
874890
875	pub fn check_property_key(key: &PropertyKey) -> Result<(), DispatchError> {
876		let key_str = sp_std::str::from_utf8(key.as_slice())
877			.map_err(|_| <Error<T>>::InvalidCharacterInPropertyKey)?;
878
879		for ch in key_str.chars() {
880			if !ch.is_ascii_alphanumeric() && ch != '_' && ch != '-' {
881				return Err(<Error<T>>::InvalidCharacterInPropertyKey.into());
882			}
883		}
884
885		Ok(())
886	}
887
888	pub fn filter_collection_properties(891	pub fn filter_collection_properties(
889		collection_id: CollectionId,892		collection_id: CollectionId,
890		keys: Vec<PropertyKey>,893		keys: Option<Vec<PropertyKey>>,
891	) -> Result<Vec<Property>, DispatchError> {894	) -> Result<Vec<Property>, DispatchError> {
892		let properties = Self::collection_properties(collection_id);895		let properties = Self::collection_properties(collection_id);
893896
894		let properties = keys897		let properties = keys
895			.into_iter()898			.map(|keys| {
899				keys.into_iter()
896			.filter_map(|key| {900					.filter_map(|key| {
897				properties.get(&key).map(|value| Property {901						properties.get(&key).map(|value| Property {
898					key,902							key,
899					value: value.clone(),903							value: value.clone(),
900				})904						})
905					})
906					.collect()
901			})907			})
902			.collect();908			.unwrap_or_else(|| {
909				properties
910					.iter()
911					.map(|(key, value)| Property {
912						key: key.clone(),
913						value: value.clone(),
914					})
915					.collect()
916			});
903917
904		Ok(properties)918		Ok(properties)
905	}919	}
906920
907	pub fn filter_property_permissions(921	pub fn filter_property_permissions(
908		collection_id: CollectionId,922		collection_id: CollectionId,
909		keys: Vec<PropertyKey>,923		keys: Option<Vec<PropertyKey>>,
910	) -> Result<Vec<PropertyKeyPermission>, DispatchError> {924	) -> Result<Vec<PropertyKeyPermission>, DispatchError> {
911		let permissions = Self::property_permissions(collection_id);925		let permissions = Self::property_permissions(collection_id);
912926
913		let key_permissions = keys927		let key_permissions = keys
914			.into_iter()928			.map(|keys| {
929				keys.into_iter()
915			.filter_map(|key| {930					.filter_map(|key| {
931						permissions
932							.get(&key)
933							.map(|permission| PropertyKeyPermission {
934								key,
935								permission: permission.clone(),
936							})
937					})
938					.collect()
939			})
940			.unwrap_or_else(|| {
916				permissions941				permissions
917					.get(&key)942					.iter()
918					.map(|permission| PropertyKeyPermission {943					.map(|(key, permission)| PropertyKeyPermission {
919						key,944						key: key.clone(),
920						permission: permission.clone(),945						permission: permission.clone(),
921					})946					})
922			})947					.collect()
923			.collect();948			});
924949
925		Ok(key_permissions)950		Ok(key_permissions)
926	}951	}
1086	fn approve() -> Weight;1111	fn approve() -> Weight;
1087	fn transfer_from() -> Weight;1112	fn transfer_from() -> Weight;
1088	fn burn_from() -> Weight;1113	fn burn_from() -> Weight;
1089	fn set_variable_metadata(bytes: u32) -> Weight;
1090}1114}
10911115
1092pub trait CommonCollectionOperations<T: Config> {1116pub trait CommonCollectionOperations<T: Config> {
1174		token: TokenId,1198		token: TokenId,
1175		amount: u128,1199		amount: u128,
1176		nesting_budget: &dyn Budget,1200		nesting_budget: &dyn Budget,
1177	) -> DispatchResultWithPostInfo;
1178
1179	fn set_variable_metadata(
1180		&self,
1181		sender: T::CrossAccountId,
1182		token: TokenId,
1183		data: BoundedVec<u8, CustomDataLimit>,
1184	) -> DispatchResultWithPostInfo;1201	) -> DispatchResultWithPostInfo;
11851202
1186	fn check_nesting(1203	fn check_nesting(
11981215
1199	fn token_owner(&self, token: TokenId) -> Option<T::CrossAccountId>;1216	fn token_owner(&self, token: TokenId) -> Option<T::CrossAccountId>;
1200	fn const_metadata(&self, token: TokenId) -> Vec<u8>;1217	fn const_metadata(&self, token: TokenId) -> Vec<u8>;
1201	fn variable_metadata(&self, token: TokenId) -> Vec<u8>;1218	fn token_properties(&self, token_id: TokenId, keys: Option<Vec<PropertyKey>>) -> Vec<Property>;
1202	fn token_properties(&self, token_id: TokenId, keys: Vec<PropertyKey>) -> Vec<Property>;
1203	/// Amount of unique collection tokens1219	/// Amount of unique collection tokens
1204	fn total_supply(&self) -> u32;1220	fn total_supply(&self) -> u32;
1205	/// Amount of different tokens account has (Applicable to nonfungible/refungible)1221	/// Amount of different tokens account has (Applicable to nonfungible/refungible)
1232			PropertiesError::NoSpaceForProperty => Self::NoSpaceForProperty,1248			PropertiesError::NoSpaceForProperty => Self::NoSpaceForProperty,
1233			PropertiesError::PropertyLimitReached => Self::PropertyLimitReached,1249			PropertiesError::PropertyLimitReached => Self::PropertyLimitReached,
1234			PropertiesError::InvalidCharacterInPropertyKey => Self::InvalidCharacterInPropertyKey,1250			PropertiesError::InvalidCharacterInPropertyKey => Self::InvalidCharacterInPropertyKey,
1251			PropertiesError::PropertyKeyIsTooLong => Self::PropertyKeyIsTooLong,
1235			PropertiesError::EmptyPropertyKey => Self::EmptyPropertyKey,1252			PropertiesError::EmptyPropertyKey => Self::EmptyPropertyKey,
1236		}1253		}
1237	}1254	}

binary blob — no preview

1616
17use core::marker::PhantomData;17use core::marker::PhantomData;
1818
19use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight, BoundedVec};19use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight};
20use up_data_structs::{TokenId, CollectionId, CreateItemExData, budget::Budget};20use up_data_structs::{TokenId, CollectionId, CreateItemExData, budget::Budget};
21use pallet_common::{CommonCollectionOperations, CommonWeightInfo, with_weight};21use pallet_common::{CommonCollectionOperations, CommonWeightInfo, with_weight};
22use sp_runtime::ArithmeticError;22use sp_runtime::ArithmeticError;
23use sp_std::{vec::Vec, vec};23use sp_std::{vec::Vec, vec};
24use up_data_structs::{CustomDataLimit, Property, PropertyKey, PropertyKeyPermission};24use up_data_structs::{Property, PropertyKey, PropertyKeyPermission};
2525
26use crate::{26use crate::{
27	Allowance, Balance, Config, Error, FungibleHandle, Pallet, SelfWeightOf, weights::WeightInfo,27	Allowance, Balance, Config, Error, FungibleHandle, Pallet, SelfWeightOf, weights::WeightInfo,
86		<SelfWeightOf<T>>::burn_from()86		<SelfWeightOf<T>>::burn_from()
87	}87	}
88
89	fn set_variable_metadata(_bytes: u32) -> Weight {
90		// Error
91		0
92	}
93}88}
9489
95impl<T: Config> CommonCollectionOperations<T> for FungibleHandle<T> {90impl<T: Config> CommonCollectionOperations<T> for FungibleHandle<T> {
287		fail!(<Error<T>>::SettingPropertiesNotAllowed)282		fail!(<Error<T>>::SettingPropertiesNotAllowed)
288	}283	}
289
290	fn set_variable_metadata(
291		&self,
292		_sender: T::CrossAccountId,
293		_token: TokenId,
294		_data: BoundedVec<u8, CustomDataLimit>,
295	) -> DispatchResultWithPostInfo {
296		fail!(<Error<T>>::FungibleItemsDontHaveData)
297	}
298284
299	fn check_nesting(285	fn check_nesting(
300		&self,286		&self,
332	fn const_metadata(&self, _token: TokenId) -> Vec<u8> {318	fn const_metadata(&self, _token: TokenId) -> Vec<u8> {
333		Vec::new()319		Vec::new()
334	}320	}
335	fn variable_metadata(&self, _token: TokenId) -> Vec<u8> {
336		Vec::new()
337	}
338321
339	fn token_properties(&self, _token_id: TokenId, _keys: Vec<PropertyKey>) -> Vec<Property> {322	fn token_properties(
323		&self,
324		_token_id: TokenId,
325		_keys: Option<Vec<PropertyKey>>,
326	) -> Vec<Property> {
340		Vec::new()327		Vec::new()
341	}328	}

binary blob — no preview

31	);
23}32}
24
25// Selector: 56fd500b
26contract CollectionProperties is Dummy, ERC165 {
27	// Selector: setProperty(string,string) 62d9491f
28	function setProperty(string memory key, string memory value) public {
29		require(false, stub_error);
30		key;
31		value;
32		dummy = 0;
33	}
34	// Selector: deleteProperty(string) 34241914
35	function deleteProperty(string memory key) public {
36		require(false, stub_error);
37		key;
38		dummy = 0;
39	}
40}
4133
42// Selector: 79cc679034// Selector: 79cc6790
43contract ERC20UniqueExtensions is Dummy, ERC165 {35contract ERC20UniqueExtensions is Dummy, ERC165 {
119	}127	}
120}128}
129
130// Selector: 9b5e29c5
131contract CollectionProperties is Dummy, ERC165 {
132	// Selector: setCollectionProperty(string,bytes) 2f073f66
133	function setCollectionProperty(string memory key, bytes memory value)
134		public
135	{
136		require(false, stub_error);
137		key;
138		value;
139		dummy = 0;
140	}
141
142	// Selector: deleteCollectionProperty(string) 7b7debce
143	function deleteCollectionProperty(string memory key) public {
144		require(false, stub_error);
145		key;
146		dummy = 0;
147	}
148
149	// Throws error if key not found
150	//
151	// Selector: collectionProperty(string) cf24fd6d
152	function collectionProperty(string memory key)
153		public
154		view
155		returns (bytes memory)
156	{
157		require(false, stub_error);
158		key;
159		dummy;
160		return hex"";
161	}
162}
121163
122contract UniqueFungible is Dummy, ERC165, ERC20, ERC20UniqueExtensions, CollectionProperties {164contract UniqueFungible is
165	Dummy,

27scale-info = { version = "2.0.1", default-features = false, features = [27scale-info = { version = "2.0.1", default-features = false, features = [
28    "derive",28    "derive",
29] }29] }
30struct-versioning = { path = "../../crates/struct-versioning" }
3031
31[features]32[features]
32default = ["std"]33default = ["std"]

2828
29fn create_max_item_data<T: Config>(owner: T::CrossAccountId) -> CreateItemData<T> {29fn create_max_item_data<T: Config>(owner: T::CrossAccountId) -> CreateItemData<T> {
30	let const_data = create_data::<CUSTOM_DATA_LIMIT>();30	let const_data = create_data::<CUSTOM_DATA_LIMIT>();
31	let variable_data = create_data::<CUSTOM_DATA_LIMIT>();
32	CreateItemData::<T> {31	CreateItemData::<T> { const_data, owner }
33		const_data,
34		variable_data,
35		owner,
36	}
37}32}
38fn create_max_item<T: Config>(33fn create_max_item<T: Config>(
126		<Pallet<T>>::set_allowance(&collection, &sender, item, Some(&burner))?;121		<Pallet<T>>::set_allowance(&collection, &sender, item, Some(&burner))?;
127	}: {<Pallet<T>>::burn_from(&collection, &burner, &sender, item, &Unlimited)?}122	}: {<Pallet<T>>::burn_from(&collection, &burner, &sender, item, &Unlimited)?}
128
129	set_variable_metadata {
130		let b in 0..CUSTOM_DATA_LIMIT;
131		bench_init!{
132			owner: sub; collection: collection(owner);
133			owner: cross_from_sub; sender: cross_sub;
134		};
135		let item = create_max_item(&collection, &owner, sender.clone())?;
136		let data = create_var_data(b).try_into().unwrap();
137	}: {<Pallet<T>>::set_variable_metadata(&collection, &sender, item, data)?}
138}123}
139124

1616
17use core::marker::PhantomData;17use core::marker::PhantomData;
1818
19use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight, BoundedVec};19use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight};
20use up_data_structs::{20use up_data_structs::{
21	TokenId, CustomDataLimit, CreateItemExData, CollectionId, budget::Budget, Property,21	TokenId, CreateItemExData, CollectionId, budget::Budget, Property, PropertyKey,
22	PropertyKey, PropertyKeyPermission,22	PropertyKeyPermission,
23};23};
24use pallet_common::{CommonCollectionOperations, CommonWeightInfo, with_weight};24use pallet_common::{CommonCollectionOperations, CommonWeightInfo, with_weight};
87		<SelfWeightOf<T>>::burn_from()87		<SelfWeightOf<T>>::burn_from()
88	}88	}
89
90	fn set_variable_metadata(bytes: u32) -> Weight {
91		<SelfWeightOf<T>>::set_variable_metadata(bytes)
92	}
93}89}
9490
95fn map_create_data<T: Config>(91fn map_create_data<T: Config>(
99	match data {95	match data {
100		up_data_structs::CreateItemData::NFT(data) => Ok(CreateItemData::<T> {96		up_data_structs::CreateItemData::NFT(data) => Ok(CreateItemData::<T> {
101			const_data: data.const_data,97			const_data: data.const_data,
102			variable_data: data.variable_data,
103			properties: data.properties,98			properties: data.properties,
104			owner: to.clone(),99			owner: to.clone(),
105		}),100		}),
184		let weight = <CommonWeights<T>>::delete_collection_properties(property_keys.len() as u32);179		let weight = <CommonWeights<T>>::delete_collection_properties(property_keys.len() as u32);
185180
186		with_weight(181		with_weight(
187			<Pallet<T>>::delete_collection_properties(self, &sender, property_keys),182			<Pallet<T>>::delete_collection_properties(self, sender, property_keys),
188			weight,183			weight,
189		)184		)
190	}185	}
327		}322		}
328	}323	}
329
330	fn set_variable_metadata(
331		&self,
332		sender: T::CrossAccountId,
333		token: TokenId,
334		data: BoundedVec<u8, CustomDataLimit>,
335	) -> DispatchResultWithPostInfo {
336		let len = data.len();
337		with_weight(
338			<Pallet<T>>::set_variable_metadata(self, &sender, token, data),
339			<CommonWeights<T>>::set_variable_metadata(len as u32),
340		)
341	}
342324
343	fn check_nesting(325	fn check_nesting(
344		&self,326		&self,
379			.unwrap_or_default()361			.unwrap_or_default()
380			.into_inner()362			.into_inner()
381	}363	}
382	fn variable_metadata(&self, token: TokenId) -> Vec<u8> {
383		<TokenData<T>>::get((self.id, token))
384			.map(|t| t.variable_data)
385			.unwrap_or_default()
386			.into_inner()
387	}
388364
389	fn token_properties(&self, token_id: TokenId, keys: Vec<PropertyKey>) -> Vec<Property> {365	fn token_properties(&self, token_id: TokenId, keys: Option<Vec<PropertyKey>>) -> Vec<Property> {
390		let properties = <Pallet<T>>::token_properties((self.id, token_id));366		let properties = <Pallet<T>>::token_properties((self.id, token_id));
391367
368		keys.map(|keys| {
392		keys.into_iter()369			keys.into_iter()
393			.filter_map(|key| {370				.filter_map(|key| {
394				properties.get(&key).map(|value| Property {371					properties.get(&key).map(|value| Property {
397				})374					})
398			})375				})
399			.collect()376				.collect()
377		})
378		.unwrap_or_else(|| {
379			properties
380				.iter()
381				.map(|(key, value)| Property {
382					key: key.clone(),
383					value: value.clone(),
384				})
385				.collect()
386		})
400	}387	}
401388
402	fn total_supply(&self) -> u32 {389	fn total_supply(&self) -> u32 {

21};21};
22use evm_coder::{ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*, weight};22use evm_coder::{ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*, weight};
23use frame_support::BoundedVec;23use frame_support::BoundedVec;
24use up_data_structs::{TokenId, SchemaVersion};24use up_data_structs::{TokenId, SchemaVersion, PropertyPermission, PropertyKeyPermission, Property};
25use pallet_evm_coder_substrate::dispatch_to_evm;25use pallet_evm_coder_substrate::dispatch_to_evm;
26use sp_core::{H160, U256};26use sp_core::{H160, U256};
27use sp_std::{vec::Vec, vec};27use sp_std::vec::Vec;
28use pallet_common::{28use pallet_common::{
29	erc::{CommonEvmHandler, PrecompileResult, CollectionPropertiesCall},29	erc::{CommonEvmHandler, PrecompileResult, CollectionPropertiesCall},
30	CollectionHandle,30	CollectionHandle,
3535
36use crate::{36use crate::{
37	AccountBalance, Config, CreateItemData, NonfungibleHandle, Pallet, TokenData, TokensMinted,37	AccountBalance, Config, CreateItemData, NonfungibleHandle, Pallet, TokenData, TokensMinted,
38	SelfWeightOf, weights::WeightInfo,38	SelfWeightOf, weights::WeightInfo, TokenProperties,
39};39};
40
41#[solidity_interface(name = "TokenProperties")]
42impl<T: Config> NonfungibleHandle<T> {
43	fn set_token_property_permission(
44		&mut self,
45		caller: caller,
46		key: string,
47		is_mutable: bool,
48		collection_admin: bool,
49		token_owner: bool,
50	) -> Result<()> {
51		let caller = T::CrossAccountId::from_eth(caller);
52		<Pallet<T>>::set_property_permission(
53			self,
54			&caller,
55			PropertyKeyPermission {
56				key: <Vec<u8>>::from(key)
57					.try_into()
58					.map_err(|_| "too long key")?,
59				permission: PropertyPermission {
60					mutable: is_mutable,
61					collection_admin,
62					token_owner,
63				},
64			},
65		)
66		.map_err(dispatch_to_evm::<T>)
67	}
68
69	fn set_property(
70		&mut self,
71		caller: caller,
72		token_id: uint256,
73		key: string,
74		value: bytes,
75	) -> Result<()> {
76		let caller = T::CrossAccountId::from_eth(caller);
77		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
78		let key = <Vec<u8>>::from(key)
79			.try_into()
80			.map_err(|_| "key too long")?;
81		let value = value.try_into().map_err(|_| "value too long")?;
82
83		<Pallet<T>>::set_token_property(self, &caller, TokenId(token_id), Property { key, value })
84			.map_err(dispatch_to_evm::<T>)
85	}
86
87	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {
88		let caller = T::CrossAccountId::from_eth(caller);
89		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
90		let key = <Vec<u8>>::from(key)
91			.try_into()
92			.map_err(|_| "key too long")?;
93
94		<Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key)
95			.map_err(dispatch_to_evm::<T>)
96	}
97
98	/// Throws error if key not found
99	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {
100		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
101		let key = <Vec<u8>>::from(key)
102			.try_into()
103			.map_err(|_| "key too long")?;
104
105		let props = <TokenProperties<T>>::get((self.id, token_id));
106		let prop = props.get(&key).ok_or("key not found")?;
107
108		Ok(prop.to_vec())
109	}
110}
40111
41fn error_unsupported_schema_version() -> Error {112fn error_unsupported_schema_version() -> Error {
42	alloc::format!(113	alloc::format!(
274			&caller,345			&caller,
275			CreateItemData::<T> {346			CreateItemData::<T> {
276				const_data: BoundedVec::default(),347				const_data: BoundedVec::default(),
277				variable_data: BoundedVec::default(),
278				properties: BoundedVec::default(),348				properties: BoundedVec::default(),
279				owner: to,349				owner: to,
280			},350			},
322				const_data: Vec::<u8>::from(token_uri)392				const_data: Vec::<u8>::from(token_uri)
323					.try_into()393					.try_into()
324					.map_err(|_| "token uri is too long")?,394					.map_err(|_| "token uri is too long")?,
325				variable_data: BoundedVec::default(),
326				properties: BoundedVec::default(),395				properties: BoundedVec::default(),
327				owner: to,396				owner: to,
328			},397			},
387			.into())456			.into())
388	}457	}
389
390	#[weight(<SelfWeightOf<T>>::set_variable_metadata(data.len() as u32))]
391	fn set_variable_metadata(
392		&mut self,
393		caller: caller,
394		token_id: uint256,
395		data: bytes,
396	) -> Result<void> {
397		let caller = T::CrossAccountId::from_eth(caller);
398		let token = token_id.try_into()?;
399
400		<Pallet<T>>::set_variable_metadata(
401			self,
402			&caller,
403			token,
404			data.try_into()
405				.map_err(|_| "metadata size exceeded limit")?,
406		)
407		.map_err(dispatch_to_evm::<T>)?;
408		Ok(())
409	}
410
411	fn get_variable_metadata(&self, token_id: uint256) -> Result<bytes> {
412		self.consume_store_reads(1)?;
413		let token: TokenId = token_id.try_into()?;
414
415		Ok(<TokenData<T>>::get((self.id, token))
416			.ok_or("token not found")?
417			.variable_data
418			.into_inner())
419	}
420458
421	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]459	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]
422	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {460	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {
440		let data = (0..total_tokens)478		let data = (0..total_tokens)
441			.map(|_| CreateItemData::<T> {479			.map(|_| CreateItemData::<T> {
442				const_data: BoundedVec::default(),480				const_data: BoundedVec::default(),
443				variable_data: BoundedVec::default(),
444				properties: BoundedVec::default(),481				properties: BoundedVec::default(),
445				owner: to.clone(),482				owner: to.clone(),
446			})483			})
484				const_data: Vec::<u8>::from(token_uri)521				const_data: Vec::<u8>::from(token_uri)
485					.try_into()522					.try_into()
486					.map_err(|_| "token uri is too long")?,523					.map_err(|_| "token uri is too long")?,
487				variable_data: vec![].try_into().unwrap(),
488				properties: BoundedVec::default(),524				properties: BoundedVec::default(),
489				owner: to.clone(),525				owner: to.clone(),
490			});526			});
505		ERC721UniqueExtensions,541		ERC721UniqueExtensions,
506		ERC721Mintable,542		ERC721Mintable,
507		ERC721Burnable,543		ERC721Burnable,
508		via("CollectionHandle<T>", common_mut, CollectionProperties)544		via("CollectionHandle<T>", common_mut, CollectionProperties),
545		TokenProperties,
509	)546	)
510)]547)]
511impl<T: Config> NonfungibleHandle<T> {}548impl<T: Config> NonfungibleHandle<T> {}