git.delta.rocks / unique-network / refs/commits / 6d28dd8067cd

2274 "hash256-std-hasher",2274 "hash256-std-hasher",
2275 "rlp",2275 "rlp",
2276 "rlp-derive",2276 "rlp-derive",
2277 "sha3",2277 "sha3 0.10.6",
2278 "triehash",2278 "triehash",
2279]2279]
22802280
2292 "rlp",2292 "rlp",
2293 "scale-info",2293 "scale-info",
2294 "serde",2294 "serde",
2295 "sha3",2295 "sha3 0.10.6",
2296 "triehash",2296 "triehash",
2297]2297]
22982298
2350 "rlp",2350 "rlp",
2351 "scale-info",2351 "scale-info",
2352 "serde",2352 "serde",
2353 "sha3",2353 "sha3 0.10.6",
2354]2354]
23552355
2356[[package]]2356[[package]]
2380 "hex",2380 "hex",
2381 "proc-macro2",2381 "proc-macro2",
2382 "quote",2382 "quote",
2383 "sha3",2383 "sha3 0.10.6",
2384 "syn",2384 "syn",
2385]2385]
23862386
2415 "environmental",2415 "environmental",
2416 "evm-core",2416 "evm-core",
2417 "primitive-types 0.12.1",2417 "primitive-types 0.12.1",
2418 "sha3",2418 "sha3 0.10.6",
2419]2419]
24202420
2421[[package]]2421[[package]]
4958 "digest 0.10.6",4958 "digest 0.10.6",
4959 "multihash-derive",4959 "multihash-derive",
4960 "sha2 0.10.6",4960 "sha2 0.10.6",
4961 "sha3",4961 "sha3 0.10.6",
4962 "unsigned-varint",4962 "unsigned-varint",
4963]4963]
49644964
5280 "cumulus-primitives-utility",5280 "cumulus-primitives-utility",
5281 "derivative",5281 "derivative",
5282 "evm-coder",5282 "evm-coder",
5283 "fp-evm",
5283 "fp-evm-mapping",5284 "fp-evm-mapping",
5284 "fp-rpc",5285 "fp-rpc",
5285 "fp-self-contained",5286 "fp-self-contained",
5294 "impl-trait-for-tuples",5295 "impl-trait-for-tuples",
5295 "log",5296 "log",
5296 "logtest",5297 "logtest",
5298 "num_enum",
5297 "orml-tokens",5299 "orml-tokens",
5298 "orml-traits",5300 "orml-traits",
5299 "orml-vesting",5301 "orml-vesting",
5309 "pallet-evm-coder-substrate",5311 "pallet-evm-coder-substrate",
5310 "pallet-evm-contract-helpers",5312 "pallet-evm-contract-helpers",
5311 "pallet-evm-migration",5313 "pallet-evm-migration",
5314 "pallet-evm-precompile-simple",
5312 "pallet-evm-transaction-payment",5315 "pallet-evm-transaction-payment",
5313 "pallet-foreign-assets",5316 "pallet-foreign-assets",
5314 "pallet-fungible",5317 "pallet-fungible",
5333 "parachain-info",5336 "parachain-info",
5334 "parity-scale-codec 3.2.1",5337 "parity-scale-codec 3.2.1",
5335 "polkadot-parachain",5338 "polkadot-parachain",
5339 "precompile-utils-macro",
5336 "rmrk-rpc",5340 "rmrk-rpc",
5337 "scale-info",5341 "scale-info",
5338 "serde",5342 "serde",
6004 "sp-std",6008 "sp-std",
6005]6009]
6010
6011[[package]]
6012name = "pallet-evm-precompile-simple"
6013version = "2.0.0-dev"
6014source = "git+https://github.com/uniquenetwork/frontier?branch=unique-polkadot-v0.9.33#c37ced433a29baad45899d6ab364fe437f97570e"
6015dependencies = [
6016 "fp-evm",
6017 "ripemd",
6018 "sp-io",
6019]
60066020
6007[[package]]6021[[package]]
6008name = "pallet-evm-transaction-payment"6022name = "pallet-evm-transaction-payment"
63286342
6329[[package]]6343[[package]]
6330name = "pallet-nonfungible"6344name = "pallet-nonfungible"
6331version = "0.1.9"6345version = "0.1.11"
6332dependencies = [6346dependencies = [
6333 "ethereum 0.14.0",6347 "ethereum 0.14.0",
6334 "evm-coder",6348 "evm-coder",
64876501
6488[[package]]6502[[package]]
6489name = "pallet-refungible"6503name = "pallet-refungible"
6490version = "0.2.8"6504version = "0.2.10"
6491dependencies = [6505dependencies = [
6492 "derivative",6506 "derivative",
6493 "ethereum 0.14.0",6507 "ethereum 0.14.0",
8594source = "registry+https://github.com/rust-lang/crates.io-index"8608source = "registry+https://github.com/rust-lang/crates.io-index"
8595checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"8609checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
8610
8611[[package]]
8612name = "precompile-utils-macro"
8613version = "0.1.0"
8614dependencies = [
8615 "num_enum",
8616 "proc-macro2",
8617 "quote",
8618 "sha3 0.8.2",
8619 "syn",
8620]
85968621
8597[[package]]8622[[package]]
8598name = "predicates"8623name = "predicates"
8850 "cumulus-primitives-utility",8875 "cumulus-primitives-utility",
8851 "derivative",8876 "derivative",
8852 "evm-coder",8877 "evm-coder",
8878 "fp-evm",
8853 "fp-evm-mapping",8879 "fp-evm-mapping",
8854 "fp-rpc",8880 "fp-rpc",
8855 "fp-self-contained",8881 "fp-self-contained",
8864 "impl-trait-for-tuples",8890 "impl-trait-for-tuples",
8865 "log",8891 "log",
8866 "logtest",8892 "logtest",
8893 "num_enum",
8867 "orml-tokens",8894 "orml-tokens",
8868 "orml-traits",8895 "orml-traits",
8869 "orml-vesting",8896 "orml-vesting",
8879 "pallet-evm-coder-substrate",8906 "pallet-evm-coder-substrate",
8880 "pallet-evm-contract-helpers",8907 "pallet-evm-contract-helpers",
8881 "pallet-evm-migration",8908 "pallet-evm-migration",
8909 "pallet-evm-precompile-simple",
8882 "pallet-evm-transaction-payment",8910 "pallet-evm-transaction-payment",
8883 "pallet-foreign-assets",8911 "pallet-foreign-assets",
8884 "pallet-fungible",8912 "pallet-fungible",
8901 "parachain-info",8929 "parachain-info",
8902 "parity-scale-codec 3.2.1",8930 "parity-scale-codec 3.2.1",
8903 "polkadot-parachain",8931 "polkadot-parachain",
8932 "precompile-utils-macro",
8904 "rmrk-rpc",8933 "rmrk-rpc",
8905 "scale-info",8934 "scale-info",
8906 "serde",8935 "serde",
9248 "winapi",9277 "winapi",
9249]9278]
9279
9280[[package]]
9281name = "ripemd"
9282version = "0.1.3"
9283source = "registry+https://github.com/rust-lang/crates.io-index"
9284checksum = "bd124222d17ad93a644ed9d011a40f4fb64aa54275c08cc216524a9ea82fb09f"
9285dependencies = [
9286 "digest 0.10.6",
9287]
92509288
9251[[package]]9289[[package]]
9252name = "rlp"9290name = "rlp"
10959 "digest 0.10.6",10997 "digest 0.10.6",
10960]10998]
10999
11000[[package]]
11001name = "sha3"
11002version = "0.8.2"
11003source = "registry+https://github.com/rust-lang/crates.io-index"
11004checksum = "dd26bc0e7a2e3a7c959bc494caf58b72ee0c71d67704e9520f736ca7e4853ecf"
11005dependencies = [
11006 "block-buffer 0.7.3",
11007 "byte-tools",
11008 "digest 0.8.1",
11009 "keccak",
11010 "opaque-debug 0.2.3",
11011]
1096111012
10962[[package]]11013[[package]]
10963name = "sha3"11014name = "sha3"
11396 "byteorder",11447 "byteorder",
11397 "digest 0.10.6",11448 "digest 0.10.6",
11398 "sha2 0.10.6",11449 "sha2 0.10.6",
11399 "sha3",11450 "sha3 0.10.6",
11400 "sp-std",11451 "sp-std",
11401 "twox-hash",11452 "twox-hash",
11402]11453]
13026 "cumulus-primitives-utility",13077 "cumulus-primitives-utility",
13027 "derivative",13078 "derivative",
13028 "evm-coder",13079 "evm-coder",
13080 "fp-evm",
13029 "fp-evm-mapping",13081 "fp-evm-mapping",
13030 "fp-rpc",13082 "fp-rpc",
13031 "fp-self-contained",13083 "fp-self-contained",
13040 "impl-trait-for-tuples",13092 "impl-trait-for-tuples",
13041 "log",13093 "log",
13042 "logtest",13094 "logtest",
13095 "num_enum",
13043 "orml-tokens",13096 "orml-tokens",
13044 "orml-traits",13097 "orml-traits",
13045 "orml-vesting",13098 "orml-vesting",
13055 "pallet-evm-coder-substrate",13108 "pallet-evm-coder-substrate",
13056 "pallet-evm-contract-helpers",13109 "pallet-evm-contract-helpers",
13057 "pallet-evm-migration",13110 "pallet-evm-migration",
13111 "pallet-evm-precompile-simple",
13058 "pallet-evm-transaction-payment",13112 "pallet-evm-transaction-payment",
13059 "pallet-foreign-assets",13113 "pallet-foreign-assets",
13060 "pallet-fungible",13114 "pallet-fungible",
13077 "parachain-info",13131 "parachain-info",
13078 "parity-scale-codec 3.2.1",13132 "parity-scale-codec 3.2.1",
13079 "polkadot-parachain",13133 "polkadot-parachain",
13134 "precompile-utils-macro",
13080 "rmrk-rpc",13135 "rmrk-rpc",
13081 "scale-info",13136 "scale-info",
13082 "serde",13137 "serde",

740	/// Some docs740	/// Some docs
741	/// At multi741	/// At multi
742	/// line742	/// line
743	#[derive(AbiCoder, Debug, PartialEq, Default)]743	#[derive(AbiCoder, Debug, PartialEq, Default, Clone, Copy)]
744	#[repr(u8)]744	#[repr(u8)]
745	enum Color {745	enum Color {
746		/// Docs for Red746		/// Docs for Red

564		/// # Arguments564		/// # Arguments
565		///565		///
566		/// * `stakers_number`: the number of stakers for which recalculation will be performed566		/// * `stakers_number`: the number of stakers for which recalculation will be performed
567		#[pallet::weight(<T as Config>::WeightInfo::payout_stakers(stakers_number.unwrap_or(20) as u32))]567		#[pallet::weight(<T as Config>::WeightInfo::payout_stakers(stakers_number.unwrap_or(DEFAULT_NUMBER_PAYOUTS) as u32))]
568		pub fn payout_stakers(admin: OriginFor<T>, stakers_number: Option<u8>) -> DispatchResult {568		pub fn payout_stakers(admin: OriginFor<T>, stakers_number: Option<u8>) -> DispatchResult {
569			let admin_id = ensure_signed(admin)?;569			let admin_id = ensure_signed(admin)?;
570570

163	TokenOwner,163	TokenOwner,
164}164}
165
166/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) fields as an enumeration.
167#[derive(AbiCoder, Copy, Clone, Default, Debug)]
168#[repr(u8)]
169pub enum EthTokenPermissions {
170	/// Permission to change the property and property permission. See [`up_data_structs::PropertyPermission::mutable`]
171	#[default]
172	Mutable,
173
174	/// Change permission for the collection administrator. See [`up_data_structs::PropertyPermission::token_owner`]
175	TokenOwner,
176
177	/// Permission to change the property for the owner of the token. See [`up_data_structs::PropertyPermission::collection_admin`]
178	CollectionAdmin,
179}
165180

1222		Ok(())1222		Ok(())
1223	}1223	}
12241224
1225	/// Set scouped collection property.1225	/// Set a scoped collection property, where the scope is a special prefix
1226	/// prohibiting a user to change the property.
1226	///1227	///
1227	/// * `collection_id` - ID of the collection for which the property is being set.1228	/// * `collection_id` - ID of the collection for which the property is being set.
1228	/// * `scope` - Property scope.1229	/// * `scope` - Property scope.
1240		Ok(())1241		Ok(())
1241	}1242	}
12421243
1243	/// Set scouped collection properties.1244	/// Set scoped collection properties, where the scope is a special prefix
1245	/// prohibiting a user to change the properties.
1244	///1246	///
1245	/// * `collection_id` - ID of the collection for which the properties is being set.1247	/// * `collection_id` - ID of the collection for which the properties is being set.
1246	/// * `scope` - Property scope.1248	/// * `scope` - Property scope.

52		type DefaultMinGasPrice: Get<u64>;52		type DefaultMinGasPrice: Get<u64>;
5353
54		#[pallet::constant]54		#[pallet::constant]
55		type MaxOverridedAllowedLocations: Get<u32>;55		type MaxXcmAllowedLocations: Get<u32>;
56		#[pallet::constant]56		#[pallet::constant]
57		type AppPromotionDailyRate: Get<Perbill>;57		type AppPromotionDailyRate: Get<Perbill>;
58		#[pallet::constant]58		#[pallet::constant]
7777
78	#[pallet::storage]78	#[pallet::storage]
79	pub type XcmAllowedLocationsOverride<T: Config> = StorageValue<79	pub type XcmAllowedLocationsOverride<T: Config> = StorageValue<
80		Value = BoundedVec<MultiLocation, T::MaxOverridedAllowedLocations>,80		Value = BoundedVec<MultiLocation, T::MaxXcmAllowedLocations>,
81		QueryKind = OptionQuery,81		QueryKind = OptionQuery,
82	>;82	>;
8383
118		#[pallet::weight(T::DbWeight::get().writes(1))]118		#[pallet::weight(T::DbWeight::get().writes(1))]
119		pub fn set_xcm_allowed_locations(119		pub fn set_xcm_allowed_locations(
120			origin: OriginFor<T>,120			origin: OriginFor<T>,
121			locations: Option<BoundedVec<MultiLocation, T::MaxOverridedAllowedLocations>>,121			locations: Option<BoundedVec<MultiLocation, T::MaxXcmAllowedLocations>>,
122		) -> DispatchResult {122		) -> DispatchResult {
123			ensure_root(origin)?;123			ensure_root(origin)?;
124			<XcmAllowedLocationsOverride<T>>::set(locations);124			<XcmAllowedLocationsOverride<T>>::set(locations);

19use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight, traits::Get};19use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight, traits::Get};
20use up_data_structs::{TokenId, CollectionId, CreateItemExData, budget::Budget, CreateItemData};20use up_data_structs::{TokenId, CollectionId, CreateItemExData, budget::Budget, CreateItemData};
21use pallet_common::{CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions, with_weight};21use pallet_common::{
22	CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions, with_weight,
23	weights::WeightInfo as _,
24};
22use pallet_structure::Error as StructureError;25use pallet_structure::Error as StructureError;
23use sp_runtime::ArithmeticError;26use sp_runtime::ArithmeticError;
53		<SelfWeightOf<T>>::burn_item()56		<SelfWeightOf<T>>::burn_item()
54	}57	}
5558
56	fn set_collection_properties(_amount: u32) -> Weight {59	fn set_collection_properties(amount: u32) -> Weight {
57		// Error
58		Weight::zero()60		<pallet_common::SelfWeightOf<T>>::set_collection_properties(amount)
59	}61	}
6062
61	fn delete_collection_properties(_amount: u32) -> Weight {63	fn delete_collection_properties(amount: u32) -> Weight {
62		// Error
63		Weight::zero()64		<pallet_common::SelfWeightOf<T>>::delete_collection_properties(amount)
64	}65	}
6566
66	fn set_token_properties(_amount: u32) -> Weight {67	fn set_token_properties(_amount: u32) -> Weight {
294295
295	fn set_collection_properties(296	fn set_collection_properties(
296		&self,297		&self,
297		_sender: T::CrossAccountId,298		sender: T::CrossAccountId,
298		_property: Vec<Property>,299		properties: Vec<Property>,
299	) -> DispatchResultWithPostInfo {300	) -> DispatchResultWithPostInfo {
301		let weight = <CommonWeights<T>>::set_collection_properties(properties.len() as u32);
302
300		fail!(<Error<T>>::SettingPropertiesNotAllowed)303		with_weight(
304			<Pallet<T>>::set_collection_properties(self, &sender, properties),
305			weight,
306		)
301	}307	}
302308
303	fn delete_collection_properties(309	fn delete_collection_properties(
304		&self,310		&self,
305		_sender: &T::CrossAccountId,311		sender: &T::CrossAccountId,
306		_property_keys: Vec<PropertyKey>,312		property_keys: Vec<PropertyKey>,
307	) -> DispatchResultWithPostInfo {313	) -> DispatchResultWithPostInfo {
314		let weight = <CommonWeights<T>>::delete_collection_properties(property_keys.len() as u32);
315
308		fail!(<Error<T>>::SettingPropertiesNotAllowed)316		with_weight(
317			<Pallet<T>>::delete_collection_properties(self, sender, property_keys),
318			weight,
319		)
309	}320	}
310321

8080
81use core::ops::Deref;81use core::ops::Deref;
82use evm_coder::ToLog;82use evm_coder::ToLog;
83use frame_support::{ensure};83use frame_support::ensure;
84use pallet_evm::account::CrossAccountId;84use pallet_evm::account::CrossAccountId;
85use up_data_structs::{85use up_data_structs::{
86	AccessMode, CollectionId, CollectionFlags, TokenId, CreateCollectionData,86	AccessMode, CollectionId, CollectionFlags, TokenId, CreateCollectionData,
87	mapping::TokenAddressMapping, budget::Budget,87	mapping::TokenAddressMapping, budget::Budget, PropertyKey, Property,
88};88};
89use pallet_common::{89use pallet_common::{
90	Error as CommonError, Event as CommonEvent, Pallet as PalletCommon,90	Error as CommonError, Event as CommonEvent, Pallet as PalletCommon,
260		Ok(())260		Ok(())
261	}261	}
262
263	/// Add properties to the collection.
264	pub fn set_collection_properties(
265		collection: &FungibleHandle<T>,
266		sender: &T::CrossAccountId,
267		properties: Vec<Property>,
268	) -> DispatchResult {
269		<PalletCommon<T>>::set_collection_properties(collection, sender, properties)
270	}
271
272	/// Delete properties of the collection, associated with the provided keys.
273	pub fn delete_collection_properties(
274		collection: &FungibleHandle<T>,
275		sender: &T::CrossAccountId,
276		property_keys: Vec<PropertyKey>,
277	) -> DispatchResult {
278		<PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)
279	}
262280
263	///Checks if collection has tokens. Return `true` if it has.281	/// Checks if collection has tokens. Return `true` if it has.
264	fn collection_has_tokens(collection_id: CollectionId) -> bool {282	fn collection_has_tokens(collection_id: CollectionId) -> bool {
265		<TotalSupply<T>>::get(collection_id) != 0283		<TotalSupply<T>>::get(collection_id) != 0
266	}284	}

44
5<!-- bureaucrate goes here -->5<!-- bureaucrate goes here -->
66
7## [0.1.11] - 2022-12-16
8
9### Added
10
11- The function `tokenPropertyPermissions` and `setTokenPropertyPermissions` to `TokenProperties` interface.
12
13### Changed
14
15- Hide `setTokenPropertyPermission` function in `TokenProperties` interface.
16
7## [0.1.10] - 2022-11-1817## [0.1.10] - 2022-11-18
818
9### Added19### Added

1[package]1[package]
2name = "pallet-nonfungible"2name = "pallet-nonfungible"
3version = "0.1.9"3version = "0.1.11"
4license = "GPLv3"4license = "GPLv3"
5edition = "2021"5edition = "2021"
66

34	CollectionPropertiesVec,34	CollectionPropertiesVec,
35};35};
36use pallet_evm_coder_substrate::dispatch_to_evm;36use pallet_evm_coder_substrate::dispatch_to_evm;
37use sp_std::vec::Vec;37use sp_std::{vec::Vec, vec};
38use pallet_common::{38use pallet_common::{
39	CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations,39	CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations,
40	erc::{CommonEvmHandler, PrecompileResult, CollectionCall, static_property::key},40	erc::{CommonEvmHandler, PrecompileResult, CollectionCall, static_property::key},
41	eth::EthCrossAccount,41	eth::{EthCrossAccount, EthTokenPermissions},
42};42};
43use pallet_evm::{account::CrossAccountId, PrecompileHandle};43use pallet_evm::{account::CrossAccountId, PrecompileHandle};
44use pallet_evm_coder_substrate::call;44use pallet_evm_coder_substrate::call;
60	/// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.60	/// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.
61	/// @param tokenOwner Permission to mutate property by token owner if property is mutable.61	/// @param tokenOwner Permission to mutate property by token owner if property is mutable.
62	#[weight(<SelfWeightOf<T>>::set_token_property_permissions(1))]62	#[weight(<SelfWeightOf<T>>::set_token_property_permissions(1))]
63	#[solidity(hide)]
63	fn set_token_property_permission(64	fn set_token_property_permission(
64		&mut self,65		&mut self,
65		caller: caller,66		caller: caller,
69		token_owner: bool,70		token_owner: bool,
70	) -> Result<()> {71	) -> Result<()> {
71		let caller = T::CrossAccountId::from_eth(caller);72		let caller = T::CrossAccountId::from_eth(caller);
72		<Pallet<T>>::set_property_permission(73		<Pallet<T>>::set_token_property_permissions(
73			self,74			self,
74			&caller,75			&caller,
75			PropertyKeyPermission {76			vec![PropertyKeyPermission {
76				key: <Vec<u8>>::from(key)77				key: <Vec<u8>>::from(key)
77					.try_into()78					.try_into()
78					.map_err(|_| "too long key")?,79					.map_err(|_| "too long key")?,
79				permission: PropertyPermission {80				permission: PropertyPermission {
80					mutable: is_mutable,81					mutable: is_mutable,
81					collection_admin,82					collection_admin,
82					token_owner,83					token_owner,
83				},84				},
84			},85			}],
85		)86		)
86		.map_err(dispatch_to_evm::<T>)87		.map_err(dispatch_to_evm::<T>)
87	}88	}
89
90	/// @notice Set permissions for token property.
91	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.
92	/// @param permissions Permissions for keys.
93	#[weight(<SelfWeightOf<T>>::set_token_property_permissions(permissions.len() as u32))]
94	fn set_token_property_permissions(
95		&mut self,
96		caller: caller,
97		permissions: Vec<(string, Vec<(EthTokenPermissions, bool)>)>,
98	) -> Result<()> {
99		let caller = T::CrossAccountId::from_eth(caller);
100		const PERMISSIONS_FIELDS_COUNT: usize = 3;
101
102		let mut perms = Vec::new();
103
104		for (key, pp) in permissions {
105			if pp.len() > PERMISSIONS_FIELDS_COUNT {
106				return Err(alloc::format!(
107					"Actual number of fields {} for {}, which exceeds the maximum value of {}",
108					pp.len(),
109					stringify!(EthTokenPermissions),
110					PERMISSIONS_FIELDS_COUNT
111				)
112				.as_str()
113				.into());
114			}
115
116			let mut token_permission = PropertyPermission::default();
117
118			for (perm, value) in pp {
119				match perm {
120					EthTokenPermissions::Mutable => token_permission.mutable = value,
121					EthTokenPermissions::TokenOwner => token_permission.token_owner = value,
122					EthTokenPermissions::CollectionAdmin => {
123						token_permission.collection_admin = value
124					}
125				}
126			}
127
128			perms.push(PropertyKeyPermission {
129				key: key.into_bytes().try_into().map_err(|_| "too long key")?,
130				permission: token_permission,
131			});
132		}
133
134		<Pallet<T>>::set_token_property_permissions(self, &caller, perms)
135			.map_err(dispatch_to_evm::<T>)
136	}
137
138	/// @notice Get permissions for token properties.
139	fn token_property_permissions(
140		&self,
141	) -> Result<Vec<(string, Vec<(EthTokenPermissions, bool)>)>> {
142		let perms = <Pallet<T>>::token_property_permission(self.id);
143		Ok(perms
144			.into_iter()
145			.map(|(key, pp)| {
146				let key = string::from_utf8(key.into_inner()).expect("Stored key must be valid");
147				let pp = vec![
148					(EthTokenPermissions::Mutable, pp.mutable),
149					(EthTokenPermissions::TokenOwner, pp.token_owner),
150					(EthTokenPermissions::CollectionAdmin, pp.collection_admin),
151				];
152				(key, pp)
153			})
154			.collect())
155	}
88156
89	/// @notice Set token property value.157	/// @notice Set token property value.
90	/// @dev Throws error if `msg.sender` has no permission to edit the property.158	/// @dev Throws error if `msg.sender` has no permission to edit the property.

103	AccessMode, CollectionId, CollectionFlags, CustomDataLimit, TokenId, CreateCollectionData,103	AccessMode, CollectionId, CollectionFlags, CustomDataLimit, TokenId, CreateCollectionData,
104	CreateNftExData, mapping::TokenAddressMapping, budget::Budget, Property, PropertyPermission,104	CreateNftExData, mapping::TokenAddressMapping, budget::Budget, Property, PropertyPermission,
105	PropertyKey, PropertyValue, PropertyKeyPermission, Properties, PropertyScope, TrySetProperty,105	PropertyKey, PropertyValue, PropertyKeyPermission, Properties, PropertyScope, TrySetProperty,
106	TokenChild, AuxPropertyValue,106	TokenChild, AuxPropertyValue, PropertiesPermissionMap,
107};107};
108use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};108use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};
109use pallet_common::{109use pallet_common::{
824		)824		)
825	}825	}
826826
827	/// Set property permissions for the collection.
828	///
829	/// Sender should be the owner or admin of the collection.
830	pub fn set_property_permission(827	pub fn token_property_permission(collection_id: CollectionId) -> PropertiesPermissionMap {
831		collection: &CollectionHandle<T>,
832		sender: &T::CrossAccountId,
833		permission: PropertyKeyPermission,
834	) -> DispatchResult {
835		<PalletCommon<T>>::set_property_permission(collection, sender, permission)828		<PalletCommon<T>>::property_permissions(collection_id)
836	}829	}
837830
838	pub fn check_token_immediate_ownership(831	pub fn check_token_immediate_ownership(

18}18}
1919
20/// @title A contract that allows to set and delete token properties and change token property permissions.20/// @title A contract that allows to set and delete token properties and change token property permissions.
21/// @dev the ERC-165 identifier for this interface is 0x91a97a6821/// @dev the ERC-165 identifier for this interface is 0xde0695c2
22contract TokenProperties is Dummy, ERC165 {22contract TokenProperties is Dummy, ERC165 {
23	// /// @notice Set permissions for token property.
24	// /// @dev Throws error if `msg.sender` is not admin or owner of the collection.
25	// /// @param key Property key.
26	// /// @param isMutable Permission to mutate property.
27	// /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.
28	// /// @param tokenOwner Permission to mutate property by token owner if property is mutable.
29	// /// @dev EVM selector for this function is: 0x222d97fa,
30	// ///  or in textual repr: setTokenPropertyPermission(string,bool,bool,bool)
31	// function setTokenPropertyPermission(string memory key, bool isMutable, bool collectionAdmin, bool tokenOwner) public {
32	// 	require(false, stub_error);
33	// 	key;
34	// 	isMutable;
35	// 	collectionAdmin;
36	// 	tokenOwner;
37	// 	dummy = 0;
38	// }
39
23	/// @notice Set permissions for token property.40	/// @notice Set permissions for token property.
24	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.41	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.
25	/// @param key Property key.42	/// @param permissions Permissions for keys.
26	/// @param isMutable Permission to mutate property.
27	/// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.
28	/// @param tokenOwner Permission to mutate property by token owner if property is mutable.
29	/// @dev EVM selector for this function is: 0x222d97fa,43	/// @dev EVM selector for this function is: 0xbd92983a,
30	///  or in textual repr: setTokenPropertyPermission(string,bool,bool,bool)44	///  or in textual repr: setTokenPropertyPermissions((string,(uint8,bool)[])[])
31	function setTokenPropertyPermission(45	function setTokenPropertyPermissions(Tuple48[] memory permissions) public {
32		string memory key,
33		bool isMutable,
34		bool collectionAdmin,
35		bool tokenOwner
36	) public {
37		require(false, stub_error);46		require(false, stub_error);
38		key;47		permissions;
39		isMutable;
40		collectionAdmin;
41		tokenOwner;
42		dummy = 0;48		dummy = 0;
43	}49	}
50
51	/// @dev EVM selector for this function is: 0xf23d7790,
52	///  or in textual repr: tokenPropertyPermissions()
53	function tokenPropertyPermissions() public view returns (Tuple48[] memory) {
54		require(false, stub_error);
55		dummy;
56		return new Tuple48[](0);
57	}
4458
45	// /// @notice Set token property value.59	// /// @notice Set token property value.
46	// /// @dev Throws error if `msg.sender` has no permission to edit the property.60	// /// @dev Throws error if `msg.sender` has no permission to edit the property.
118	bytes value;132	bytes value;
119}133}
134
135enum EthTokenPermissions {
136	Mutable,
137	TokenOwner,
138	CollectionAdmin
139}
140
141/// @dev anonymous struct
142struct Tuple48 {
143	string field_0;
144	Tuple46[] field_1;
145}
146
147/// @dev anonymous struct
148struct Tuple46 {
149	EthTokenPermissions field_0;
150	bool field_1;
151}
120152
121/// @title A contract that allows you to work with collections.153/// @title A contract that allows you to work with collections.
122/// @dev the ERC-165 identifier for this interface is 0xb5e1747f154/// @dev the ERC-165 identifier for this interface is 0xb5e1747f

44
5<!-- bureaucrate goes here -->5<!-- bureaucrate goes here -->
66
7## [0.2.10] - 2022-12-16
8
9### Added
10
11- The function `tokenPropertyPermissions` and `setTokenPropertyPermissions` to `TokenProperties` interface.
12
13### Changed
14
15- Hide `setTokenPropertyPermission` function in `TokenProperties` interface.
16
7## [0.2.9] - 2022-11-1817## [0.2.9] - 2022-11-18
818
9### Added19### Added

1[package]1[package]
2name = "pallet-refungible"2name = "pallet-refungible"
3version = "0.2.8"3version = "0.2.10"
4license = "GPLv3"4license = "GPLv3"
5edition = "2021"5edition = "2021"
66

33use pallet_common::{33use pallet_common::{
34	CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations,34	CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations,
35	erc::{CommonEvmHandler, CollectionCall, static_property::key},35	erc::{CommonEvmHandler, CollectionCall, static_property::key},
36	eth::EthCrossAccount,36	eth::{EthCrossAccount, EthTokenPermissions},
37	Error as CommonError,37	Error as CommonError,
38};38};
39use pallet_evm::{account::CrossAccountId, PrecompileHandle};39use pallet_evm::{account::CrossAccountId, PrecompileHandle};
63	/// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.63	/// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.
64	/// @param tokenOwner Permission to mutate property by token owner if property is mutable.64	/// @param tokenOwner Permission to mutate property by token owner if property is mutable.
65	#[weight(<SelfWeightOf<T>>::set_token_property_permissions(1))]65	#[weight(<SelfWeightOf<T>>::set_token_property_permissions(1))]
66	#[solidity(hide)]
66	fn set_token_property_permission(67	fn set_token_property_permission(
67		&mut self,68		&mut self,
68		caller: caller,69		caller: caller,
89		.map_err(dispatch_to_evm::<T>)90		.map_err(dispatch_to_evm::<T>)
90	}91	}
92
93	/// @notice Set permissions for token property.
94	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.
95	/// @param permissions Permissions for keys.
96	#[weight(<SelfWeightOf<T>>::set_token_property_permissions(permissions.len() as u32))]
97	fn set_token_property_permissions(
98		&mut self,
99		caller: caller,
100		permissions: Vec<(string, Vec<(EthTokenPermissions, bool)>)>,
101	) -> Result<()> {
102		let caller = T::CrossAccountId::from_eth(caller);
103		const PERMISSIONS_FIELDS_COUNT: usize = 3;
104
105		let mut perms = Vec::new();
106
107		for (key, pp) in permissions {
108			if pp.len() > PERMISSIONS_FIELDS_COUNT {
109				return Err(alloc::format!(
110					"Actual number of fields {} for {}, which exceeds the maximum value of {}",
111					pp.len(),
112					stringify!(EthTokenPermissions),
113					PERMISSIONS_FIELDS_COUNT
114				)
115				.as_str()
116				.into());
117			}
118
119			let mut token_permission = PropertyPermission {
120				mutable: false,
121				collection_admin: false,
122				token_owner: false,
123			};
124
125			for (perm, value) in pp {
126				match perm {
127					EthTokenPermissions::Mutable => token_permission.mutable = value,
128					EthTokenPermissions::TokenOwner => token_permission.token_owner = value,
129					EthTokenPermissions::CollectionAdmin => {
130						token_permission.collection_admin = value
131					}
132				}
133			}
134
135			perms.push(PropertyKeyPermission {
136				key: key.into_bytes().try_into().map_err(|_| "too long key")?,
137				permission: token_permission,
138			});
139		}
140
141		<Pallet<T>>::set_token_property_permissions(self, &caller, perms)
142			.map_err(dispatch_to_evm::<T>)
143	}
144
145	/// @notice Get permissions for token properties.
146	fn token_property_permissions(
147		&self,
148	) -> Result<Vec<(string, Vec<(EthTokenPermissions, bool)>)>> {
149		let perms = <Pallet<T>>::token_property_permission(self.id);
150		Ok(perms
151			.into_iter()
152			.map(|(key, pp)| {
153				let key = string::from_utf8(key.into_inner()).expect("Stored key must be valid");
154				let pp = vec![
155					(EthTokenPermissions::Mutable, pp.mutable),
156					(EthTokenPermissions::TokenOwner, pp.token_owner),
157					(EthTokenPermissions::CollectionAdmin, pp.collection_admin),
158				];
159				(key, pp)
160			})
161			.collect())
162	}
91163
92	/// @notice Set token property value.164	/// @notice Set token property value.
93	/// @dev Throws error if `msg.sender` has no permission to edit the property.165	/// @dev Throws error if `msg.sender` has no permission to edit the property.