git.delta.rocks / unique-network / refs/commits / 4e1bd65c37e5

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};1718pub use pallet::*;19#[cfg(feature = "runtime-benchmarks")]20pub mod benchmarking;21pub mod common;22pub mod erc;23pub mod weights;2425pub struct CreateItemData<T: Config> {26	pub const_data: BoundedVec<u8, CustomDataLimit>,27	pub variable_data: BoundedVec<u8, CustomDataLimit>,28	pub owner: T::CrossAccountId,29}30pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;3132#[derive(Encode, Decode)]33pub struct ItemData<T: Config> {34	pub const_data: Vec<u8>,35	pub variable_data: Vec<u8>,36	pub owner: T::CrossAccountId,37}3839#[frame_support::pallet]40pub mod pallet {41	use super::*;42	use frame_support::{Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key};43	use nft_data_structs::{CollectionId, TokenId};44	use super::weights::WeightInfo;4546	#[pallet::error]47	pub enum Error<T> {48		/// Not Nonfungible item data used to mint in Nonfungible collection.49		NotNonfungibleDataUsedToMintFungibleCollectionToken,50		/// Used amount > 1 with NFT51		NonfungibleItemsHaveNoAmount,52	}5354	#[pallet::config]55	pub trait Config: frame_system::Config + pallet_common::Config {56		type WeightInfo: WeightInfo;57	}5859	#[pallet::pallet]60	#[pallet::generate_store(pub(super) trait Store)]61	pub struct Pallet<T>(_);6263	#[pallet::storage]64	pub(super) type TokensMinted<T: Config> =65		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;66	#[pallet::storage]67	pub(super) type TokensBurnt<T: Config> =68		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;6970	#[pallet::storage]71	pub(super) type TokenData<T: Config> = StorageNMap<72		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),73		Value = ItemData<T>,74		QueryKind = OptionQuery,75	>;7677	/// Used to enumerate tokens owned by account78	#[pallet::storage]79	pub(super) type Owned<T: Config> = StorageNMap<80		Key = (81			Key<Twox64Concat, CollectionId>,82			Key<Blake2_128Concat, T::AccountId>,83			Key<Twox64Concat, TokenId>,84		),85		Value = bool,86		QueryKind = ValueQuery,87	>;8889	#[pallet::storage]90	pub(super) type AccountBalance<T: Config> = StorageNMap<91		Key = (92			Key<Twox64Concat, CollectionId>,93			Key<Blake2_128Concat, T::AccountId>,94		),95		Value = u32,96		QueryKind = ValueQuery,97	>;9899	#[pallet::storage]100	pub(super) type Allowance<T: Config> = StorageNMap<101		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),102		Value = T::CrossAccountId,103		QueryKind = OptionQuery,104	>;105}106107pub struct NonfungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);108impl<T: Config> NonfungibleHandle<T> {109	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {110		Self(inner)111	}112	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {113		self.0114	}115}116impl<T: Config> Deref for NonfungibleHandle<T> {117	type Target = pallet_common::CollectionHandle<T>;118119	fn deref(&self) -> &Self::Target {120		&self.0121	}122}123124impl<T: Config> Pallet<T> {125	pub fn total_supply(collection: &NonfungibleHandle<T>) -> u32 {126		<TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)127	}128	pub fn token_exists(collection: &NonfungibleHandle<T>, token: TokenId) -> bool {129		<TokenData<T>>::contains_key((collection.id, token))130	}131}132133// unchecked calls skips any permission checks134impl<T: Config> Pallet<T> {135	pub fn init_collection(data: Collection<T>) -> Result<CollectionId, DispatchError> {136		PalletCommon::init_collection(data)137	}138	pub fn destroy_collection(139		collection: NonfungibleHandle<T>,140		sender: &T::CrossAccountId,141	) -> DispatchResult {142		let id = collection.id;143144		// =========145146		PalletCommon::destroy_collection(collection.0, sender)?;147148		<TokenData<T>>::remove_prefix((id,), None);149		<Owned<T>>::remove_prefix((id,), None);150		<TokensMinted<T>>::remove(id);151		<TokensBurnt<T>>::remove(id);152		<Allowance<T>>::remove_prefix((id,), None);153		<AccountBalance<T>>::remove_prefix((id,), None);154		Ok(())155	}156157	pub fn burn(158		collection: &NonfungibleHandle<T>,159		sender: &T::CrossAccountId,160		token: TokenId,161	) -> DispatchResult {162		let token_data = <TokenData<T>>::get((collection.id, token))163			.ok_or_else(|| <CommonError<T>>::TokenNotFound)?;164		ensure!(165			&token_data.owner == sender166				|| (collection.limits.owner_can_transfer167					&& collection.is_owner_or_admin(sender)?),168			<CommonError<T>>::NoPermission169		);170171		if collection.access == AccessMode::WhiteList {172			collection.check_allowlist(sender)?;173		}174175		let burnt = <TokensBurnt<T>>::get(collection.id)176			.checked_add(1)177			.ok_or(ArithmeticError::Overflow)?;178179		// =========180181		<Owned<T>>::remove((collection.id, token_data.owner.as_sub(), token));182		<TokensBurnt<T>>::insert(collection.id, burnt);183		<TokenData<T>>::remove((collection.id, token));184		let old_spender = <Allowance<T>>::take((collection.id, token));185186		if let Some(old_spender) = old_spender {187			<PalletCommon<T>>::deposit_event(CommonEvent::Approved(188				collection.id,189				token,190				sender.clone(),191				old_spender.clone(),192				0,193			));194		}195196		collection.log_infallible(ERC721Events::Transfer {197			from: *token_data.owner.as_eth(),198			to: H160::default(),199			token_id: token.into(),200		});201		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(202			collection.id,203			token,204			token_data.owner,205			1,206		));207		return Ok(());208	}209210	pub fn transfer(211		collection: &NonfungibleHandle<T>,212		from: &T::CrossAccountId,213		to: &T::CrossAccountId,214		token: TokenId,215	) -> DispatchResult {216		ensure!(217			collection.transfers_enabled,218			<CommonError<T>>::TransferNotAllowed219		);220221		let token_data = <TokenData<T>>::get((collection.id, token))222			.ok_or_else(|| <CommonError<T>>::TokenNotFound)?;223		ensure!(224			&token_data.owner == from225				|| (collection.limits.owner_can_transfer && collection.is_owner_or_admin(from)?),226			<CommonError<T>>::NoPermission227		);228229		if collection.access == AccessMode::WhiteList {230			collection.check_allowlist(from)?;231			collection.check_allowlist(to)?;232		}233		<PalletCommon<T>>::ensure_correct_receiver(to)?;234235		let balance_from = <AccountBalance<T>>::get((collection.id, from.as_sub()))236			.checked_sub(1)237			.ok_or(<CommonError<T>>::TokenValueTooLow)?;238		let balance_to = if from != to {239			let balance_to = <AccountBalance<T>>::get((collection.id, to.as_sub()))240				.checked_add(1)241				.ok_or(ArithmeticError::Overflow)?;242243			ensure!(244				balance_to < collection.limits.account_token_ownership_limit(),245				<CommonError<T>>::AccountTokenLimitExceeded,246			);247248			Some(balance_to)249		} else {250			None251		};252253		collection.consume_sstores(4)?;254		collection.consume_log(3, 0)?;255256		// =========257258		<TokenData<T>>::insert(259			(collection.id, token),260			ItemData {261				owner: to.clone(),262				..token_data263			},264		);265266		if let Some(balance_to) = balance_to {267			// from != to268			if balance_from == 0 {269				<AccountBalance<T>>::remove((collection.id, from.as_sub()));270			} else {271				<AccountBalance<T>>::insert((collection.id, from.as_sub()), balance_from);272			}273			<AccountBalance<T>>::insert((collection.id, to.as_sub()), balance_to);274			<Owned<T>>::remove((collection.id, from.as_sub(), token));275			<Owned<T>>::insert((collection.id, to.as_sub(), token), true);276		}277		Self::set_allowance_unchecked(collection, from, token, None);278279		collection.log_infallible(ERC721Events::Transfer {280			from: *from.as_eth(),281			to: *to.as_eth(),282			token_id: token.into(),283		});284		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(285			collection.id,286			token,287			from.clone(),288			to.clone(),289			1,290		));291		Ok(())292	}293294	pub fn create_multiple_items(295		collection: &NonfungibleHandle<T>,296		sender: &T::CrossAccountId,297		data: Vec<CreateItemData<T>>,298	) -> DispatchResult {299		let unrestricted_minting = collection.is_owner_or_admin(sender)?;300		if !unrestricted_minting {301			ensure!(302				collection.mint_mode,303				<CommonError<T>>::PublicMintingNotAllowed304			);305			collection.check_allowlist(sender)?;306307			for item in data.iter() {308				collection.check_allowlist(&item.owner)?;309			}310		}311312		for data in data.iter() {313			<PalletCommon<T>>::ensure_correct_receiver(&data.owner)?;314			if !data.const_data.is_empty() {315				collection.consume_sstore()?;316			}317			if !data.variable_data.is_empty() {318				collection.consume_sstore()?;319			}320			collection.consume_sstore()?;321			collection.consume_log(3, 0)?;322		}323324		let first_token = <TokensMinted<T>>::get(collection.id);325		let tokens_minted = first_token326			.checked_add(data.len() as u32)327			.ok_or(ArithmeticError::Overflow)?;328		ensure!(329			tokens_minted < collection.limits.token_limit,330			<CommonError<T>>::CollectionTokenLimitExceeded331		);332		collection.consume_sstore()?;333334		let mut balances = BTreeMap::new();335		for data in &data {336			let balance = balances337				.entry(data.owner.as_sub())338				.or_insert_with(|| <AccountBalance<T>>::get((collection.id, data.owner.as_sub())));339			*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;340341			ensure!(342				*balance <= collection.limits.account_token_ownership_limit(),343				<CommonError<T>>::AccountTokenLimitExceeded,344			);345		}346		collection.consume_sstores(balances.len())?;347348		// =========349350		<TokensMinted<T>>::insert(collection.id, tokens_minted);351		for (account, balance) in balances {352			<AccountBalance<T>>::insert((collection.id, account), balance);353		}354		for (i, data) in data.into_iter().enumerate() {355			let token = first_token + i as u32 + 1;356357			<TokenData<T>>::insert(358				(collection.id, token),359				ItemData {360					const_data: data.const_data.into(),361					variable_data: data.variable_data.into(),362					owner: data.owner.clone(),363				},364			);365			<Owned<T>>::insert((collection.id, data.owner.as_sub(), token), true);366367			collection.log_infallible(ERC721Events::Transfer {368				from: H160::default(),369				to: *data.owner.as_eth(),370				token_id: token.into(),371			});372			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(373				collection.id,374				TokenId(token),375				data.owner.clone(),376				1,377			));378		}379		Ok(())380	}381382	pub fn set_allowance_unchecked(383		collection: &NonfungibleHandle<T>,384		sender: &T::CrossAccountId,385		token: TokenId,386		spender: Option<&T::CrossAccountId>,387	) {388		if let Some(spender) = spender {389			let old_spender = <Allowance<T>>::get((collection.id, token));390			<Allowance<T>>::insert((collection.id, token), spender);391			// In ERC721 there is only one possible approved user of token, so we set392			// approved user to spender393			collection.log_infallible(ERC721Events::Approval {394				owner: *sender.as_eth(),395				approved: *spender.as_eth(),396				token_id: token.into(),397			});398			// In Unique chain, any token can have any amount of approved users, so we need to399			// set allowance of old owner to 0, and allowance of new owner to 1400			if old_spender.as_ref() != Some(spender) {401				if let Some(old_owner) = old_spender {402					<PalletCommon<T>>::deposit_event(CommonEvent::Approved(403						collection.id,404						token,405						sender.clone(),406						old_owner.clone(),407						0,408					));409				}410				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(411					collection.id,412					token,413					sender.clone(),414					spender.clone(),415					1,416				));417			}418		} else {419			let old_spender = <Allowance<T>>::take((collection.id, token));420			// In ERC721 there is only one possible approved user of token, so we set421			// approved user to zero address422			collection.log_infallible(ERC721Events::Approval {423				owner: *sender.as_eth(),424				approved: H160::default(),425				token_id: token.into(),426			});427			// In Unique chain, any token can have any amount of approved users, so we need to428			// set allowance of old owner to 0429			if let Some(old_spender) = old_spender {430				<PalletCommon<T>>::deposit_event(CommonEvent::Approved(431					collection.id,432					token,433					sender.clone(),434					old_spender.clone(),435					0,436				));437			}438		}439	}440441	pub fn set_allowance(442		collection: &NonfungibleHandle<T>,443		sender: &T::CrossAccountId,444		token: TokenId,445		spender: Option<&T::CrossAccountId>,446	) -> DispatchResult {447		if collection.access == AccessMode::WhiteList {448			collection.check_allowlist(&sender)?;449			if let Some(spender) = spender {450				collection.check_allowlist(&spender)?;451			}452		}453454		if let Some(spender) = spender {455			<PalletCommon<T>>::ensure_correct_receiver(spender)?;456		}457		let token_data =458			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;459		if &token_data.owner != sender {460			ensure!(461				collection.ignores_owned_amount(sender)?,462				<CommonError<T>>::CantApproveMoreThanOwned463			);464		}465466		// =========467468		Self::set_allowance_unchecked(collection, sender, token, spender);469		Ok(())470	}471472	pub fn transfer_from(473		collection: &NonfungibleHandle<T>,474		spender: &T::CrossAccountId,475		from: &T::CrossAccountId,476		to: &T::CrossAccountId,477		token: TokenId,478	) -> DispatchResult {479		if spender == from {480			return Self::transfer(collection, from, to, token);481		}482		if collection.access == AccessMode::WhiteList {483			// `from`, `to` checked in [`transfer`]484			collection.check_allowlist(spender)?;485		}486487		if <Allowance<T>>::get((collection.id, token)).as_ref() != Some(spender) {488			ensure!(489				collection.ignores_allowance(spender)?,490				<CommonError<T>>::TokenValueNotEnough491			);492		}493494		// =========495496		Self::transfer(collection, &from, to, token)?;497		// Allowance is reset in [`transfer`]498		Ok(())499	}500501	pub fn set_variable_metadata(502		collection: &NonfungibleHandle<T>,503		sender: &T::CrossAccountId,504		token: TokenId,505		data: Vec<u8>,506	) -> DispatchResult {507		ensure!(508			data.len() as u32 <= CUSTOM_DATA_LIMIT,509			<CommonError<T>>::TokenVariableDataLimitExceeded510		);511		let token_data =512			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;513		collection.check_can_update_meta(sender, &token_data.owner)?;514515		collection.consume_sstore()?;516517		// =========518519		<TokenData<T>>::insert(520			(collection.id, token),521			ItemData {522				variable_data: data,523				..token_data524			},525		);526		Ok(())527	}528529	/// Delegated to `create_multiple_items`530	pub fn create_item(531		collection: &NonfungibleHandle<T>,532		sender: &T::CrossAccountId,533		data: CreateItemData<T>,534	) -> DispatchResult {535		Self::create_multiple_items(collection, sender, vec![data])536	}537}