git.delta.rocks / unique-network / refs/commits / 20ac01d2fe7c

26462646
2647[[package]]2647[[package]]
2648name = "evm-coder"2648name = "evm-coder"
2649version = "0.3.1"2649version = "0.3.6"
2650source = "git+https://github.com/uniquenetwork/evm-coder?tag=v0.3.1#21e61c627f71337d6b8a03899fe8de14bfbf67aa"2650source = "git+https://github.com/uniquenetwork/evm-coder?tag=v0.3.6#be59ae41a5d2ec9389bae22d54f81122b6ba55a4"
2651dependencies = [2651dependencies = [
2652 "ethereum",2652 "ethereum",
2653 "evm-coder-procedural",2653 "evm-coder-procedural",
26582658
2659[[package]]2659[[package]]
2660name = "evm-coder-procedural"2660name = "evm-coder-procedural"
2661version = "0.3.1"2661version = "0.3.6"
2662source = "git+https://github.com/uniquenetwork/evm-coder?tag=v0.3.1#21e61c627f71337d6b8a03899fe8de14bfbf67aa"2662source = "git+https://github.com/uniquenetwork/evm-coder?tag=v0.3.6#be59ae41a5d2ec9389bae22d54f81122b6ba55a4"
2663dependencies = [2663dependencies = [
2664 "Inflector",2664 "Inflector",
2665 "hex",2665 "hex",
6489name = "pallet-common"6489name = "pallet-common"
6490version = "0.1.14"6490version = "0.1.14"
6491dependencies = [6491dependencies = [
6492 "bondrewd",
6492 "ethereum",6493 "ethereum",
6493 "evm-coder",6494 "evm-coder",
6494 "frame-benchmarking",6495 "frame-benchmarking",
7530 "frame-benchmarking",7531 "frame-benchmarking",
7531 "frame-support",7532 "frame-support",
7532 "frame-system",7533 "frame-system",
7534 "log",
7533 "pallet-balances-adapter",7535 "pallet-balances-adapter",
7534 "pallet-common",7536 "pallet-common",
7535 "pallet-evm",7537 "pallet-evm",
14097dependencies = [14099dependencies = [
14098 "bondrewd",14100 "bondrewd",
14099 "derivative",14101 "derivative",
14102 "evm-coder",
14100 "frame-support",14103 "frame-support",
14101 "pallet-evm",14104 "pallet-evm",
14102 "parity-scale-codec",14105 "parity-scale-codec",

27[workspace.dependencies]27[workspace.dependencies]
28# Unique28# Unique
29app-promotion-rpc = { path = "primitives/app_promotion_rpc", default-features = false }29app-promotion-rpc = { path = "primitives/app_promotion_rpc", default-features = false }
30evm-coder = { git = "https://github.com/uniquenetwork/evm-coder", tag = "v0.3.1", default-features = false }30evm-coder = { git = "https://github.com/uniquenetwork/evm-coder", tag = "v0.3.6", default-features = false, features = ['bondrewd'] }
31pallet-app-promotion = { path = "pallets/app-promotion", default-features = false }31pallet-app-promotion = { path = "pallets/app-promotion", default-features = false }
32pallet-balances-adapter = { default-features = false, path = "pallets/balances-adapter" }32pallet-balances-adapter = { default-features = false, path = "pallets/balances-adapter" }
33pallet-charge-transaction = { package = "pallet-template-transaction-payment", default-features = false, git = "https://github.com/uniquenetwork/pallet-sponsoring", branch = "polkadot-v0.9.43" }33pallet-charge-transaction = { package = "pallet-template-transaction-payment", default-features = false, git = "https://github.com/uniquenetwork/pallet-sponsoring", branch = "polkadot-v0.9.43" }

1010
11scale-info = { workspace = true }11scale-info = { workspace = true }
1212
13bondrewd = { version = "0.1.14", features = ["derive"], default-features = false }
13ethereum = { workspace = true }14ethereum = { workspace = true }
14evm-coder = { workspace = true }15evm-coder = { workspace = true }
15frame-benchmarking = { workspace = true, optional = true }16frame-benchmarking = { workspace = true, optional = true }

21use pallet_evm::account::CrossAccountId;21use pallet_evm::account::CrossAccountId;
22use frame_benchmarking::{benchmarks, account};22use frame_benchmarking::{benchmarks, account};
23use up_data_structs::{23use up_data_structs::{
24	CollectionMode, CollectionFlags, CreateCollectionData, CollectionId, Property, PropertyKey,24	CollectionMode, CreateCollectionData, CollectionId, Property, PropertyKey, PropertyValue,
25	PropertyValue, CollectionPermissions, NestingPermissions, AccessMode,25	CollectionPermissions, NestingPermissions, AccessMode, MAX_COLLECTION_NAME_LENGTH,
26	MAX_COLLECTION_NAME_LENGTH, MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_TOKEN_PREFIX_LENGTH,26	MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_TOKEN_PREFIX_LENGTH, MAX_PROPERTIES_PER_ITEM,
27	MAX_PROPERTIES_PER_ITEM,
47		.unwrap()46		.unwrap()
48}47}
49pub fn create_var_data<const S: u32>(size: u32) -> BoundedVec<u8, ConstU32<S>> {48pub fn create_var_data<const S: u32>(size: u32) -> BoundedVec<u8, ConstU32<S>> {
50	assert!(49	assert!(size <= S, "size ({size}) should be less within bound ({S})",);
51		size <= S,
52		"size ({}) should be less within bound ({})",
53		size,
54		S
55	);
56	(0..size)50	(0..size)
57		.map(|v| (v & 0xff) as u8)51		.map(|v| (v & 0xff) as u8)
81	mode: CollectionMode,75	mode: CollectionMode,
82	handler: impl FnOnce(76	handler: impl FnOnce(
83		T::CrossAccountId,77		T::CrossAccountId,
84		CreateCollectionData<T::AccountId>,78		CreateCollectionData<T::CrossAccountId>,
85	) -> Result<CollectionId, DispatchError>,79	) -> Result<CollectionId, DispatchError>,
86	cast: impl FnOnce(CollectionHandle<T>) -> R,80	cast: impl FnOnce(CollectionHandle<T>) -> R,
87) -> Result<R, DispatchError> {81) -> Result<R, DispatchError> {
124	create_collection_raw(118	create_collection_raw(
125		owner,119		owner,
126		CollectionMode::NFT,120		CollectionMode::NFT,
127		|owner: T::CrossAccountId, data| {121		|owner: T::CrossAccountId, data| <Pallet<T>>::init_collection(owner.clone(), owner, data),
128			<Pallet<T>>::init_collection(owner.clone(), owner, data, CollectionFlags::default())
129		},
130		|h| h,122		|h| h,
131	)123	)
132}124}

9	traits::Get,9	traits::Get,
10};10};
11use sp_runtime::DispatchError;11use sp_runtime::DispatchError;
12use up_data_structs::{CollectionId, CreateCollectionData, CollectionFlags};12use up_data_structs::{CollectionId, CreateCollectionData};
1313
14use crate::{pallet::Config, CommonCollectionOperations};14use crate::{pallet::Config, CommonCollectionOperations};
1515
76	fn create(76	fn create(
77		sender: T::CrossAccountId,77		sender: T::CrossAccountId,
78		payer: T::CrossAccountId,78		payer: T::CrossAccountId,
79		data: CreateCollectionData<T::AccountId>,79		data: CreateCollectionData<T::CrossAccountId>,
80		flags: CollectionFlags,
81	) -> Result<CollectionId, DispatchError>;80	) -> Result<CollectionId, DispatchError>;
8281
83	/// Delete the collection.82	/// Delete the collection.

402		Ok(())402		Ok(())
403	}403	}
404
405	#[solidity(rename_selector = "setCollectionNesting")]
406	fn set_nesting(
407		&mut self,
408		caller: Caller,
409		collection_nesting_and_permissions: eth::CollectionNestingAndPermission,
410	) -> Result<()> {
411		self.consume_store_reads_and_writes(1, 1)?;
412
413		let caller = T::CrossAccountId::from_eth(caller);
414
415		let mut permissions = self.collection.permissions.clone();
416		let mut nesting = permissions.nesting().clone();
417
418		let bv = if !collection_nesting_and_permissions.restricted.is_empty() {
419			let mut bv = OwnerRestrictedSet::new();
420			for address in collection_nesting_and_permissions.restricted.iter() {
421				bv.try_insert(crate::eth::map_eth_to_id(address).ok_or_else(|| {
422					Error::Revert("Can't convert address into collection id".into())
423				})?)
424				.map_err(|_| "too many collections")?;
425			}
426			Some(bv)
427		} else {
428			None
429		};
430
431		nesting.token_owner = collection_nesting_and_permissions.token_owner;
432		nesting.collection_admin = collection_nesting_and_permissions.collection_admin;
433		nesting.restricted = bv;
434		permissions.nesting = Some(nesting);
435
436		<Pallet<T>>::update_permissions(&caller, self, permissions).map_err(dispatch_to_evm::<T>)
437	}
404438
405	/// Toggle accessibility of collection nesting.439	/// Toggle accessibility of collection nesting.
406	///440	///
407	/// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'441	/// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'
408	#[solidity(rename_selector = "setCollectionNesting")]442	#[solidity(hide, rename_selector = "setCollectionNesting")]
409	fn set_nesting_bool(&mut self, caller: Caller, enable: bool) -> Result<()> {443	fn set_nesting_bool(&mut self, caller: Caller, enable: bool) -> Result<()> {
410		self.consume_store_reads_and_writes(1, 1)?;444		self.consume_store_reads_and_writes(1, 1)?;
411445
424	///458	///
425	/// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'459	/// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'
426	/// @param collections Addresses of collections that will be available for nesting.460	/// @param collections Addresses of collections that will be available for nesting.
427	#[solidity(rename_selector = "setCollectionNesting")]461	#[solidity(hide, rename_selector = "setCollectionNesting")]
428	fn set_nesting(462	fn set_nesting_collection_ids(
429		&mut self,463		&mut self,
430		caller: Caller,464		caller: Caller,
431		enable: bool,465		enable: bool,
464		<Pallet<T>>::update_permissions(&caller, self, permissions).map_err(dispatch_to_evm::<T>)498		<Pallet<T>>::update_permissions(&caller, self, permissions).map_err(dispatch_to_evm::<T>)
465	}499	}
500
501	#[solidity(rename_selector = "collectionNesting")]
502	fn collection_nesting(&self) -> Result<eth::CollectionNestingAndPermission> {
503		let nesting = self.collection.permissions.nesting();
504
505		Ok(eth::CollectionNestingAndPermission::new(
506			nesting.token_owner,
507			nesting.collection_admin,
508			nesting
509				.restricted
510				.clone()
511				.map(|b| {
512					b.0.into_inner()
513						.iter()
514						.map(|id| crate::eth::collection_id_to_address(id.0.into()))
515						.collect()
516				})
517				.unwrap_or_default(),
518		))
519	}
466520
467	/// Returns nesting for a collection521	/// Returns nesting for a collection
468	#[solidity(rename_selector = "collectionNestingRestrictedCollectionIds")]522	#[solidity(hide, rename_selector = "collectionNestingRestrictedCollectionIds")]
469	fn collection_nesting_restricted_ids(&self) -> Result<eth::CollectionNesting> {523	fn collection_nesting_restricted_ids(&self) -> Result<eth::CollectionNesting> {
470		let nesting = self.collection.permissions.nesting();524		let nesting = self.collection.permissions.nesting();
471525
480	}534	}
481535
482	/// Returns permissions for a collection536	/// Returns permissions for a collection
537	#[solidity(hide)]
483	fn collection_nesting_permissions(&self) -> Result<Vec<eth::CollectionNestingPermission>> {538	fn collection_nesting_permissions(&self) -> Result<Vec<eth::CollectionNestingPermission>> {
484		let nesting = self.collection.permissions.nesting();539		let nesting = self.collection.permissions.nesting();
485		Ok(vec![540		Ok(vec![

24};24};
25pub use pallet_evm::{Config, account::CrossAccountId};25pub use pallet_evm::{Config, account::CrossAccountId};
26use sp_core::{H160, U256};26use sp_core::{H160, U256};
27use up_data_structs::CollectionId;27use up_data_structs::{CollectionId, CollectionFlags};
28use pallet_evm_coder_substrate::execution::Error;
2829
29// 0x17c4e6453Cc49AAAaEACA894e6D9683e00000001 - collection 130// 0x17c4e6453Cc49AAAaEACA894e6D9683e00000001 - collection 1
30// TODO: Unhardcode prefix31// TODO: Unhardcode prefix
105		}106		}
106	}107	}
108
109	/// Converts [`CrossAddress`] to `Option<CrossAccountId>`.
110	pub fn into_option_sub_cross_account<T>(&self) -> Result<Option<T::CrossAccountId>, Error>
111	where
112		T: pallet_evm::Config,
113		T::AccountId: From<[u8; 32]>,
114	{
115		if self.eth == Default::default() && self.sub == Default::default() {
116			Ok(None)
117		} else if self.eth == Default::default() {
118			Ok(Some(convert_uint256_to_cross_account::<T>(self.sub)))
119		} else if self.sub == Default::default() {
120			Ok(Some(T::CrossAccountId::from_eth(self.eth)))
121		} else {
122			Err(format!("All fields of cross account is non zeroed {:?}", self).into())
123		}
124	}
125
107	/// Converts [`CrossAddress`] to `CrossAccountId`.126	/// Converts [`CrossAddress`] to `CrossAccountId`.
108	pub fn into_sub_cross_account<T>(127	pub fn into_sub_cross_account<T>(&self) -> Result<T::CrossAccountId, Error>
109		&self,
110	) -> pallet_evm_coder_substrate::execution::Result<T::CrossAccountId>
111	where128	where
112		T: pallet_evm::Config,129		T: pallet_evm::Config,
113		T::AccountId: From<[u8; 32]>,130		T::AccountId: From<[u8; 32]>,
124	}141	}
125}142}
143
144/// Type of tokens in collection
145#[derive(AbiCoder, Copy, Clone, Default, Debug, PartialEq)]
146#[repr(u8)]
147pub enum CollectionMode {
148	/// Nonfungible
149	#[default]
150	Nonfungible,
151	/// Fungible
152	Fungible,
153	/// Refungible
154	Refungible,
155}
126156
127/// Ethereum representation of collection [`PropertyKey`](up_data_structs::PropertyKey) and [`PropertyValue`](up_data_structs::PropertyValue).157/// Ethereum representation of collection [`PropertyKey`](up_data_structs::PropertyKey) and [`PropertyValue`](up_data_structs::PropertyValue).
128#[derive(Debug, Default, AbiCoder)]158#[derive(Debug, Default, AbiCoder)]
144}174}
145175
146impl TryFrom<up_data_structs::Property> for Property {176impl TryFrom<up_data_structs::Property> for Property {
147	type Error = pallet_evm_coder_substrate::execution::Error;177	type Error = Error;
148178
149	fn try_from(from: up_data_structs::Property) -> Result<Self, Self::Error> {179	fn try_from(from: up_data_structs::Property) -> Result<Self, Self::Error> {
150		let key = evm_coder::types::String::from_utf8(from.key.into())180		let key = evm_coder::types::String::from_utf8(from.key.into())
155}185}
156186
157impl TryInto<up_data_structs::Property> for Property {187impl TryInto<up_data_structs::Property> for Property {
158	type Error = pallet_evm_coder_substrate::execution::Error;188	type Error = Error;
159189
160	fn try_into(self) -> Result<up_data_structs::Property, Self::Error> {190	fn try_into(self) -> Result<up_data_structs::Property, Self::Error> {
161		let key = <Vec<u8>>::from(self.key)191		let key = <Vec<u8>>::from(self.key)
208	value: Option<U256>,238	value: Option<U256>,
209}239}
210240
211impl CollectionLimit {241impl CollectionLimit {
212	/// Create [`CollectionLimit`] from field and value.242	/// Create [`CollectionLimit`] from field and value.
213	pub fn new(field: CollectionLimitField, value: Option<u32>) -> Self {243	pub fn new(field: CollectionLimitField, value: Option<u32>) -> Self {
214		Self {244		Self {
220	pub fn has_value(&self) -> bool {250	pub fn has_value(&self) -> bool {
221		self.value.is_some()251		self.value.is_some()
222	}252	}
223}253
224254	/// Set corresponding property in CollectionLimits struct
225impl TryInto<up_data_structs::CollectionLimits> for CollectionLimit {255	pub fn apply_limit(&self, limits: &mut up_data_structs::CollectionLimits) -> Result<(), Error> {
226	type Error = pallet_evm_coder_substrate::execution::Error;
227
228	fn try_into(self) -> Result<up_data_structs::CollectionLimits, Self::Error> {
229		let value = self256		let value = self
230			.value257			.value
231			.ok_or::<Self::Error>("can't convert `None` value to boolean".into())?;258			.ok_or::<Error>("can't convert `None` value to boolean".into())?;
232		let value = Some(value.try_into().map_err(|error| {259		let value = Some(value.try_into().map_err(|error| {
233			Self::Error::Revert(format!(260			Error::Revert(format!(
234				"can't convert value to u32 \"{value}\" because: \"{error}\""261				"can't convert value to u32 \"{value}\" because: \"{error}\""
235			))262			))
236		})?);263		})?);
239			Some(value) => match value {266			Some(value) => match value {
240				0 => Ok(Some(false)),267				0 => Ok(Some(false)),
241				1 => Ok(Some(true)),268				1 => Ok(Some(true)),
242				_ => Err(Self::Error::Revert(format!(269				_ => Err(Error::Revert(format!(
243					"can't convert value to boolean \"{value}\""270					"can't convert value to boolean \"{value}\""
244				))),271				))),
245			},272			},
246			None => Ok(None),273			None => Ok(None),
247		};274		};
248275
249		let mut limits = up_data_structs::CollectionLimits::default();
250		match self.field {276		match self.field {
251			CollectionLimitField::AccountTokenOwnership => {277			CollectionLimitField::AccountTokenOwnership => {
252				limits.account_token_ownership_limit = value;278				limits.account_token_ownership_limit = value;
277				limits.transfers_enabled = convert_value_to_bool()?;303				limits.transfers_enabled = convert_value_to_bool()?;
278			}304			}
279		};305		};
280		Ok(limits)306		Ok(())
281	}307	}
282}308}
309
310/// [`CollectionLimits`](up_data_structs::CollectionLimits) field representation for EVM.
311#[derive(Debug, Default, AbiCoder)]
312pub struct CollectionLimitValue {
313	field: CollectionLimitField,
314	value: U256,
315}
316
317impl CollectionLimitValue {
318	/// Create [`CollectionLimitValue`] from field and value.
319	pub fn new(field: CollectionLimitField, value: u32) -> Self {
320		Self {
321			field,
322			value: value.into(),
323		}
324	}
325
326	/// Set corresponding property in CollectionLimits struct
327	pub fn apply_limit(&self, limits: &mut up_data_structs::CollectionLimits) -> Result<(), Error> {
328		let value = self.value;
329		let value: u32 = value.try_into().map_err(|error| {
330			Error::Revert(format!(
331				"can't convert value to u32 \"{value}\" because: \"{error}\""
332			))
333		})?;
334
335		let convert_value_to_bool = || match value {
336			0 => Ok(Some(false)),
337			1 => Ok(Some(true)),
338			_ => Err(Error::Revert(format!(
339				"can't convert value to boolean \"{value}\""
340			))),
341		};
342
343		match self.field {
344			CollectionLimitField::AccountTokenOwnership => {
345				limits.account_token_ownership_limit = Some(value);
346			}
347			CollectionLimitField::SponsoredDataSize => {
348				limits.sponsored_data_size = Some(value);
349			}
350			CollectionLimitField::SponsoredDataRateLimit => {
351				limits.sponsored_data_rate_limit =
352					Some(up_data_structs::SponsoringRateLimit::Blocks(value));
353			}
354			CollectionLimitField::TokenLimit => {
355				limits.token_limit = Some(value);
356			}
357			CollectionLimitField::SponsorTransferTimeout => {
358				limits.sponsor_transfer_timeout = Some(value);
359			}
360			CollectionLimitField::SponsorApproveTimeout => {
361				limits.sponsor_approve_timeout = Some(value);
362			}
363			CollectionLimitField::OwnerCanTransfer => {
364				limits.owner_can_transfer = convert_value_to_bool()?;
365			}
366			CollectionLimitField::OwnerCanDestroy => {
367				limits.owner_can_destroy = convert_value_to_bool()?;
368			}
369			CollectionLimitField::TransferEnabled => {
370				limits.transfers_enabled = convert_value_to_bool()?;
371			}
372		};
373		Ok(())
374	}
375}
376
377impl TryInto<up_data_structs::CollectionLimits> for CollectionLimit {
378	type Error = Error;
379
380	fn try_into(self) -> Result<up_data_structs::CollectionLimits, Self::Error> {
381		let mut limits = up_data_structs::CollectionLimits::default();
382		self.apply_limit(&mut limits)?;
383		Ok(limits)
384	}
385}
386
387impl FromIterator<CollectionLimitValue> for Result<up_data_structs::CollectionLimits, Error> {
388	fn from_iter<T: IntoIterator<Item = CollectionLimitValue>>(
389		iter: T,
390	) -> Result<up_data_structs::CollectionLimits, Error> {
391		let mut limits = up_data_structs::CollectionLimits::default();
392		for value in iter.into_iter() {
393			value.apply_limit(&mut limits)?;
394		}
395		Ok(limits)
396	}
397}
283398
284/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) fields as an enumeration.399/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) fields as an enumeration.
285#[derive(Default, Debug, Clone, Copy, AbiCoder)]400#[derive(Default, Debug, Clone, Copy, AbiCoder)]
384	/// Convert vector of [`TokenPropertyPermission`] into vector of [`up_data_structs::PropertyKeyPermission`].499	/// Convert vector of [`TokenPropertyPermission`] into vector of [`up_data_structs::PropertyKeyPermission`].
385	pub fn into_property_key_permissions(500	pub fn into_property_key_permissions(
386		permissions: Vec<TokenPropertyPermission>,501		permissions: Vec<TokenPropertyPermission>,
387	) -> pallet_evm_coder_substrate::execution::Result<Vec<up_data_structs::PropertyKeyPermission>>502	) -> Result<Vec<up_data_structs::PropertyKeyPermission>, Error> {
388	{
389		let mut perms = Vec::new();503		let mut perms = Vec::new();
390504
410	pub uri: String,524	pub uri: String,
411}525}
526
527/// Nested collections and permissions
528#[derive(Debug, Default, AbiCoder)]
529pub struct CollectionNestingAndPermission {
530	/// Owner of token can nest tokens under it.
531	pub token_owner: bool,
532	/// Admin of token collection can nest tokens under token.
533	pub collection_admin: bool,
534	/// If set - only tokens from specified collections can be nested.
535	pub restricted: Vec<Address>,
536}
537
538impl CollectionNestingAndPermission {
539	/// Create [`CollectionNesting`].
540	pub fn new(token_owner: bool, collection_admin: bool, restricted: Vec<Address>) -> Self {
541		Self {
542			token_owner,
543			collection_admin,
544			restricted,
545		}
546	}
547}
548
549/// Collection properties
550#[derive(Debug, Default, AbiCoder)]
551pub struct CreateCollectionData {
552	/// Collection sponsor
553	pub pending_sponsor: CrossAddress,
554	/// Collection name
555	pub name: String,
556	/// Collection description
557	pub description: String,
558	/// Token prefix
559	pub token_prefix: String,
560	/// Token type (NFT, FT or RFT)
561	pub mode: CollectionMode,
562	/// Fungible token precision
563	pub decimals: u8,
564	/// Custom Properties
565	pub properties: Vec<Property>,
566	/// Permissions for token properties
567	pub token_property_permissions: Vec<TokenPropertyPermission>,
568	/// Collection admins
569	pub admin_list: Vec<CrossAddress>,
570	/// Nesting settings
571	pub nesting_settings: CollectionNestingAndPermission,
572	/// Collection limits
573	pub limits: Vec<CollectionLimitValue>,
574	/// Extra collection flags
575	pub flags: CollectionFlags,
576}
412577
413/// Nested collections.578/// Nested collections.
414#[derive(Debug, Default, AbiCoder)]579#[derive(Debug, Default, AbiCoder)]

73	transactional, fail,73	transactional, fail,
74};74};
75use up_data_structs::{75use up_data_structs::{
76	AccessMode, COLLECTION_NUMBER_LIMIT, Collection, RpcCollection, CollectionFlags,76	AccessMode, COLLECTION_NUMBER_LIMIT, Collection, RpcCollection, RpcCollectionFlags,
77	RpcCollectionFlags, CollectionId, CreateItemData, MAX_TOKEN_PREFIX_LENGTH,77	CollectionId, CreateItemData, MAX_TOKEN_PREFIX_LENGTH, COLLECTION_ADMINS_LIMIT, TokenId,
78	COLLECTION_ADMINS_LIMIT, TokenId, TokenChild, CollectionStats, MAX_TOKEN_OWNERSHIP,78	TokenChild, CollectionStats, MAX_TOKEN_OWNERSHIP, CollectionMode, NFT_SPONSOR_TRANSFER_TIMEOUT,
79	CollectionMode, NFT_SPONSOR_TRANSFER_TIMEOUT, FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,79	FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, MAX_SPONSOR_TIMEOUT,
1091	/// * `owner` - The owner of the collection.1090	/// * `owner` - The owner of the collection.
1092	/// * `data` - Description of the created collection.1091	/// * `data` - Description of the created collection.
1093	/// * `flags` - Extra flags to store.1092	/// * `flags` - Extra flags to store.
1094	pub fn init_collection(1093	pub fn init_collection(
1094		owner: T::CrossAccountId,
1095		payer: T::CrossAccountId,
1096		data: CreateCollectionData<T::CrossAccountId>,
1097	) -> Result<CollectionId, DispatchError> {
1098		ensure!(data.flags.is_allowed_for_user(), <Error<T>>::NoPermission);
1099		Self::init_collection_internal(owner, payer, data)
1100	}
1101
1102	/// Initializes the collection with ForeignCollection flag. Returns [CollectionId] on success, [DispatchError] otherwise.
1103	pub fn init_foreign_collection(
1095		owner: T::CrossAccountId,1104		owner: T::CrossAccountId,
1096		payer: T::CrossAccountId,1105		payer: T::CrossAccountId,
1097		data: CreateCollectionData<T::AccountId>,1106		mut data: CreateCollectionData<T::CrossAccountId>,
1098		flags: CollectionFlags,
1099	) -> Result<CollectionId, DispatchError> {1107	) -> Result<CollectionId, DispatchError> {
1108		data.flags.foreign = true;
1109		let id = Self::init_collection_internal(owner, payer, data)?;
1110		Ok(id)
1111	}
1112
1113	fn init_collection_internal(
1114		owner: T::CrossAccountId,
1115		payer: T::CrossAccountId,
1116		data: CreateCollectionData<T::CrossAccountId>,
1117	) -> Result<CollectionId, DispatchError> {
1100		{1118		{
1101			ensure!(1119			ensure!(
1102				data.token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH as usize,1120				data.token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH as usize,
1127			token_prefix: data.token_prefix,1145			token_prefix: data.token_prefix,
1128			sponsorship: data1146			sponsorship: data
1129				.pending_sponsor1147				.pending_sponsor
1130				.map(SponsorshipState::Unconfirmed)1148				.map(|sponsor| SponsorshipState::Unconfirmed(sponsor.as_sub().clone()))
1131				.unwrap_or_default(),1149				.unwrap_or_default(),
1132			limits: data1150			limits: data
1133				.limits1151				.limits
1139					Self::clamp_permissions(data.mode.clone(), &Default::default(), permissions)1157					Self::clamp_permissions(data.mode.clone(), &Default::default(), permissions)
1140				})1158				})
1141				.unwrap_or_else(|| Ok(CollectionPermissions::default()))?,1159				.unwrap_or_else(|| Ok(CollectionPermissions::default()))?,
1142			flags,1160			flags: data.flags,
1143		};1161		};
11441162
1145		let mut collection_properties = CollectionPropertiesT::new();1163		let mut collection_properties = CollectionPropertiesT::new();
11561174
1157		CollectionPropertyPermissions::<T>::insert(id, token_props_permissions);1175		CollectionPropertyPermissions::<T>::insert(id, token_props_permissions);
1176
1177		let mut admin_amount = 0u32;
1178		for admin in data.admin_list.iter() {
1179			if !<IsAdmin<T>>::get((id, admin)) {
1180				<IsAdmin<T>>::insert((id, admin), true);
1181				admin_amount = admin_amount
1182					.checked_add(1)
1183					.ok_or(<Error<T>>::CollectionAdminCountExceeded)?;
1184			}
1185		}
1186		ensure!(
1187			admin_amount <= Self::collection_admins_limit(),
1188			<Error<T>>::CollectionAdminCountExceeded,
1189		);
1190		<AdminAmount<T>>::insert(id, admin_amount);
11581191
1159		// Take a (non-refundable) deposit of collection creation1192		// Take a (non-refundable) deposit of collection creation
1160		{1193		{

42	RuntimeDebug,42	RuntimeDebug,
43};43};
44use frame_system::pallet_prelude::*;44use frame_system::pallet_prelude::*;
45use up_data_structs::{CollectionMode};45use up_data_structs::CollectionMode;
46use pallet_fungible::{Pallet as PalletFungible};46use pallet_fungible::Pallet as PalletFungible;
47use scale_info::{TypeInfo};47use scale_info::TypeInfo;
48use sp_runtime::{48use sp_runtime::{
49	traits::{One, Zero},49	traits::{One, Zero},
50	ArithmeticError,50	ArithmeticError,
304				.collect::<Vec<u16>>();304				.collect::<Vec<u16>>();
305			description.append(&mut name.clone());305			description.append(&mut name.clone());
306306
307			let data: CreateCollectionData<T::AccountId> = CreateCollectionData {307			let data: CreateCollectionData<T::CrossAccountId> = CreateCollectionData {
308				name: name.try_into().unwrap(),308				name: name.try_into().unwrap(),
309				description: description.try_into().unwrap(),309				description: description.try_into().unwrap(),
310				mode: CollectionMode::Fungible(md.decimals),310				mode: CollectionMode::Fungible(md.decimals),

31	create_collection_raw(31	create_collection_raw(
32		owner,32		owner,
33		CollectionMode::Fungible(0),33		CollectionMode::Fungible(0),
34		|owner: T::CrossAccountId, data| {34		|owner: T::CrossAccountId, data| <Pallet<T>>::init_collection(owner.clone(), owner, data),
35			<Pallet<T>>::init_collection(owner.clone(), owner, data, Default::default())
36		},
37		FungibleHandle::cast,35		FungibleHandle::cast,
38	)36	)
39}37}

87};87};
88use pallet_evm::account::CrossAccountId;88use pallet_evm::account::CrossAccountId;
89use up_data_structs::{89use up_data_structs::{
90	AccessMode, CollectionId, CollectionFlags, TokenId, CreateCollectionData,90	AccessMode, CollectionId, TokenId, CreateCollectionData, mapping::TokenAddressMapping,
91	mapping::TokenAddressMapping, budget::Budget, PropertyKey, Property,91	budget::Budget, PropertyKey, Property,
92};92};
93use pallet_common::{93use pallet_common::{
219	pub fn init_collection(219	pub fn init_collection(
220		owner: T::CrossAccountId,220		owner: T::CrossAccountId,
221		payer: T::CrossAccountId,221		payer: T::CrossAccountId,
222		data: CreateCollectionData<T::AccountId>,222		data: CreateCollectionData<T::CrossAccountId>,
223		flags: CollectionFlags,
224	) -> Result<CollectionId, DispatchError> {223	) -> Result<CollectionId, DispatchError> {
225		<PalletCommon<T>>::init_collection(owner, payer, data, flags)224		<PalletCommon<T>>::init_collection(owner, payer, data)
226	}225	}
227226
228	/// Initializes the collection with ForeignCollection flag. Returns [CollectionId] on success, [DispatchError] otherwise.227	/// Initializes the collection with ForeignCollection flag. Returns [CollectionId] on success, [DispatchError] otherwise.
229	pub fn init_foreign_collection(228	pub fn init_foreign_collection(
230		owner: T::CrossAccountId,229		owner: T::CrossAccountId,
231		payer: T::CrossAccountId,230		payer: T::CrossAccountId,
232		data: CreateCollectionData<T::AccountId>,231		data: CreateCollectionData<T::CrossAccountId>,
233	) -> Result<CollectionId, DispatchError> {232	) -> Result<CollectionId, DispatchError> {
234		let id = <PalletCommon<T>>::init_collection(233		<PalletCommon<T>>::init_foreign_collection(owner, payer, data)
235			owner,
236			payer,
237			data,
238			CollectionFlags {
239				foreign: true,
240				..Default::default()
241			},
242		)?;
243		Ok(id)
244	}234	}
245235
246	/// Destroys a collection.236	/// Destroys a collection.