git.delta.rocks / unique-network / refs/commits / 11621bb1723c

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617#![cfg_attr(not(feature = "std"), no_std)]1819use erc::ERC721Events;20use frame_support::{BoundedVec, ensure, fail};21use up_data_structs::{22	AccessMode, CollectionId, CustomDataLimit, TokenId, CreateCollectionData, CreateNftExData,23	mapping::TokenAddressMapping, NestingRule,24};25use pallet_evm::account::CrossAccountId;26use pallet_common::{27	Error as CommonError, Pallet as PalletCommon, Event as CommonEvent,28	CollectionHandle, dispatch::CollectionDispatch,29};30use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};31use sp_core::H160;32use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};33use sp_std::{vec::Vec, vec};34use core::ops::Deref;35use sp_std::collections::btree_map::BTreeMap;36use codec::{Encode, Decode, MaxEncodedLen};37use scale_info::TypeInfo;3839pub use pallet::*;40#[cfg(feature = "runtime-benchmarks")]41pub mod benchmarking;42pub mod common;43pub mod erc;44pub mod weights;4546pub type CreateItemData<T> = CreateNftExData<<T as pallet_evm::account::Config>::CrossAccountId>;47pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;4849#[derive(Encode, Decode, TypeInfo, MaxEncodedLen)]50pub struct ItemData<CrossAccountId> {51	pub const_data: BoundedVec<u8, CustomDataLimit>,52	pub variable_data: BoundedVec<u8, CustomDataLimit>,53	pub owner: CrossAccountId,54}5556#[frame_support::pallet]57pub mod pallet {58	use super::*;59	use frame_support::{Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key};60	use up_data_structs::{CollectionId, TokenId};61	use super::weights::WeightInfo;6263	#[pallet::error]64	pub enum Error<T> {65		/// Not Nonfungible item data used to mint in Nonfungible collection.66		NotNonfungibleDataUsedToMintFungibleCollectionToken,67		/// Used amount > 1 with NFT68		NonfungibleItemsHaveNoAmount,69	}7071	#[pallet::config]72	pub trait Config: frame_system::Config + pallet_common::Config {73		type WeightInfo: WeightInfo;74	}7576	#[pallet::pallet]77	#[pallet::generate_store(pub(super) trait Store)]78	pub struct Pallet<T>(_);7980	#[pallet::storage]81	pub type TokensMinted<T: Config> =82		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;83	#[pallet::storage]84	pub type TokensBurnt<T: Config> =85		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;8687	#[pallet::storage]88	pub type TokenData<T: Config> = StorageNMap<89		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),90		Value = ItemData<T::CrossAccountId>,91		QueryKind = OptionQuery,92	>;9394	/// Used to enumerate tokens owned by account95	#[pallet::storage]96	pub type Owned<T: Config> = StorageNMap<97		Key = (98			Key<Twox64Concat, CollectionId>,99			Key<Blake2_128Concat, T::CrossAccountId>,100			Key<Twox64Concat, TokenId>,101		),102		Value = bool,103		QueryKind = ValueQuery,104	>;105106	#[pallet::storage]107	pub type AccountBalance<T: Config> = StorageNMap<108		Key = (109			Key<Twox64Concat, CollectionId>,110			Key<Blake2_128Concat, T::CrossAccountId>,111		),112		Value = u32,113		QueryKind = ValueQuery,114	>;115116	#[pallet::storage]117	pub type Allowance<T: Config> = StorageNMap<118		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),119		Value = T::CrossAccountId,120		QueryKind = OptionQuery,121	>;122}123124pub struct NonfungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);125impl<T: Config> NonfungibleHandle<T> {126	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {127		Self(inner)128	}129	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {130		self.0131	}132}133impl<T: Config> WithRecorder<T> for NonfungibleHandle<T> {134	fn recorder(&self) -> &SubstrateRecorder<T> {135		self.0.recorder()136	}137	fn into_recorder(self) -> SubstrateRecorder<T> {138		self.0.into_recorder()139	}140}141impl<T: Config> Deref for NonfungibleHandle<T> {142	type Target = pallet_common::CollectionHandle<T>;143144	fn deref(&self) -> &Self::Target {145		&self.0146	}147}148149impl<T: Config> Pallet<T> {150	pub fn total_supply(collection: &NonfungibleHandle<T>) -> u32 {151		<TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)152	}153	pub fn token_exists(collection: &NonfungibleHandle<T>, token: TokenId) -> bool {154		<TokenData<T>>::contains_key((collection.id, token))155	}156}157158// unchecked calls skips any permission checks159impl<T: Config> Pallet<T> {160	pub fn init_collection(161		owner: T::AccountId,162		data: CreateCollectionData<T::AccountId>,163	) -> Result<CollectionId, DispatchError> {164		<PalletCommon<T>>::init_collection(owner, data)165	}166	pub fn destroy_collection(167		collection: NonfungibleHandle<T>,168		sender: &T::CrossAccountId,169	) -> DispatchResult {170		let id = collection.id;171172		// =========173174		PalletCommon::destroy_collection(collection.0, sender)?;175176		<TokenData<T>>::remove_prefix((id,), None);177		<Owned<T>>::remove_prefix((id,), None);178		<TokensMinted<T>>::remove(id);179		<TokensBurnt<T>>::remove(id);180		<Allowance<T>>::remove_prefix((id,), None);181		<AccountBalance<T>>::remove_prefix((id,), None);182		Ok(())183	}184185	pub fn burn(186		collection: &NonfungibleHandle<T>,187		sender: &T::CrossAccountId,188		token: TokenId,189	) -> DispatchResult {190		let token_data =191			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;192		ensure!(193			&token_data.owner == sender194				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(sender)),195			<CommonError<T>>::NoPermission196		);197198		if collection.access == AccessMode::AllowList {199			collection.check_allowlist(sender)?;200		}201202		let burnt = <TokensBurnt<T>>::get(collection.id)203			.checked_add(1)204			.ok_or(ArithmeticError::Overflow)?;205206		let balance = <AccountBalance<T>>::get((collection.id, token_data.owner.clone()))207			.checked_sub(1)208			.ok_or(ArithmeticError::Overflow)?;209210		if balance == 0 {211			<AccountBalance<T>>::remove((collection.id, token_data.owner.clone()));212		} else {213			<AccountBalance<T>>::insert((collection.id, token_data.owner.clone()), balance);214		}215		// =========216217		<Owned<T>>::remove((collection.id, &token_data.owner, token));218		<TokensBurnt<T>>::insert(collection.id, burnt);219		<TokenData<T>>::remove((collection.id, token));220		let old_spender = <Allowance<T>>::take((collection.id, token));221222		if let Some(old_spender) = old_spender {223			<PalletCommon<T>>::deposit_event(CommonEvent::Approved(224				collection.id,225				token,226				sender.clone(),227				old_spender,228				0,229			));230		}231232		collection.log_mirrored(ERC721Events::Transfer {233			from: *token_data.owner.as_eth(),234			to: H160::default(),235			token_id: token.into(),236		});237		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(238			collection.id,239			token,240			token_data.owner,241			1,242		));243		Ok(())244	}245246	pub fn transfer(247		collection: &NonfungibleHandle<T>,248		from: &T::CrossAccountId,249		to: &T::CrossAccountId,250		token: TokenId,251	) -> DispatchResult {252		ensure!(253			collection.limits.transfers_enabled(),254			<CommonError<T>>::TransferNotAllowed255		);256257		let token_data =258			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;259		ensure!(260			&token_data.owner == from261				|| (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(from)),262			<CommonError<T>>::NoPermission263		);264265		if collection.access == AccessMode::AllowList {266			collection.check_allowlist(from)?;267			collection.check_allowlist(to)?;268		}269		<PalletCommon<T>>::ensure_correct_receiver(to)?;270271		let balance_from = <AccountBalance<T>>::get((collection.id, from))272			.checked_sub(1)273			.ok_or(<CommonError<T>>::TokenValueTooLow)?;274		let balance_to = if from != to {275			let balance_to = <AccountBalance<T>>::get((collection.id, to))276				.checked_add(1)277				.ok_or(ArithmeticError::Overflow)?;278279			ensure!(280				balance_to < collection.limits.account_token_ownership_limit(),281				<CommonError<T>>::AccountTokenLimitExceeded,282			);283284			Some(balance_to)285		} else {286			None287		};288289		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();293294			// =========295296			dispatch.nest_token(from.clone(), (collection.id, token), target.1)?;297		}298299		<TokenData<T>>::insert(300			(collection.id, token),301			ItemData {302				owner: to.clone(),303				..token_data304			},305		);306307		if let Some(balance_to) = balance_to {308			// from != to309			if balance_from == 0 {310				<AccountBalance<T>>::remove((collection.id, from));311			} else {312				<AccountBalance<T>>::insert((collection.id, from), balance_from);313			}314			<AccountBalance<T>>::insert((collection.id, to), balance_to);315			<Owned<T>>::remove((collection.id, from, token));316			<Owned<T>>::insert((collection.id, to, token), true);317		}318		Self::set_allowance_unchecked(collection, from, token, None, true);319320		collection.log_mirrored(ERC721Events::Transfer {321			from: *from.as_eth(),322			to: *to.as_eth(),323			token_id: token.into(),324		});325		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(326			collection.id,327			token,328			from.clone(),329			to.clone(),330			1,331		));332		Ok(())333	}334335	pub fn create_multiple_items(336		collection: &NonfungibleHandle<T>,337		sender: &T::CrossAccountId,338		data: Vec<CreateItemData<T>>,339	) -> DispatchResult {340		if !collection.is_owner_or_admin(sender) {341			ensure!(342				collection.mint_mode,343				<CommonError<T>>::PublicMintingNotAllowed344			);345			collection.check_allowlist(sender)?;346347			for item in data.iter() {348				collection.check_allowlist(&item.owner)?;349			}350		}351352		for data in data.iter() {353			<PalletCommon<T>>::ensure_correct_receiver(&data.owner)?;354		}355356		let first_token = <TokensMinted<T>>::get(collection.id);357		let tokens_minted = first_token358			.checked_add(data.len() as u32)359			.ok_or(ArithmeticError::Overflow)?;360		ensure!(361			tokens_minted <= collection.limits.token_limit(),362			<CommonError<T>>::CollectionTokenLimitExceeded363		);364365		let mut balances = BTreeMap::new();366		for data in &data {367			let balance = balances368				.entry(&data.owner)369				.or_insert_with(|| <AccountBalance<T>>::get((collection.id, &data.owner)));370			*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;371372			ensure!(373				*balance <= collection.limits.account_token_ownership_limit(),374				<CommonError<T>>::AccountTokenLimitExceeded,375			);376		}377378		// =========379380		<TokensMinted<T>>::insert(collection.id, tokens_minted);381		for (account, balance) in balances {382			<AccountBalance<T>>::insert((collection.id, account), balance);383		}384		for (i, data) in data.into_iter().enumerate() {385			let token = first_token + i as u32 + 1;386387			<TokenData<T>>::insert(388				(collection.id, token),389				ItemData {390					const_data: data.const_data,391					variable_data: data.variable_data,392					owner: data.owner.clone(),393				},394			);395			<Owned<T>>::insert((collection.id, &data.owner, token), true);396397			collection.log_mirrored(ERC721Events::Transfer {398				from: H160::default(),399				to: *data.owner.as_eth(),400				token_id: token.into(),401			});402			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(403				collection.id,404				TokenId(token),405				data.owner.clone(),406				1,407			));408		}409		Ok(())410	}411412	pub fn set_allowance_unchecked(413		collection: &NonfungibleHandle<T>,414		sender: &T::CrossAccountId,415		token: TokenId,416		spender: Option<&T::CrossAccountId>,417		assume_implicit_eth: bool,418	) {419		if let Some(spender) = spender {420			let old_spender = <Allowance<T>>::get((collection.id, token));421			<Allowance<T>>::insert((collection.id, token), spender);422			// In ERC721 there is only one possible approved user of token, so we set423			// approved user to spender424			collection.log_mirrored(ERC721Events::Approval {425				owner: *sender.as_eth(),426				approved: *spender.as_eth(),427				token_id: token.into(),428			});429			// In Unique chain, any token can have any amount of approved users, so we need to430			// set allowance of old owner to 0, and allowance of new owner to 1431			if old_spender.as_ref() != Some(spender) {432				if let Some(old_owner) = old_spender {433					<PalletCommon<T>>::deposit_event(CommonEvent::Approved(434						collection.id,435						token,436						sender.clone(),437						old_owner,438						0,439					));440				}441				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(442					collection.id,443					token,444					sender.clone(),445					spender.clone(),446					1,447				));448			}449		} else {450			let old_spender = <Allowance<T>>::take((collection.id, token));451			if !assume_implicit_eth {452				// In ERC721 there is only one possible approved user of token, so we set453				// approved user to zero address454				collection.log_mirrored(ERC721Events::Approval {455					owner: *sender.as_eth(),456					approved: H160::default(),457					token_id: token.into(),458				});459			}460			// In Unique chain, any token can have any amount of approved users, so we need to461			// set allowance of old owner to 0462			if let Some(old_spender) = old_spender {463				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(464					collection.id,465					token,466					sender.clone(),467					old_spender,468					0,469				));470			}471		}472	}473474	pub fn set_allowance(475		collection: &NonfungibleHandle<T>,476		sender: &T::CrossAccountId,477		token: TokenId,478		spender: Option<&T::CrossAccountId>,479	) -> DispatchResult {480		if collection.access == AccessMode::AllowList {481			collection.check_allowlist(sender)?;482			if let Some(spender) = spender {483				collection.check_allowlist(spender)?;484			}485		}486487		if let Some(spender) = spender {488			<PalletCommon<T>>::ensure_correct_receiver(spender)?;489		}490		let token_data =491			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;492		if &token_data.owner != sender {493			ensure!(494				collection.ignores_owned_amount(sender),495				<CommonError<T>>::CantApproveMoreThanOwned496			);497		}498499		// =========500501		Self::set_allowance_unchecked(collection, sender, token, spender, false);502		Ok(())503	}504505	pub fn transfer_from(506		collection: &NonfungibleHandle<T>,507		spender: &T::CrossAccountId,508		from: &T::CrossAccountId,509		to: &T::CrossAccountId,510		token: TokenId,511	) -> DispatchResult {512		if spender.conv_eq(from) {513			return Self::transfer(collection, from, to, token);514		}515		if collection.access == AccessMode::AllowList {516			// `from`, `to` checked in [`transfer`]517			collection.check_allowlist(spender)?;518		}519520		if <Allowance<T>>::get((collection.id, token)).as_ref() != Some(spender) {521			ensure!(522				collection.ignores_allowance(spender),523				<CommonError<T>>::ApprovedValueTooLow524			);525		}526527		// =========528529		Self::transfer(collection, from, to, token)?;530		// Allowance is reset in [`transfer`]531		Ok(())532	}533534	pub fn burn_from(535		collection: &NonfungibleHandle<T>,536		spender: &T::CrossAccountId,537		from: &T::CrossAccountId,538		token: TokenId,539	) -> DispatchResult {540		if spender.conv_eq(from) {541			return Self::burn(collection, from, token);542		}543		if collection.access == AccessMode::AllowList {544			// `from` checked in [`burn`]545			collection.check_allowlist(spender)?;546		}547548		if <Allowance<T>>::get((collection.id, token)).as_ref() != Some(spender) {549			ensure!(550				collection.ignores_allowance(spender),551				<CommonError<T>>::ApprovedValueTooLow552			);553		}554555		// =========556557		Self::burn(collection, from, token)558	}559560	pub fn set_variable_metadata(561		collection: &NonfungibleHandle<T>,562		sender: &T::CrossAccountId,563		token: TokenId,564		data: BoundedVec<u8, CustomDataLimit>,565	) -> DispatchResult {566		let token_data =567			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;568		collection.check_can_update_meta(sender, &token_data.owner)?;569570		// =========571572		<TokenData<T>>::insert(573			(collection.id, token),574			ItemData {575				variable_data: data,576				..token_data577			},578		);579		Ok(())580	}581582	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					.owner597					.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>>::SourceCollectionIsNotAllowedToNest609				);610				ensure_sender_allowed::<T>(from, under, sender)?611			}612		}613		Ok(())614	}615616	/// Delegated to `create_multiple_items`617	pub fn create_item(618		collection: &NonfungibleHandle<T>,619		sender: &T::CrossAccountId,620		data: CreateItemData<T>,621	) -> DispatchResult {622		Self::create_multiple_items(collection, sender, vec![data])623	}624}