git.delta.rocks / unique-network / refs/commits / 75d8b9094b27

1#![cfg_attr(not(feature = "std"), no_std)]23use erc::ERC721Events;4use frame_support::{BoundedVec, ensure};5use up_data_structs::{6	AccessMode, Collection, CollectionId, CustomDataLimit, TokenId, CreateCollectionData,7};8use pallet_common::{9	Error as CommonError, Pallet as PalletCommon, Event as CommonEvent, account::CrossAccountId,10};11use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};12use sp_core::H160;13use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};14use sp_std::{vec::Vec, vec};15use core::ops::Deref;16use sp_std::collections::btree_map::BTreeMap;17use codec::{Encode, Decode, MaxEncodedLen};18use scale_info::TypeInfo;1920pub use pallet::*;21#[cfg(feature = "runtime-benchmarks")]22pub mod benchmarking;23pub mod common;24pub mod erc;25pub mod weights;2627pub struct CreateItemData<T: Config> {28	pub const_data: BoundedVec<u8, CustomDataLimit>,29	pub variable_data: BoundedVec<u8, CustomDataLimit>,30	pub owner: T::CrossAccountId,31}32pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;3334#[derive(Encode, Decode, TypeInfo, MaxEncodedLen)]35pub struct ItemData<CrossAccountId> {36	pub const_data: BoundedVec<u8, CustomDataLimit>,37	pub variable_data: BoundedVec<u8, CustomDataLimit>,38	pub owner: CrossAccountId,39}4041#[frame_support::pallet]42pub mod pallet {43	use super::*;44	use frame_support::{Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key};45	use up_data_structs::{CollectionId, TokenId};46	use super::weights::WeightInfo;4748	#[pallet::error]49	pub enum Error<T> {50		/// Not Nonfungible item data used to mint in Nonfungible collection.51		NotNonfungibleDataUsedToMintFungibleCollectionToken,52		/// Used amount > 1 with NFT53		NonfungibleItemsHaveNoAmount,54	}5556	#[pallet::config]57	pub trait Config: frame_system::Config + pallet_common::Config {58		type WeightInfo: WeightInfo;59	}6061	#[pallet::pallet]62	#[pallet::generate_store(pub(super) trait Store)]63	pub struct Pallet<T>(_);6465	#[pallet::storage]66	pub type TokensMinted<T: Config> =67		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;68	#[pallet::storage]69	pub type TokensBurnt<T: Config> =70		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;7172	#[pallet::storage]73	pub type TokenData<T: Config> = StorageNMap<74		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),75		Value = ItemData<T::CrossAccountId>,76		QueryKind = OptionQuery,77	>;7879	/// Used to enumerate tokens owned by account80	#[pallet::storage]81	pub type Owned<T: Config> = StorageNMap<82		Key = (83			Key<Twox64Concat, CollectionId>,84			Key<Blake2_128Concat, T::CrossAccountId>,85			Key<Twox64Concat, TokenId>,86		),87		Value = bool,88		QueryKind = ValueQuery,89	>;9091	#[pallet::storage]92	pub type AccountBalance<T: Config> = StorageNMap<93		Key = (94			Key<Twox64Concat, CollectionId>,95			Key<Blake2_128Concat, T::CrossAccountId>,96		),97		Value = u32,98		QueryKind = ValueQuery,99	>;100101	#[pallet::storage]102	pub type Allowance<T: Config> = StorageNMap<103		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),104		Value = T::CrossAccountId,105		QueryKind = OptionQuery,106	>;107}108109pub struct NonfungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);110impl<T: Config> NonfungibleHandle<T> {111	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {112		Self(inner)113	}114	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {115		self.0116	}117}118impl<T: Config> WithRecorder<T> for NonfungibleHandle<T> {119	fn recorder(&self) -> &SubstrateRecorder<T> {120		self.0.recorder()121	}122	fn into_recorder(self) -> SubstrateRecorder<T> {123		self.0.into_recorder()124	}125}126impl<T: Config> Deref for NonfungibleHandle<T> {127	type Target = pallet_common::CollectionHandle<T>;128129	fn deref(&self) -> &Self::Target {130		&self.0131	}132}133134impl<T: Config> Pallet<T> {135	pub fn total_supply(collection: &NonfungibleHandle<T>) -> u32 {136		<TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)137	}138	pub fn token_exists(collection: &NonfungibleHandle<T>, token: TokenId) -> bool {139		<TokenData<T>>::contains_key((collection.id, token))140	}141}142143// unchecked calls skips any permission checks144impl<T: Config> Pallet<T> {145	pub fn init_collection(146		owner: T::AccountId,147		data: CreateCollectionData<T::AccountId>,148	) -> Result<CollectionId, DispatchError> {149		<PalletCommon<T>>::init_collection(owner, data)150	}151	pub fn destroy_collection(152		collection: NonfungibleHandle<T>,153		sender: &T::CrossAccountId,154	) -> DispatchResult {155		let id = collection.id;156157		// =========158159		PalletCommon::destroy_collection(collection.0, sender)?;160161		<TokenData<T>>::remove_prefix((id,), None);162		<Owned<T>>::remove_prefix((id,), None);163		<TokensMinted<T>>::remove(id);164		<TokensBurnt<T>>::remove(id);165		<Allowance<T>>::remove_prefix((id,), None);166		<AccountBalance<T>>::remove_prefix((id,), None);167		Ok(())168	}169170	pub fn burn(171		collection: &NonfungibleHandle<T>,172		sender: &T::CrossAccountId,173		token: TokenId,174	) -> DispatchResult {175		let token_data =176			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;177		ensure!(178			&token_data.owner == sender179				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(sender)),180			<CommonError<T>>::NoPermission181		);182183		if collection.access == AccessMode::AllowList {184			collection.check_allowlist(sender)?;185		}186187		let burnt = <TokensBurnt<T>>::get(collection.id)188			.checked_add(1)189			.ok_or(ArithmeticError::Overflow)?;190191		let balance = <AccountBalance<T>>::get((collection.id, token_data.owner.clone()))192			.checked_sub(1)193			.ok_or(ArithmeticError::Overflow)?;194195		if balance == 0 {196			<AccountBalance<T>>::remove((collection.id, token_data.owner.clone()));197		} else {198			<AccountBalance<T>>::insert((collection.id, token_data.owner.clone()), balance);199		}200		// =========201202		<Owned<T>>::remove((collection.id, &token_data.owner, token));203		<TokensBurnt<T>>::insert(collection.id, burnt);204		<TokenData<T>>::remove((collection.id, token));205		let old_spender = <Allowance<T>>::take((collection.id, token));206207		if let Some(old_spender) = old_spender {208			<PalletCommon<T>>::deposit_event(CommonEvent::Approved(209				collection.id,210				token,211				sender.clone(),212				old_spender,213				0,214			));215		}216217		collection.log_mirrored(ERC721Events::Transfer {218			from: *token_data.owner.as_eth(),219			to: H160::default(),220			token_id: token.into(),221		});222		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(223			collection.id,224			token,225			token_data.owner,226			1,227		));228		Ok(())229	}230231	pub fn transfer(232		collection: &NonfungibleHandle<T>,233		from: &T::CrossAccountId,234		to: &T::CrossAccountId,235		token: TokenId,236	) -> DispatchResult {237		ensure!(238			collection.limits.transfers_enabled(),239			<CommonError<T>>::TransferNotAllowed240		);241242		let token_data =243			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;244		ensure!(245			&token_data.owner == from246				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(from)),247			<CommonError<T>>::NoPermission248		);249250		if collection.access == AccessMode::AllowList {251			collection.check_allowlist(from)?;252			collection.check_allowlist(to)?;253		}254		<PalletCommon<T>>::ensure_correct_receiver(to)?;255256		let balance_from = <AccountBalance<T>>::get((collection.id, from))257			.checked_sub(1)258			.ok_or(<CommonError<T>>::TokenValueTooLow)?;259		let balance_to = if from != to {260			let balance_to = <AccountBalance<T>>::get((collection.id, to))261				.checked_add(1)262				.ok_or(ArithmeticError::Overflow)?;263264			ensure!(265				balance_to < collection.limits.account_token_ownership_limit(),266				<CommonError<T>>::AccountTokenLimitExceeded,267			);268269			Some(balance_to)270		} else {271			None272		};273274		// =========275276		<TokenData<T>>::insert(277			(collection.id, token),278			ItemData {279				owner: to.clone(),280				..token_data281			},282		);283284		if let Some(balance_to) = balance_to {285			// from != to286			if balance_from == 0 {287				<AccountBalance<T>>::remove((collection.id, from));288			} else {289				<AccountBalance<T>>::insert((collection.id, from), balance_from);290			}291			<AccountBalance<T>>::insert((collection.id, to), balance_to);292			<Owned<T>>::remove((collection.id, from, token));293			<Owned<T>>::insert((collection.id, to, token), true);294		}295		Self::set_allowance_unchecked(collection, from, token, None, true);296297		collection.log_mirrored(ERC721Events::Transfer {298			from: *from.as_eth(),299			to: *to.as_eth(),300			token_id: token.into(),301		});302		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(303			collection.id,304			token,305			from.clone(),306			to.clone(),307			1,308		));309		Ok(())310	}311312	pub fn create_multiple_items(313		collection: &NonfungibleHandle<T>,314		sender: &T::CrossAccountId,315		data: Vec<CreateItemData<T>>,316	) -> DispatchResult {317		if !collection.is_owner_or_admin(sender) {318			ensure!(319				collection.mint_mode,320				<CommonError<T>>::PublicMintingNotAllowed321			);322			collection.check_allowlist(sender)?;323324			for item in data.iter() {325				collection.check_allowlist(&item.owner)?;326			}327		}328329		for data in data.iter() {330			<PalletCommon<T>>::ensure_correct_receiver(&data.owner)?;331		}332333		let first_token = <TokensMinted<T>>::get(collection.id);334		let tokens_minted = first_token335			.checked_add(data.len() as u32)336			.ok_or(ArithmeticError::Overflow)?;337		ensure!(338			tokens_minted <= collection.limits.token_limit(),339			<CommonError<T>>::CollectionTokenLimitExceeded340		);341342		let mut balances = BTreeMap::new();343		for data in &data {344			let balance = balances345				.entry(&data.owner)346				.or_insert_with(|| <AccountBalance<T>>::get((collection.id, &data.owner)));347			*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;348349			ensure!(350				*balance <= collection.limits.account_token_ownership_limit(),351				<CommonError<T>>::AccountTokenLimitExceeded,352			);353		}354355		// =========356357		<TokensMinted<T>>::insert(collection.id, tokens_minted);358		for (account, balance) in balances {359			<AccountBalance<T>>::insert((collection.id, account), balance);360		}361		for (i, data) in data.into_iter().enumerate() {362			let token = first_token + i as u32 + 1;363364			<TokenData<T>>::insert(365				(collection.id, token),366				ItemData {367					const_data: data.const_data,368					variable_data: data.variable_data,369					owner: data.owner.clone(),370				},371			);372			<Owned<T>>::insert((collection.id, &data.owner, token), true);373374			collection.log_mirrored(ERC721Events::Transfer {375				from: H160::default(),376				to: *data.owner.as_eth(),377				token_id: token.into(),378			});379			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(380				collection.id,381				TokenId(token),382				data.owner.clone(),383				1,384			));385		}386		Ok(())387	}388389	pub fn set_allowance_unchecked(390		collection: &NonfungibleHandle<T>,391		sender: &T::CrossAccountId,392		token: TokenId,393		spender: Option<&T::CrossAccountId>,394		assume_implicit_eth: bool,395	) {396		if let Some(spender) = spender {397			let old_spender = <Allowance<T>>::get((collection.id, token));398			<Allowance<T>>::insert((collection.id, token), spender);399			// In ERC721 there is only one possible approved user of token, so we set400			// approved user to spender401			collection.log_mirrored(ERC721Events::Approval {402				owner: *sender.as_eth(),403				approved: *spender.as_eth(),404				token_id: token.into(),405			});406			// In Unique chain, any token can have any amount of approved users, so we need to407			// set allowance of old owner to 0, and allowance of new owner to 1408			if old_spender.as_ref() != Some(spender) {409				if let Some(old_owner) = old_spender {410					<PalletCommon<T>>::deposit_event(CommonEvent::Approved(411						collection.id,412						token,413						sender.clone(),414						old_owner,415						0,416					));417				}418				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(419					collection.id,420					token,421					sender.clone(),422					spender.clone(),423					1,424				));425			}426		} else {427			let old_spender = <Allowance<T>>::take((collection.id, token));428			if !assume_implicit_eth {429				// In ERC721 there is only one possible approved user of token, so we set430				// approved user to zero address431				collection.log_mirrored(ERC721Events::Approval {432					owner: *sender.as_eth(),433					approved: H160::default(),434					token_id: token.into(),435				});436			}437			// In Unique chain, any token can have any amount of approved users, so we need to438			// set allowance of old owner to 0439			if let Some(old_spender) = old_spender {440				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(441					collection.id,442					token,443					sender.clone(),444					old_spender,445					0,446				));447			}448		}449	}450451	pub fn set_allowance(452		collection: &NonfungibleHandle<T>,453		sender: &T::CrossAccountId,454		token: TokenId,455		spender: Option<&T::CrossAccountId>,456	) -> DispatchResult {457		if collection.access == AccessMode::AllowList {458			collection.check_allowlist(sender)?;459			if let Some(spender) = spender {460				collection.check_allowlist(spender)?;461			}462		}463464		if let Some(spender) = spender {465			<PalletCommon<T>>::ensure_correct_receiver(spender)?;466		}467		let token_data =468			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;469		if &token_data.owner != sender {470			ensure!(471				collection.ignores_owned_amount(sender),472				<CommonError<T>>::CantApproveMoreThanOwned473			);474		}475476		// =========477478		Self::set_allowance_unchecked(collection, sender, token, spender, false);479		Ok(())480	}481482	pub fn transfer_from(483		collection: &NonfungibleHandle<T>,484		spender: &T::CrossAccountId,485		from: &T::CrossAccountId,486		to: &T::CrossAccountId,487		token: TokenId,488	) -> DispatchResult {489		if spender.conv_eq(from) {490			return Self::transfer(collection, from, to, token);491		}492		if collection.access == AccessMode::AllowList {493			// `from`, `to` checked in [`transfer`]494			collection.check_allowlist(spender)?;495		}496497		if <Allowance<T>>::get((collection.id, token)).as_ref() != Some(spender) {498			ensure!(499				collection.ignores_allowance(spender),500				<CommonError<T>>::TokenValueNotEnough501			);502		}503504		// =========505506		Self::transfer(collection, from, to, token)?;507		// Allowance is reset in [`transfer`]508		Ok(())509	}510511	pub fn burn_from(512		collection: &NonfungibleHandle<T>,513		spender: &T::CrossAccountId,514		from: &T::CrossAccountId,515		token: TokenId,516	) -> DispatchResult {517		if spender.conv_eq(from) {518			return Self::burn(collection, from, token);519		}520		if collection.access == AccessMode::AllowList {521			// `from` checked in [`burn`]522			collection.check_allowlist(spender)?;523		}524525		if <Allowance<T>>::get((collection.id, token)).as_ref() != Some(spender) {526			ensure!(527				collection.ignores_allowance(spender),528				<CommonError<T>>::TokenValueNotEnough529			);530		}531532		// =========533534		Self::burn(collection, from, token)535	}536537	pub fn set_variable_metadata(538		collection: &NonfungibleHandle<T>,539		sender: &T::CrossAccountId,540		token: TokenId,541		data: BoundedVec<u8, CustomDataLimit>,542	) -> DispatchResult {543		let token_data =544			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;545		collection.check_can_update_meta(sender, &token_data.owner)?;546547		// =========548549		<TokenData<T>>::insert(550			(collection.id, token),551			ItemData {552				variable_data: data,553				..token_data554			},555		);556		Ok(())557	}558559	/// Delegated to `create_multiple_items`560	pub fn create_item(561		collection: &NonfungibleHandle<T>,562		sender: &T::CrossAccountId,563		data: CreateItemData<T>,564	) -> DispatchResult {565		Self::create_multiple_items(collection, sender, vec![data])566	}567}