`98013fc81aa8`

10 files changed

modifiedpallets/common/src/eth.rsdiff before after both

14// You should have received a copy of the GNU General Public License14// You should have received a copy of the GNU General Public License
15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17use up_data_structs::{CollectionId, TokenId};17use up_data_structs::CollectionId;
18use sp_core::H160;18use sp_core::H160;
1919
20// 0x17c4e6453Cc49AAAaEACA894e6D9683e00000001 - collection 120// 0x17c4e6453Cc49AAAaEACA894e6D9683e00000001 - collection 1

modifiedpallets/common/src/lib.rsdiff before after both

346		/// Not sufficient founds to perform action346		/// Not sufficient founds to perform action
347		NotSufficientFounds,347		NotSufficientFounds,
348
349		/// Collection has nesting disabled
350		NestingIsDisabled,
351		/// Only owner may nest tokens under this collection
352		OnlyOwnerAllowedToNest,
353		/// Only tokens from specific collections may nest tokens under this
354		SourceCollectionIsNotAllowedToNest,
348	}355	}
349356
350	#[pallet::storage]357	#[pallet::storage]
400	#[pallet::hooks]407	#[pallet::hooks]
401	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {408	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
402		fn on_runtime_upgrade() -> Weight {409		fn on_runtime_upgrade() -> Weight {
403			let mut weight = 0;
404
405			if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {410			if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {
406				use up_data_structs::{CollectionVersion1, CollectionVersion2};411				use up_data_structs::{CollectionVersion1, CollectionVersion2};
409				});414				});
410			}415			}
411416
412			weight417			0
413		}418		}
414	}419	}
415}420}
774		data: BoundedVec<u8, CustomDataLimit>,779		data: BoundedVec<u8, CustomDataLimit>,
775	) -> DispatchResultWithPostInfo;780	) -> DispatchResultWithPostInfo;
781
782	fn nest_token(
783		&self,
784		sender: T::CrossAccountId,
785		from: (CollectionId, TokenId),
786		under: TokenId,
787	) -> DispatchResult;
776788
777	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId>;789	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId>;
778	fn token_exists(&self, token: TokenId) -> bool;790	fn token_exists(&self, token: TokenId) -> bool;

modifiedpallets/fungible/src/common.rsdiff before after both

228		fail!(<Error<T>>::FungibleItemsDontHaveData)228		fail!(<Error<T>>::FungibleItemsDontHaveData)
229	}229	}
230
231	fn nest_token(
232		&self,
233		_sender: <T>::CrossAccountId,
234		_from: (up_data_structs::CollectionId, TokenId),
235		_under: TokenId,
236	) -> sp_runtime::DispatchResult {
237		fail!(<Error<T>>::FungibleDisallowsNesting)
238	}
230239
231	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId> {240	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId> {
232		if <Balance<T>>::get((self.id, account)) != 0 {241		if <Balance<T>>::get((self.id, account)) != 0 {

modifiedpallets/fungible/src/lib.rsdiff before after both

1818
19use core::ops::Deref;19use core::ops::Deref;
20use frame_support::{ensure};20use frame_support::{ensure};
21use pallet_evm::account::CrossAccountId;
21use up_data_structs::{AccessMode, CollectionId, TokenId, CreateCollectionData};22use up_data_structs::{
23	AccessMode, CollectionId, TokenId, CreateCollectionData, mapping::TokenAddressMapping,
24};
22use pallet_common::{Error as CommonError, Event as CommonEvent, Pallet as PalletCommon};25use pallet_common::{
23use pallet_evm::account::CrossAccountId;26	Error as CommonError, Event as CommonEvent, Pallet as PalletCommon,
27	CollectionHandle, dispatch::CollectionDispatch,
28};
24use pallet_evm_coder_substrate::WithRecorder;29use pallet_evm_coder_substrate::WithRecorder;
25use sp_core::H160;30use sp_core::H160;
52		FungibleItemsHaveNoId,57		FungibleItemsHaveNoId,
53		/// Tried to set data for fungible item58		/// Tried to set data for fungible item
54		FungibleItemsDontHaveData,59		FungibleItemsDontHaveData,
60		/// Fungible token does not support nested
61		FungibleDisallowsNesting,
55	}62	}
5663
57	#[pallet::config]64	#[pallet::config]
207			None214			None
208		};215		};
216
217		if let Some(target) = T::CrossTokenAddressMapping::address_to_token(to) {
218			let handle = <CollectionHandle<T>>::try_get(target.0)?;
219			let dispatch = T::CollectionDispatch::dispatch(handle);
220			let dispatch = dispatch.as_dyn();
209221
210		// =========222			// =========
223
224			dispatch.nest_token(from.clone(), (collection.id, TokenId::default()), target.1)?;
225		}
211226
212		if let Some(balance_to) = balance_to {227		if let Some(balance_to) = balance_to {
213			// from != to228			// from != to

modifiedpallets/nonfungible/src/common.rsdiff before after both

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, BoundedVec};
20use up_data_structs::{TokenId, CustomDataLimit, CreateItemExData};20use up_data_structs::{TokenId, CustomDataLimit, CreateItemExData, CollectionId};
21use pallet_common::{CommonCollectionOperations, CommonWeightInfo, with_weight};21use pallet_common::{CommonCollectionOperations, CommonWeightInfo, with_weight};
22use sp_runtime::DispatchError;22use sp_runtime::DispatchError;
23use sp_std::vec::Vec;23use sp_std::vec::Vec;
237		)237		)
238	}238	}
239
240	fn nest_token(
241		&self,
242		sender: T::CrossAccountId,
243		(from, _): (CollectionId, TokenId),
244		under: TokenId,
245	) -> sp_runtime::DispatchResult {
246		<Pallet<T>>::nest_token(self, sender, from, under)
247	}
239248
240	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId> {249	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId> {
241		<Owned<T>>::iter_prefix((self.id, account))250		<Owned<T>>::iter_prefix((self.id, account))

modifiedpallets/nonfungible/src/lib.rsdiff before after both

17#![cfg_attr(not(feature = "std"), no_std)]17#![cfg_attr(not(feature = "std"), no_std)]
1818
19use erc::ERC721Events;19use erc::ERC721Events;
20use frame_support::{BoundedVec, ensure};20use frame_support::{BoundedVec, ensure, fail};
21use up_data_structs::{21use up_data_structs::{
22	AccessMode, CollectionId, CustomDataLimit, TokenId, CreateCollectionData, CreateNftExData,22	AccessMode, CollectionId, CustomDataLimit, TokenId, CreateCollectionData, CreateNftExData,
23	mapping::TokenAddressMapping, NestingRule,
23};24};
25use pallet_evm::account::CrossAccountId;
24use pallet_common::{Error as CommonError, Pallet as PalletCommon, Event as CommonEvent};26use pallet_common::{
25use pallet_evm::account::CrossAccountId;27	Error as CommonError, Pallet as PalletCommon, Event as CommonEvent,
28	CollectionHandle, dispatch::CollectionDispatch,
29};
26use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};30use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};
27use sp_core::H160;31use sp_core::H160;
282			None286			None
283		};287		};
288
289		if let Some(target) = T::CrossTokenAddressMapping::address_to_token(to) {
290			let handle = <CollectionHandle<T>>::try_get(target.0)?;
291			let dispatch = T::CollectionDispatch::dispatch(handle);
292			let dispatch = dispatch.as_dyn();
284293
285		// =========294			// =========
295
296			dispatch.nest_token(from.clone(), (collection.id, token), target.1)?;
297		}
286298
287		<TokenData<T>>::insert(299		<TokenData<T>>::insert(
288			(collection.id, token),300			(collection.id, token),
567		Ok(())579		Ok(())
568	}580	}
581
582	pub fn nest_token(
583		handle: &NonfungibleHandle<T>,
584		sender: T::CrossAccountId,
585		from: CollectionId,
586		under: TokenId,
587	) -> DispatchResult {
588		fn ensure_sender_allowed<T: Config>(
589			collection: CollectionId,
590			token: TokenId,
591			sender: T::CrossAccountId,
592		) -> DispatchResult {
593			ensure!(
594				<TokenData<T>>::get((collection, token))
595					.ok_or(<CommonError<T>>::TokenNotFound)?
596					.owner
597					.conv_eq(&sender),
598				<CommonError<T>>::OnlyOwnerAllowedToNest,
599			);
600			Ok(())
601		}
602		match handle.limits.nesting_rule() {
603			NestingRule::Disabled => fail!(<CommonError<T>>::NestingIsDisabled),
604			NestingRule::Owner => ensure_sender_allowed::<T>(from, under, sender)?,
605			NestingRule::OwnerRestricted(whitelist) => {
606				ensure!(
607					whitelist.contains(&from),
608					<CommonError<T>>::SourceCollectionIsNotAllowedToNest
609				);
610				ensure_sender_allowed::<T>(from, under, sender)?
611			}
612		}
613		Ok(())
614	}
569615
570	/// Delegated to `create_multiple_items`616	/// Delegated to `create_multiple_items`
571	pub fn create_item(617	pub fn create_item(

modifiedpallets/refungible/src/common.rsdiff before after both

243		)243		)
244	}244	}
245
246	fn nest_token(
247		&self,
248		_sender: <T>::CrossAccountId,
249		_from: (up_data_structs::CollectionId, TokenId),
250		_under: TokenId,
251	) -> sp_runtime::DispatchResult {
252		fail!(<Error<T>>::RefungibleDisallowsNesting)
253	}
245254
246	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId> {255	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId> {
247		<Owned<T>>::iter_prefix((self.id, account))256		<Owned<T>>::iter_prefix((self.id, account))

modifiedpallets/refungible/src/lib.rsdiff before after both

19use frame_support::{ensure, BoundedVec};19use frame_support::{ensure, BoundedVec};
20use up_data_structs::{20use up_data_structs::{
21	AccessMode, CollectionId, CustomDataLimit, MAX_REFUNGIBLE_PIECES, TokenId,21	AccessMode, CollectionId, CustomDataLimit, MAX_REFUNGIBLE_PIECES, TokenId,
22	CreateCollectionData, CreateRefungibleExData,22	CreateCollectionData, CreateRefungibleExData, mapping::TokenAddressMapping,
23};23};
24use pallet_evm::account::CrossAccountId;
24use pallet_common::{Error as CommonError, Event as CommonEvent, Pallet as PalletCommon};25use pallet_common::{
25use pallet_evm::account::CrossAccountId;26	Error as CommonError, Event as CommonEvent, Pallet as PalletCommon,
27	CollectionHandle, dispatch::CollectionDispatch,
28};
26use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};29use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};
27use sp_std::{vec::Vec, vec, collections::btree_map::BTreeMap};30use sp_std::{vec::Vec, vec, collections::btree_map::BTreeMap};
56		NotRefungibleDataUsedToMintFungibleCollectionToken,59		NotRefungibleDataUsedToMintFungibleCollectionToken,
57		/// Maximum refungibility exceeded60		/// Maximum refungibility exceeded
58		WrongRefungiblePieces,61		WrongRefungiblePieces,
62		/// Refungible token can't nest other tokens
63		RefungibleDisallowsNesting,
59	}64	}
6065
61	#[pallet::config]66	#[pallet::config]
338			None343			None
339		};344		};
345
346		if let Some(target) = T::CrossTokenAddressMapping::address_to_token(to) {
347			let handle = <CollectionHandle<T>>::try_get(target.0)?;
348			let dispatch = T::CollectionDispatch::dispatch(handle);
349			let dispatch = dispatch.as_dyn();
340350
341		// =========351			// =========
352
353			dispatch.nest_token(from.clone(), (collection.id, token), target.1)?;
354		}
342355
343		if let Some(balance_to) = balance_to {356		if let Some(balance_to) = balance_to {
344			// from != to357			// from != to

addedprimitives/data-structs/src/bounded.rsdiff before after both

no changes

modifiedprimitives/data-structs/src/lib.rsdiff before after both

22};22};
23use frame_support::{23use frame_support::{
24	storage::{bounded_btree_map::BoundedBTreeMap, bounded_btree_set::BoundedBTreeSet},24	storage::{bounded_btree_map::BoundedBTreeMap, bounded_btree_set::BoundedBTreeSet},
25	traits::ConstU16,
26};25};
27use sp_std::collections::{btree_map::BTreeMap, btree_set::BTreeSet};
2826
29#[cfg(feature = "serde")]27#[cfg(feature = "serde")]
30use serde::{Serialize, Deserialize};28use serde::{Serialize, Deserialize};
36use derivative::Derivative;34use derivative::Derivative;
37use scale_info::TypeInfo;35use scale_info::TypeInfo;
3836
37mod bounded;
39pub mod mapping;38pub mod mapping;
40mod migration;39mod migration;
4140
255	pub owner: AccountId,254	pub owner: AccountId,
256	pub mode: CollectionMode,255	pub mode: CollectionMode,
257	pub access: AccessMode,256	pub access: AccessMode,
258	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]257	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
259	pub name: BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>,258	pub name: BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>,
260	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]259	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
261	pub description: BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>,260	pub description: BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>,
262	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]261	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
263	pub token_prefix: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,262	pub token_prefix: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,
264	pub mint_mode: bool,263	pub mint_mode: bool,
265	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]264	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
266	pub offchain_schema: BoundedVec<u8, ConstU32<OFFCHAIN_SCHEMA_LIMIT>>,265	pub offchain_schema: BoundedVec<u8, ConstU32<OFFCHAIN_SCHEMA_LIMIT>>,
267	pub schema_version: SchemaVersion,266	pub schema_version: SchemaVersion,
268	pub sponsorship: SponsorshipState<AccountId>,267	pub sponsorship: SponsorshipState<AccountId>,
272	#[version(2.., upper(limits.into()))]271	#[version(2.., upper(limits.into()))]
273	pub limits: CollectionLimitsVersion2,272	pub limits: CollectionLimitsVersion2,
274273
275	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]274	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
276	pub variable_on_chain_schema: BoundedVec<u8, ConstU32<VARIABLE_ON_CHAIN_SCHEMA_LIMIT>>,275	pub variable_on_chain_schema: BoundedVec<u8, ConstU32<VARIABLE_ON_CHAIN_SCHEMA_LIMIT>>,
277	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]276	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
278	pub const_on_chain_schema: BoundedVec<u8, ConstU32<CONST_ON_CHAIN_SCHEMA_LIMIT>>,277	pub const_on_chain_schema: BoundedVec<u8, ConstU32<CONST_ON_CHAIN_SCHEMA_LIMIT>>,
279	pub meta_update_permission: MetaUpdatePermission,278	pub meta_update_permission: MetaUpdatePermission,
280}279}
286	#[derivative(Default(value = "CollectionMode::NFT"))]285	#[derivative(Default(value = "CollectionMode::NFT"))]
287	pub mode: CollectionMode,286	pub mode: CollectionMode,
288	pub access: Option<AccessMode>,287	pub access: Option<AccessMode>,
289	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]288	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
290	pub name: BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>,289	pub name: BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>,
291	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]290	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
292	pub description: BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>,291	pub description: BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>,
293	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]292	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
294	pub token_prefix: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,293	pub token_prefix: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,
295	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]294	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
296	pub offchain_schema: BoundedVec<u8, ConstU32<OFFCHAIN_SCHEMA_LIMIT>>,295	pub offchain_schema: BoundedVec<u8, ConstU32<OFFCHAIN_SCHEMA_LIMIT>>,
297	pub schema_version: Option<SchemaVersion>,296	pub schema_version: Option<SchemaVersion>,
298	pub pending_sponsor: Option<AccountId>,297	pub pending_sponsor: Option<AccountId>,
299	pub limits: Option<CollectionLimits>,298	pub limits: Option<CollectionLimits>,
300	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]299	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
301	pub variable_on_chain_schema: BoundedVec<u8, ConstU32<VARIABLE_ON_CHAIN_SCHEMA_LIMIT>>,300	pub variable_on_chain_schema: BoundedVec<u8, ConstU32<VARIABLE_ON_CHAIN_SCHEMA_LIMIT>>,
302	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]301	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
303	pub const_on_chain_schema: BoundedVec<u8, ConstU32<CONST_ON_CHAIN_SCHEMA_LIMIT>>,302	pub const_on_chain_schema: BoundedVec<u8, ConstU32<CONST_ON_CHAIN_SCHEMA_LIMIT>>,
304	pub meta_update_permission: Option<MetaUpdatePermission>,303	pub meta_update_permission: Option<MetaUpdatePermission>,
305}304}
410	Owner,409	Owner,
411	/// Owner can nest tokens from specified collections410	/// Owner can nest tokens from specified collections
412	OwnerRestricted(411	OwnerRestricted(
413		#[cfg_attr(feature = "serde1", serde(with = "bounded_set_serde"))]412		#[cfg_attr(feature = "serde1", serde(with = "bounded::set_serde"))]
414		#[derivative(Debug(format_with = "bounded_set_debug"))]413		#[derivative(Debug(format_with = "bounded::set_debug"))]
415		BoundedBTreeSet<CollectionId, ConstU32<16>>,414		BoundedBTreeSet<CollectionId, ConstU32<16>>,
416	),415	),
417}416}
423	Blocks(u32),422	Blocks(u32),
424}423}
425
426/// BoundedVec doesn't supports serde
427#[cfg(feature = "serde1")]
428mod bounded_serde {
429	use core::convert::TryFrom;
430	use frame_support::{BoundedVec, traits::Get};
431	use serde::{
432		ser::{self, Serialize},
433		de::{self, Deserialize, Error},
434	};
435	use sp_std::vec::Vec;
436
437	pub fn serialize<D, V, S>(value: &BoundedVec<V, S>, serializer: D) -> Result<D::Ok, D::Error>
438	where
439		D: ser::Serializer,
440		V: Serialize,
441	{
442		(value as &Vec<_>).serialize(serializer)
443	}
444
445	pub fn deserialize<'de, D, V, S>(deserializer: D) -> Result<BoundedVec<V, S>, D::Error>
446	where
447		D: de::Deserializer<'de>,
448		V: de::Deserialize<'de>,
449		S: Get<u32>,
450	{
451		// TODO: Implement custom visitor, which will limit vec size at parse time? Will serde only be used by chainspec?
452		let vec = <Vec<V>>::deserialize(deserializer)?;
453		let len = vec.len();
454		TryFrom::try_from(vec).map_err(|_| D::Error::invalid_length(len, &"lesser size"))
455	}
456}
457
458fn bounded_debug<V, S>(v: &BoundedVec<V, S>, f: &mut fmt::Formatter) -> Result<(), fmt::Error>
459where
460	V: fmt::Debug,
461{
462	use core::fmt::Debug;
463	(&v as &Vec<V>).fmt(f)
464}
465
466#[cfg(feature = "serde1")]
467#[allow(dead_code)]
468mod bounded_map_serde {
469	use core::convert::TryFrom;
470	use sp_std::collections::btree_map::BTreeMap;
471	use frame_support::{traits::Get, storage::bounded_btree_map::BoundedBTreeMap};
472	use serde::{
473		ser::{self, Serialize},
474		de::{self, Deserialize, Error},
475	};
476	pub fn serialize<D, K, V, S>(
477		value: &BoundedBTreeMap<K, V, S>,
478		serializer: D,
479	) -> Result<D::Ok, D::Error>
480	where
481		D: ser::Serializer,
482		K: Serialize + Ord,
483		V: Serialize,
484	{
485		(value as &BTreeMap<_, _>).serialize(serializer)
486	}
487
488	pub fn deserialize<'de, D, K, V, S>(
489		deserializer: D,
490	) -> Result<BoundedBTreeMap<K, V, S>, D::Error>
491	where
492		D: de::Deserializer<'de>,
493		K: de::Deserialize<'de> + Ord,
494		V: de::Deserialize<'de>,
495		S: Get<u32>,
496	{
497		let map = <BTreeMap<K, V>>::deserialize(deserializer)?;
498		let len = map.len();
499		TryFrom::try_from(map).map_err(|_| D::Error::invalid_length(len, &"lesser size"))
500	}
501}
502
503fn bounded_map_debug<K, V, S>(
504	v: &BoundedBTreeMap<K, V, S>,
505	f: &mut fmt::Formatter,
506) -> Result<(), fmt::Error>
507where
508	K: fmt::Debug + Ord,
509	V: fmt::Debug,
510{
511	use core::fmt::Debug;
512	(&v as &BTreeMap<K, V>).fmt(f)
513}
514
515#[cfg(feature = "serde1")]
516#[allow(dead_code)]
517mod bounded_set_serde {
518	use core::convert::TryFrom;
519	use sp_std::collections::btree_set::BTreeSet;
520	use frame_support::{traits::Get, storage::bounded_btree_set::BoundedBTreeSet};
521	use serde::{
522		ser::{self, Serialize},
523		de::{self, Deserialize, Error},
524	};
525	pub fn serialize<D, K, S>(
526		value: &BoundedBTreeSet<K, S>,
527		serializer: D,
528	) -> Result<D::Ok, D::Error>
529	where
530		D: ser::Serializer,
531		K: Serialize + Ord,
532	{
533		(value as &BTreeSet<_>).serialize(serializer)
534	}
535
536	pub fn deserialize<'de, D, K, S>(deserializer: D) -> Result<BoundedBTreeSet<K, S>, D::Error>
537	where
538		D: de::Deserializer<'de>,
539		K: de::Deserialize<'de> + Ord,
540		S: Get<u32>,
541	{
542		let map = <BTreeSet<K>>::deserialize(deserializer)?;
543		let len = map.len();
544		TryFrom::try_from(map).map_err(|_| D::Error::invalid_length(len, &"lesser size"))
545	}
546}
547
548fn bounded_set_debug<K, S>(
549	v: &BoundedBTreeSet<K, S>,
550	f: &mut fmt::Formatter,
551) -> Result<(), fmt::Error>
552where
553	K: fmt::Debug + Ord,
554{
555	use core::fmt::Debug;
556	(&v as &BTreeSet<K>).fmt(f)
557}
558424
559#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]425#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]
560#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]426#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
561#[derivative(Debug)]427#[derivative(Debug)]
562pub struct CreateNftData {428pub struct CreateNftData {
563	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]429	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
564	#[derivative(Debug(format_with = "bounded_debug"))]430	#[derivative(Debug(format_with = "bounded::vec_debug"))]
565	pub const_data: BoundedVec<u8, CustomDataLimit>,431	pub const_data: BoundedVec<u8, CustomDataLimit>,
566	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]432	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
567	#[derivative(Debug(format_with = "bounded_debug"))]433	#[derivative(Debug(format_with = "bounded::vec_debug"))]
568	pub variable_data: BoundedVec<u8, CustomDataLimit>,434	pub variable_data: BoundedVec<u8, CustomDataLimit>,
569}435}
570436
578#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]444#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
579#[derivative(Debug)]445#[derivative(Debug)]
580pub struct CreateReFungibleData {446pub struct CreateReFungibleData {
581	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]447	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
582	#[derivative(Debug(format_with = "bounded_debug"))]448	#[derivative(Debug(format_with = "bounded::vec_debug"))]
583	pub const_data: BoundedVec<u8, CustomDataLimit>,449	pub const_data: BoundedVec<u8, CustomDataLimit>,
584	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]450	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
585	#[derivative(Debug(format_with = "bounded_debug"))]451	#[derivative(Debug(format_with = "bounded::vec_debug"))]
586	pub variable_data: BoundedVec<u8, CustomDataLimit>,452	pub variable_data: BoundedVec<u8, CustomDataLimit>,
587	pub pieces: u128,453	pub pieces: u128,
588}454}
612#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]478#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]
613#[derivative(Debug)]479#[derivative(Debug)]
614pub struct CreateNftExData<CrossAccountId> {480pub struct CreateNftExData<CrossAccountId> {
615	#[derivative(Debug(format_with = "bounded_debug"))]481	#[derivative(Debug(format_with = "bounded::vec_debug"))]
616	pub const_data: BoundedVec<u8, CustomDataLimit>,482	pub const_data: BoundedVec<u8, CustomDataLimit>,
617	#[derivative(Debug(format_with = "bounded_debug"))]483	#[derivative(Debug(format_with = "bounded::vec_debug"))]
618	pub variable_data: BoundedVec<u8, CustomDataLimit>,484	pub variable_data: BoundedVec<u8, CustomDataLimit>,
619	pub owner: CrossAccountId,485	pub owner: CrossAccountId,
620}486}
621487
622#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]488#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]
623#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]489#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]
624pub struct CreateRefungibleExData<CrossAccountId> {490pub struct CreateRefungibleExData<CrossAccountId> {
625	#[derivative(Debug(format_with = "bounded_debug"))]491	#[derivative(Debug(format_with = "bounded::vec_debug"))]
626	pub const_data: BoundedVec<u8, CustomDataLimit>,492	pub const_data: BoundedVec<u8, CustomDataLimit>,
627	#[derivative(Debug(format_with = "bounded_debug"))]493	#[derivative(Debug(format_with = "bounded::vec_debug"))]
628	pub variable_data: BoundedVec<u8, CustomDataLimit>,494	pub variable_data: BoundedVec<u8, CustomDataLimit>,
629	#[derivative(Debug(format_with = "bounded_map_debug"))]495	#[derivative(Debug(format_with = "bounded::map_debug"))]
630	pub users: BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,496	pub users: BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,
631}497}
632498
633#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]499#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]
634#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]500#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]
635pub enum CreateItemExData<CrossAccountId> {501pub enum CreateItemExData<CrossAccountId> {
636	NFT(502	NFT(
637		#[derivative(Debug(format_with = "bounded_debug"))]503		#[derivative(Debug(format_with = "bounded::vec_debug"))]
638		BoundedVec<CreateNftExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,504		BoundedVec<CreateNftExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,
639	),505	),
640	Fungible(506	Fungible(
641		#[derivative(Debug(format_with = "bounded_map_debug"))]507		#[derivative(Debug(format_with = "bounded::map_debug"))]
642		BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,508		BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,
643	),509	),
644	/// Many tokens, each may have only one owner510	/// Many tokens, each may have only one owner
645	RefungibleMultipleItems(511	RefungibleMultipleItems(
646		#[derivative(Debug(format_with = "bounded_debug"))]512		#[derivative(Debug(format_with = "bounded::vec_debug"))]
647		BoundedVec<CreateRefungibleExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,513		BoundedVec<CreateRefungibleExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,
648	),514	),
649	/// Single token, which may have many owners515	/// Single token, which may have many owners