git.delta.rocks / unique-network / refs/commits / f8774b896e5b

1#![cfg_attr(not(feature = "std"), no_std)]23use erc::ERC721Events;4use frame_support::{BoundedVec, ensure};5use nft_data_structs::{6	AccessMode, CUSTOM_DATA_LIMIT, Collection, CollectionId, CustomDataLimit, TokenId,7};8use pallet_common::{9	Error as CommonError, Pallet as PalletCommon, Event as CommonEvent, account::CrossAccountId,10};11use sp_core::H160;12use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};13use sp_std::{vec::Vec, vec};14use core::ops::Deref;15use sp_std::collections::btree_map::BTreeMap;16use codec::{Encode, Decode};17use scale_info::TypeInfo;1819pub use pallet::*;20#[cfg(feature = "runtime-benchmarks")]21pub mod benchmarking;22pub mod common;23pub mod erc;24pub mod weights;2526pub struct CreateItemData<T: Config> {27	pub const_data: BoundedVec<u8, CustomDataLimit>,28	pub variable_data: BoundedVec<u8, CustomDataLimit>,29	pub owner: T::CrossAccountId,30}31pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;3233#[derive(Encode, Decode, TypeInfo)]34pub struct ItemData<T: Config> {35	pub const_data: Vec<u8>,36	pub variable_data: Vec<u8>,37	pub owner: T::CrossAccountId,38}3940#[frame_support::pallet]41pub mod pallet {42	use super::*;43	use frame_support::{Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key};44	use nft_data_structs::{CollectionId, TokenId};45	use super::weights::WeightInfo;4647	#[pallet::error]48	pub enum Error<T> {49		/// Not Nonfungible item data used to mint in Nonfungible collection.50		NotNonfungibleDataUsedToMintFungibleCollectionToken,51		/// Used amount > 1 with NFT52		NonfungibleItemsHaveNoAmount,53	}5455	#[pallet::config]56	pub trait Config: frame_system::Config + pallet_common::Config {57		type WeightInfo: WeightInfo;58	}5960	#[pallet::pallet]61	#[pallet::generate_store(pub(super) trait Store)]62	pub struct Pallet<T>(_);6364	#[pallet::storage]65	pub(super) type TokensMinted<T: Config> =66		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;67	#[pallet::storage]68	pub(super) type TokensBurnt<T: Config> =69		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;7071	#[pallet::storage]72	pub(super) type TokenData<T: Config> = StorageNMap<73		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),74		Value = ItemData<T>,75		QueryKind = OptionQuery,76	>;7778	/// Used to enumerate tokens owned by account79	#[pallet::storage]80	pub(super) type Owned<T: Config> = StorageNMap<81		Key = (82			Key<Twox64Concat, CollectionId>,83			Key<Blake2_128Concat, T::CrossAccountId>,84			Key<Twox64Concat, TokenId>,85		),86		Value = bool,87		QueryKind = ValueQuery,88	>;8990	#[pallet::storage]91	pub(super) type AccountBalance<T: Config> = StorageNMap<92		Key = (93			Key<Twox64Concat, CollectionId>,94			Key<Blake2_128Concat, T::CrossAccountId>,95		),96		Value = u32,97		QueryKind = ValueQuery,98	>;99100	#[pallet::storage]101	pub(super) type Allowance<T: Config> = StorageNMap<102		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),103		Value = T::CrossAccountId,104		QueryKind = OptionQuery,105	>;106}107108pub struct NonfungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);109impl<T: Config> NonfungibleHandle<T> {110	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {111		Self(inner)112	}113	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {114		self.0115	}116}117impl<T: Config> Deref for NonfungibleHandle<T> {118	type Target = pallet_common::CollectionHandle<T>;119120	fn deref(&self) -> &Self::Target {121		&self.0122	}123}124125impl<T: Config> Pallet<T> {126	pub fn total_supply(collection: &NonfungibleHandle<T>) -> u32 {127		<TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)128	}129	pub fn token_exists(collection: &NonfungibleHandle<T>, token: TokenId) -> bool {130		<TokenData<T>>::contains_key((collection.id, token))131	}132}133134// unchecked calls skips any permission checks135impl<T: Config> Pallet<T> {136	pub fn init_collection(data: Collection<T>) -> Result<CollectionId, DispatchError> {137		PalletCommon::init_collection(data)138	}139	pub fn destroy_collection(140		collection: NonfungibleHandle<T>,141		sender: &T::CrossAccountId,142	) -> DispatchResult {143		let id = collection.id;144145		// =========146147		PalletCommon::destroy_collection(collection.0, sender)?;148149		<TokenData<T>>::remove_prefix((id,), None);150		<Owned<T>>::remove_prefix((id,), None);151		<TokensMinted<T>>::remove(id);152		<TokensBurnt<T>>::remove(id);153		<Allowance<T>>::remove_prefix((id,), None);154		<AccountBalance<T>>::remove_prefix((id,), None);155		Ok(())156	}157158	pub fn burn(159		collection: &NonfungibleHandle<T>,160		sender: &T::CrossAccountId,161		token: TokenId,162	) -> DispatchResult {163		let token_data = <TokenData<T>>::get((collection.id, token))164			.ok_or_else(|| <CommonError<T>>::TokenNotFound)?;165		ensure!(166			&token_data.owner == sender167				|| (collection.limits.owner_can_transfer()168					&& collection.is_owner_or_admin(sender)?),169			<CommonError<T>>::NoPermission170		);171172		if collection.access == AccessMode::AllowList {173			collection.check_allowlist(sender)?;174		}175176		let burnt = <TokensBurnt<T>>::get(collection.id)177			.checked_add(1)178			.ok_or(ArithmeticError::Overflow)?;179180		// =========181182		<Owned<T>>::remove((collection.id, &token_data.owner, token));183		<TokensBurnt<T>>::insert(collection.id, burnt);184		<TokenData<T>>::remove((collection.id, token));185		let old_spender = <Allowance<T>>::take((collection.id, token));186187		if let Some(old_spender) = old_spender {188			<PalletCommon<T>>::deposit_event(CommonEvent::Approved(189				collection.id,190				token,191				sender.clone(),192				old_spender.clone(),193				0,194			));195		}196197		collection.log_infallible(ERC721Events::Transfer {198			from: *token_data.owner.as_eth(),199			to: H160::default(),200			token_id: token.into(),201		});202		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(203			collection.id,204			token,205			token_data.owner,206			1,207		));208		return Ok(());209	}210211	pub fn transfer(212		collection: &NonfungibleHandle<T>,213		from: &T::CrossAccountId,214		to: &T::CrossAccountId,215		token: TokenId,216	) -> DispatchResult {217		ensure!(218			collection.limits.transfers_enabled(),219			<CommonError<T>>::TransferNotAllowed220		);221222		let token_data = <TokenData<T>>::get((collection.id, token))223			.ok_or_else(|| <CommonError<T>>::TokenNotFound)?;224		ensure!(225			&token_data.owner == from226				|| (collection.limits.owner_can_transfer()227					&& collection.is_owner_or_admin(from)?),228			<CommonError<T>>::NoPermission229		);230231		if collection.access == AccessMode::AllowList {232			collection.check_allowlist(from)?;233			collection.check_allowlist(to)?;234		}235		<PalletCommon<T>>::ensure_correct_receiver(to)?;236237		let balance_from = <AccountBalance<T>>::get((collection.id, from))238			.checked_sub(1)239			.ok_or(<CommonError<T>>::TokenValueTooLow)?;240		let balance_to = if from != to {241			let balance_to = <AccountBalance<T>>::get((collection.id, to))242				.checked_add(1)243				.ok_or(ArithmeticError::Overflow)?;244245			ensure!(246				balance_to < collection.limits.account_token_ownership_limit(),247				<CommonError<T>>::AccountTokenLimitExceeded,248			);249250			Some(balance_to)251		} else {252			None253		};254255		collection.consume_sstores(4)?;256		collection.consume_log(3, 0)?;257258		// =========259260		<TokenData<T>>::insert(261			(collection.id, token),262			ItemData {263				owner: to.clone(),264				..token_data265			},266		);267268		if let Some(balance_to) = balance_to {269			// from != to270			if balance_from == 0 {271				<AccountBalance<T>>::remove((collection.id, from));272			} else {273				<AccountBalance<T>>::insert((collection.id, from), balance_from);274			}275			<AccountBalance<T>>::insert((collection.id, to), balance_to);276			<Owned<T>>::remove((collection.id, from, token));277			<Owned<T>>::insert((collection.id, to, token), true);278		}279		Self::set_allowance_unchecked(collection, from, token, None, true);280281		collection.log_infallible(ERC721Events::Transfer {282			from: *from.as_eth(),283			to: *to.as_eth(),284			token_id: token.into(),285		});286		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(287			collection.id,288			token,289			from.clone(),290			to.clone(),291			1,292		));293		Ok(())294	}295296	pub fn create_multiple_items(297		collection: &NonfungibleHandle<T>,298		sender: &T::CrossAccountId,299		data: Vec<CreateItemData<T>>,300	) -> DispatchResult {301		let unrestricted_minting = collection.is_owner_or_admin(sender)?;302		if !unrestricted_minting {303			ensure!(304				collection.mint_mode,305				<CommonError<T>>::PublicMintingNotAllowed306			);307			collection.check_allowlist(sender)?;308309			for item in data.iter() {310				collection.check_allowlist(&item.owner)?;311			}312		}313314		for data in data.iter() {315			<PalletCommon<T>>::ensure_correct_receiver(&data.owner)?;316			if !data.const_data.is_empty() {317				collection.consume_sstore()?;318			}319			if !data.variable_data.is_empty() {320				collection.consume_sstore()?;321			}322			collection.consume_sstore()?;323			collection.consume_log(3, 0)?;324		}325326		let first_token = <TokensMinted<T>>::get(collection.id);327		let tokens_minted = first_token328			.checked_add(data.len() as u32)329			.ok_or(ArithmeticError::Overflow)?;330		ensure!(331			tokens_minted <= collection.limits.token_limit(),332			<CommonError<T>>::CollectionTokenLimitExceeded333		);334		collection.consume_sstore()?;335336		let mut balances = BTreeMap::new();337		for data in &data {338			let balance = balances339				.entry(&data.owner)340				.or_insert_with(|| <AccountBalance<T>>::get((collection.id, &data.owner)));341			*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;342343			ensure!(344				*balance <= collection.limits.account_token_ownership_limit(),345				<CommonError<T>>::AccountTokenLimitExceeded,346			);347		}348		collection.consume_sstores(balances.len())?;349350		// =========351352		<TokensMinted<T>>::insert(collection.id, tokens_minted);353		for (account, balance) in balances {354			<AccountBalance<T>>::insert((collection.id, account), balance);355		}356		for (i, data) in data.into_iter().enumerate() {357			let token = first_token + i as u32 + 1;358359			<TokenData<T>>::insert(360				(collection.id, token),361				ItemData {362					const_data: data.const_data.into(),363					variable_data: data.variable_data.into(),364					owner: data.owner.clone(),365				},366			);367			<Owned<T>>::insert((collection.id, &data.owner, token), true);368369			collection.log_infallible(ERC721Events::Transfer {370				from: H160::default(),371				to: *data.owner.as_eth(),372				token_id: token.into(),373			});374			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(375				collection.id,376				TokenId(token),377				data.owner.clone(),378				1,379			));380		}381		Ok(())382	}383384	pub fn set_allowance_unchecked(385		collection: &NonfungibleHandle<T>,386		sender: &T::CrossAccountId,387		token: TokenId,388		spender: Option<&T::CrossAccountId>,389		assume_implicit_eth: bool,390	) {391		if let Some(spender) = spender {392			let old_spender = <Allowance<T>>::get((collection.id, token));393			<Allowance<T>>::insert((collection.id, token), spender);394			// In ERC721 there is only one possible approved user of token, so we set395			// approved user to spender396			collection.log_infallible(ERC721Events::Approval {397				owner: *sender.as_eth(),398				approved: *spender.as_eth(),399				token_id: token.into(),400			});401			// In Unique chain, any token can have any amount of approved users, so we need to402			// set allowance of old owner to 0, and allowance of new owner to 1403			if old_spender.as_ref() != Some(spender) {404				if let Some(old_owner) = old_spender {405					<PalletCommon<T>>::deposit_event(CommonEvent::Approved(406						collection.id,407						token,408						sender.clone(),409						old_owner.clone(),410						0,411					));412				}413				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(414					collection.id,415					token,416					sender.clone(),417					spender.clone(),418					1,419				));420			}421		} else {422			let old_spender = <Allowance<T>>::take((collection.id, token));423			if !assume_implicit_eth {424				// In ERC721 there is only one possible approved user of token, so we set425				// approved user to zero address426				collection.log_infallible(ERC721Events::Approval {427					owner: *sender.as_eth(),428					approved: H160::default(),429					token_id: token.into(),430				});431			}432			// In Unique chain, any token can have any amount of approved users, so we need to433			// set allowance of old owner to 0434			if let Some(old_spender) = old_spender {435				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(436					collection.id,437					token,438					sender.clone(),439					old_spender.clone(),440					0,441				));442			}443		}444	}445446	pub fn set_allowance(447		collection: &NonfungibleHandle<T>,448		sender: &T::CrossAccountId,449		token: TokenId,450		spender: Option<&T::CrossAccountId>,451	) -> DispatchResult {452		if collection.access == AccessMode::AllowList {453			collection.check_allowlist(&sender)?;454			if let Some(spender) = spender {455				collection.check_allowlist(&spender)?;456			}457		}458459		if let Some(spender) = spender {460			<PalletCommon<T>>::ensure_correct_receiver(spender)?;461		}462		let token_data =463			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;464		if &token_data.owner != sender {465			ensure!(466				collection.ignores_owned_amount(sender)?,467				<CommonError<T>>::CantApproveMoreThanOwned468			);469		}470471		// =========472473		Self::set_allowance_unchecked(collection, sender, token, spender, false);474		Ok(())475	}476477	pub fn transfer_from(478		collection: &NonfungibleHandle<T>,479		spender: &T::CrossAccountId,480		from: &T::CrossAccountId,481		to: &T::CrossAccountId,482		token: TokenId,483	) -> DispatchResult {484		if spender.conv_eq(from) {485			return Self::transfer(collection, from, to, token);486		}487		if collection.access == AccessMode::AllowList {488			// `from`, `to` checked in [`transfer`]489			collection.check_allowlist(spender)?;490		}491492		if <Allowance<T>>::get((collection.id, token)).as_ref() != Some(spender) {493			ensure!(494				collection.ignores_allowance(spender)?,495				<CommonError<T>>::TokenValueNotEnough496			);497		}498499		// =========500501		Self::transfer(collection, &from, to, token)?;502		// Allowance is reset in [`transfer`]503		Ok(())504	}505506	pub fn burn_from(507		collection: &NonfungibleHandle<T>,508		spender: &T::CrossAccountId,509		from: &T::CrossAccountId,510		token: TokenId,511	) -> DispatchResult {512		if spender.conv_eq(from) {513			return Self::burn(collection, from, token);514		}515		if collection.access == AccessMode::AllowList {516			// `from` checked in [`burn`]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>>::TokenValueNotEnough524			);525		}526527		// =========528529		Self::burn(collection, &from, token)530	}531532	pub fn set_variable_metadata(533		collection: &NonfungibleHandle<T>,534		sender: &T::CrossAccountId,535		token: TokenId,536		data: Vec<u8>,537	) -> DispatchResult {538		ensure!(539			data.len() as u32 <= CUSTOM_DATA_LIMIT,540			<CommonError<T>>::TokenVariableDataLimitExceeded541		);542		let token_data =543			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;544		collection.check_can_update_meta(sender, &token_data.owner)?;545546		collection.consume_sstore()?;547548		// =========549550		<TokenData<T>>::insert(551			(collection.id, token),552			ItemData {553				variable_data: data,554				..token_data555			},556		);557		Ok(())558	}559560	/// Delegated to `create_multiple_items`561	pub fn create_item(562		collection: &NonfungibleHandle<T>,563		sender: &T::CrossAccountId,564		data: CreateItemData<T>,565	) -> DispatchResult {566		Self::create_multiple_items(collection, sender, vec![data])567	}568}