git.delta.rocks / unique-network / refs/commits / 9d51561e5bd0

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 frame_support::{ensure, BoundedVec};20use up_data_structs::{21	AccessMode, CollectionId, CustomDataLimit, MAX_REFUNGIBLE_PIECES, TokenId,22	CreateCollectionData, CreateRefungibleExData, mapping::TokenAddressMapping, budget::Budget,23};24use pallet_evm::account::CrossAccountId;25use pallet_common::{26	Error as CommonError, Event as CommonEvent, Pallet as PalletCommon,27};28use pallet_structure::Pallet as PalletStructure;29use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};30use sp_std::{vec::Vec, vec, collections::btree_map::BTreeMap};31use core::ops::Deref;32use codec::{Encode, Decode, MaxEncodedLen};33use scale_info::TypeInfo;3435pub use pallet::*;36#[cfg(feature = "runtime-benchmarks")]37pub mod benchmarking;38pub mod common;39pub mod erc;40pub mod weights;41pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;4243#[struct_versioning::versioned(version = 2, upper)]44#[derive(Encode, Decode, Default, TypeInfo, MaxEncodedLen)]45pub struct ItemData {46	pub const_data: BoundedVec<u8, CustomDataLimit>,4748	#[version(..2)]49	pub variable_data: BoundedVec<u8, CustomDataLimit>,50}5152#[frame_support::pallet]53pub mod pallet {54	use super::*;55	use frame_support::{56		Blake2_128, Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key,57		traits::StorageVersion,58	};59	use frame_system::pallet_prelude::*;60	use up_data_structs::{CollectionId, TokenId};61	use super::weights::WeightInfo;6263	#[pallet::error]64	pub enum Error<T> {65		/// Not Refungible item data used to mint in Refungible collection.66		NotRefungibleDataUsedToMintFungibleCollectionToken,67		/// Maximum refungibility exceeded68		WrongRefungiblePieces,69		/// Refungible token can't nest other tokens70		RefungibleDisallowsNesting,71		/// Setting item properties is not allowed72		SettingPropertiesNotAllowed,73	}7475	#[pallet::config]76	pub trait Config:77		frame_system::Config + pallet_common::Config + pallet_structure::Config78	{79		type WeightInfo: WeightInfo;80	}8182	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);8384	#[pallet::pallet]85	#[pallet::storage_version(STORAGE_VERSION)]86	#[pallet::generate_store(pub(super) trait Store)]87	pub struct Pallet<T>(_);8889	#[pallet::storage]90	pub type TokensMinted<T: Config> =91		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;92	#[pallet::storage]93	pub type TokensBurnt<T: Config> =94		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;9596	#[pallet::storage]97	pub type TokenData<T: Config> = StorageNMap<98		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),99		Value = ItemData,100		QueryKind = ValueQuery,101	>;102103	#[pallet::storage]104	pub type TotalSupply<T: Config> = StorageNMap<105		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),106		Value = u128,107		QueryKind = ValueQuery,108	>;109110	/// Used to enumerate tokens owned by account111	#[pallet::storage]112	pub type Owned<T: Config> = StorageNMap<113		Key = (114			Key<Twox64Concat, CollectionId>,115			Key<Blake2_128Concat, T::CrossAccountId>,116			Key<Twox64Concat, TokenId>,117		),118		Value = bool,119		QueryKind = ValueQuery,120	>;121122	#[pallet::storage]123	pub type AccountBalance<T: Config> = StorageNMap<124		Key = (125			Key<Twox64Concat, CollectionId>,126			// Owner127			Key<Blake2_128Concat, T::CrossAccountId>,128		),129		Value = u32,130		QueryKind = ValueQuery,131	>;132133	#[pallet::storage]134	pub type Balance<T: Config> = StorageNMap<135		Key = (136			Key<Twox64Concat, CollectionId>,137			Key<Twox64Concat, TokenId>,138			// Owner139			Key<Blake2_128Concat, T::CrossAccountId>,140		),141		Value = u128,142		QueryKind = ValueQuery,143	>;144145	#[pallet::storage]146	pub type Allowance<T: Config> = StorageNMap<147		Key = (148			Key<Twox64Concat, CollectionId>,149			Key<Twox64Concat, TokenId>,150			// Owner151			Key<Blake2_128, T::CrossAccountId>,152			// Spender153			Key<Blake2_128Concat, T::CrossAccountId>,154		),155		Value = u128,156		QueryKind = ValueQuery,157	>;158159	#[pallet::hooks]160	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {161		fn on_runtime_upgrade() -> Weight {162			if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {163				<TokenData<T>>::translate_values::<ItemDataVersion1, _>(|v| {164					Some(<ItemDataVersion2>::from(v))165				})166			}167168			0169		}170	}171}172173pub struct RefungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);174impl<T: Config> RefungibleHandle<T> {175	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {176		Self(inner)177	}178	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {179		self.0180	}181}182impl<T: Config> Deref for RefungibleHandle<T> {183	type Target = pallet_common::CollectionHandle<T>;184185	fn deref(&self) -> &Self::Target {186		&self.0187	}188}189190impl<T: Config> Pallet<T> {191	pub fn total_supply(collection: &RefungibleHandle<T>) -> u32 {192		<TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)193	}194	pub fn token_exists(collection: &RefungibleHandle<T>, token: TokenId) -> bool {195		<TotalSupply<T>>::contains_key((collection.id, token))196	}197}198199// unchecked calls skips any permission checks200impl<T: Config> Pallet<T> {201	pub fn init_collection(202		owner: T::AccountId,203		data: CreateCollectionData<T::AccountId>,204	) -> Result<CollectionId, DispatchError> {205		<PalletCommon<T>>::init_collection(owner, data)206	}207	pub fn destroy_collection(208		collection: RefungibleHandle<T>,209		sender: &T::CrossAccountId,210	) -> DispatchResult {211		let id = collection.id;212213		// =========214215		PalletCommon::destroy_collection(collection.0, sender)?;216217		<TokensMinted<T>>::remove(id);218		<TokensBurnt<T>>::remove(id);219		<TokenData<T>>::remove_prefix((id,), None);220		<TotalSupply<T>>::remove_prefix((id,), None);221		<Balance<T>>::remove_prefix((id,), None);222		<Allowance<T>>::remove_prefix((id,), None);223		<Owned<T>>::remove_prefix((id,), None);224		<AccountBalance<T>>::remove_prefix((id,), None);225		Ok(())226	}227228	pub fn burn_token(collection: &RefungibleHandle<T>, token_id: TokenId) -> DispatchResult {229		let burnt = <TokensBurnt<T>>::get(collection.id)230			.checked_add(1)231			.ok_or(ArithmeticError::Overflow)?;232233		<TokensBurnt<T>>::insert(collection.id, burnt);234		<TokenData<T>>::remove((collection.id, token_id));235		<TotalSupply<T>>::remove((collection.id, token_id));236		<Balance<T>>::remove_prefix((collection.id, token_id), None);237		<Allowance<T>>::remove_prefix((collection.id, token_id), None);238		// TODO: ERC721 transfer event239		Ok(())240	}241242	pub fn burn(243		collection: &RefungibleHandle<T>,244		owner: &T::CrossAccountId,245		token: TokenId,246		amount: u128,247	) -> DispatchResult {248		let total_supply = <TotalSupply<T>>::get((collection.id, token))249			.checked_sub(amount)250			.ok_or(<CommonError<T>>::TokenValueTooLow)?;251252		// This was probally last owner of this token?253		if total_supply == 0 {254			// Ensure user actually owns this amount255			ensure!(256				<Balance<T>>::get((collection.id, token, owner)) == amount,257				<CommonError<T>>::TokenValueTooLow258			);259			let account_balance = <AccountBalance<T>>::get((collection.id, owner))260				.checked_sub(1)261				// Should not occur262				.ok_or(ArithmeticError::Underflow)?;263264			// =========265266			<Owned<T>>::remove((collection.id, owner, token));267			<PalletStructure<T>>::unnest_if_nested(owner, collection.id, token);268			<AccountBalance<T>>::insert((collection.id, owner), account_balance);269			Self::burn_token(collection, token)?;270			<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(271				collection.id,272				token,273				owner.clone(),274				amount,275			));276			return Ok(());277		}278279		let balance = <Balance<T>>::get((collection.id, token, owner))280			.checked_sub(amount)281			.ok_or(<CommonError<T>>::TokenValueTooLow)?;282		let account_balance = if balance == 0 {283			<AccountBalance<T>>::get((collection.id, owner))284				.checked_sub(1)285				// Should not occur286				.ok_or(ArithmeticError::Underflow)?287		} else {288			0289		};290291		// =========292293		if balance == 0 {294			<Owned<T>>::remove((collection.id, owner, token));295			<PalletStructure<T>>::unnest_if_nested(owner, collection.id, token);296			<Balance<T>>::remove((collection.id, token, owner));297			<AccountBalance<T>>::insert((collection.id, owner), account_balance);298		} else {299			<Balance<T>>::insert((collection.id, token, owner), balance);300		}301		<TotalSupply<T>>::insert((collection.id, token), total_supply);302		// TODO: ERC20 transfer event303		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(304			collection.id,305			token,306			owner.clone(),307			amount,308		));309		Ok(())310	}311312	pub fn transfer(313		collection: &RefungibleHandle<T>,314		from: &T::CrossAccountId,315		to: &T::CrossAccountId,316		token: TokenId,317		amount: u128,318		nesting_budget: &dyn Budget,319	) -> DispatchResult {320		ensure!(321			collection.limits.transfers_enabled(),322			<CommonError<T>>::TransferNotAllowed323		);324325		if collection.permissions.access() == AccessMode::AllowList {326			collection.check_allowlist(from)?;327			collection.check_allowlist(to)?;328		}329		<PalletCommon<T>>::ensure_correct_receiver(to)?;330331		let balance_from = <Balance<T>>::get((collection.id, token, from))332			.checked_sub(amount)333			.ok_or(<CommonError<T>>::TokenValueTooLow)?;334		let mut create_target = false;335		let from_to_differ = from != to;336		let balance_to = if from != to {337			let old_balance = <Balance<T>>::get((collection.id, token, to));338			if old_balance == 0 {339				create_target = true;340			}341			Some(342				old_balance343					.checked_add(amount)344					.ok_or(ArithmeticError::Overflow)?,345			)346		} else {347			None348		};349350		let account_balance_from = if balance_from == 0 {351			Some(352				<AccountBalance<T>>::get((collection.id, from))353					.checked_sub(1)354					// Should not occur355					.ok_or(ArithmeticError::Underflow)?,356			)357		} else {358			None359		};360		// Account data is created in token, AccountBalance should be increased361		// But only if from != to as we shouldn't check overflow in this case362		let account_balance_to = if create_target && from_to_differ {363			let account_balance_to = <AccountBalance<T>>::get((collection.id, to))364				.checked_add(1)365				.ok_or(ArithmeticError::Overflow)?;366			ensure!(367				account_balance_to < collection.limits.account_token_ownership_limit(),368				<CommonError<T>>::AccountTokenLimitExceeded,369			);370371			Some(account_balance_to)372		} else {373			None374		};375376		// =========377378		<PalletStructure<T>>::try_nest_if_sent_to_token(379			from.clone(),380			to,381			collection.id,382			token,383			nesting_budget384		)?;385386		if let Some(balance_to) = balance_to {387			// from != to388			if balance_from == 0 {389				<Balance<T>>::remove((collection.id, token, from));390			} else {391				<Balance<T>>::insert((collection.id, token, from), balance_from);392			}393			<Balance<T>>::insert((collection.id, token, to), balance_to);394			if let Some(account_balance_from) = account_balance_from {395				<AccountBalance<T>>::insert((collection.id, from), account_balance_from);396				<Owned<T>>::remove((collection.id, from, token));397			}398			if let Some(account_balance_to) = account_balance_to {399				<AccountBalance<T>>::insert((collection.id, to), account_balance_to);400				<Owned<T>>::insert((collection.id, to, token), true);401			}402		}403404		// TODO: ERC20 transfer event405		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(406			collection.id,407			token,408			from.clone(),409			to.clone(),410			amount,411		));412		Ok(())413	}414415	pub fn create_multiple_items(416		collection: &RefungibleHandle<T>,417		sender: &T::CrossAccountId,418		data: Vec<CreateRefungibleExData<T::CrossAccountId>>,419		nesting_budget: &dyn Budget,420	) -> DispatchResult {421		if !collection.is_owner_or_admin(sender) {422			ensure!(423				collection.permissions.mint_mode(),424				<CommonError<T>>::PublicMintingNotAllowed425			);426			collection.check_allowlist(sender)?;427428			for item in data.iter() {429				for user in item.users.keys() {430					collection.check_allowlist(user)?;431				}432			}433		}434435		for item in data.iter() {436			for (owner, _) in item.users.iter() {437				<PalletCommon<T>>::ensure_correct_receiver(owner)?;438			}439		}440441		// Total pieces per tokens442		let totals = data443			.iter()444			.map(|data| {445				Ok(data446					.users447					.iter()448					.map(|u| u.1)449					.try_fold(0u128, |acc, v| acc.checked_add(*v))450					.ok_or(ArithmeticError::Overflow)?)451			})452			.collect::<Result<Vec<_>, DispatchError>>()?;453		for total in &totals {454			ensure!(455				*total <= MAX_REFUNGIBLE_PIECES,456				<Error<T>>::WrongRefungiblePieces457			);458		}459460		let first_token_id = <TokensMinted<T>>::get(collection.id);461		let tokens_minted = first_token_id462			.checked_add(data.len() as u32)463			.ok_or(ArithmeticError::Overflow)?;464		ensure!(465			tokens_minted < collection.limits.token_limit(),466			<CommonError<T>>::CollectionTokenLimitExceeded467		);468469		let mut balances = BTreeMap::new();470		for data in &data {471			for owner in data.users.keys() {472				let balance = balances473					.entry(owner)474					.or_insert_with(|| <AccountBalance<T>>::get((collection.id, owner)));475				*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;476477				ensure!(478					*balance <= collection.limits.account_token_ownership_limit(),479					<CommonError<T>>::AccountTokenLimitExceeded,480				);481			}482		}483484		for (i, token) in data.iter().enumerate() {485			let token_id = TokenId(first_token_id + i as u32 + 1);486			for (to, _) in token.users.iter() {487488				<PalletStructure<T>>::check_nesting(489					sender.clone(),490					to,491					collection.id,492					token_id,493					nesting_budget,494				)?;495			}496		}497498		// =========499500		<TokensMinted<T>>::insert(collection.id, tokens_minted);501		for (account, balance) in balances {502			<AccountBalance<T>>::insert((collection.id, account), balance);503		}504		for (i, token) in data.into_iter().enumerate() {505			let token_id = first_token_id + i as u32 + 1;506			<TotalSupply<T>>::insert((collection.id, token_id), totals[i]);507508			<TokenData<T>>::insert(509				(collection.id, token_id),510				ItemData {511					const_data: token.const_data,512				},513			);514515			for (user, amount) in token.users.into_iter() {516				if amount == 0 {517					continue;518				}519				<Balance<T>>::insert((collection.id, token_id, &user), amount);520				<Owned<T>>::insert((collection.id, &user, TokenId(token_id)), true);521				<PalletStructure<T>>::nest_if_sent_to_token(&user, collection.id, TokenId(token_id));522523				// TODO: ERC20 transfer event524				<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(525					collection.id,526					TokenId(token_id),527					user,528					amount,529				));530			}531		}532		Ok(())533	}534535	pub fn set_allowance_unchecked(536		collection: &RefungibleHandle<T>,537		sender: &T::CrossAccountId,538		spender: &T::CrossAccountId,539		token: TokenId,540		amount: u128,541	) {542		if amount == 0 {543			<Allowance<T>>::remove((collection.id, token, sender, spender));544		} else {545			<Allowance<T>>::insert((collection.id, token, sender, spender), amount);546		}547		// TODO: ERC20 approval event548		<PalletCommon<T>>::deposit_event(CommonEvent::Approved(549			collection.id,550			token,551			sender.clone(),552			spender.clone(),553			amount,554		))555	}556557	pub fn set_allowance(558		collection: &RefungibleHandle<T>,559		sender: &T::CrossAccountId,560		spender: &T::CrossAccountId,561		token: TokenId,562		amount: u128,563	) -> DispatchResult {564		if collection.permissions.access() == AccessMode::AllowList {565			collection.check_allowlist(sender)?;566			collection.check_allowlist(spender)?;567		}568569		<PalletCommon<T>>::ensure_correct_receiver(spender)?;570571		if <Balance<T>>::get((collection.id, token, sender)) < amount {572			ensure!(573				collection.ignores_owned_amount(sender) && Self::token_exists(collection, token),574				<CommonError<T>>::CantApproveMoreThanOwned575			);576		}577578		// =========579580		Self::set_allowance_unchecked(collection, sender, spender, token, amount);581		Ok(())582	}583584	/// Returns allowance, which should be set after transaction585	fn check_allowed(586		collection: &RefungibleHandle<T>,587		spender: &T::CrossAccountId,588		from: &T::CrossAccountId,589		token: TokenId,590		amount: u128,591		nesting_budget: &dyn Budget,592	) -> Result<Option<u128>, DispatchError> {593		if spender.conv_eq(from) {594			return Ok(None);595		}596		if collection.permissions.access() == AccessMode::AllowList {597			// `from`, `to` checked in [`transfer`]598			collection.check_allowlist(spender)?;599		}600		if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {601			// TODO: should collection owner be allowed to perform this transfer?602			ensure!(603				<PalletStructure<T>>::check_indirectly_owned(604					spender.clone(),605					source.0,606					source.1,607					None,608					nesting_budget609				)?,610				<CommonError<T>>::ApprovedValueTooLow,611			);612			return Ok(None);613		}614		let allowance =615			<Allowance<T>>::get((collection.id, token, from, &spender)).checked_sub(amount);616		if allowance.is_none() {617			ensure!(618				collection.ignores_allowance(spender),619				<CommonError<T>>::ApprovedValueTooLow620			);621		}622		Ok(allowance)623	}624625	pub fn transfer_from(626		collection: &RefungibleHandle<T>,627		spender: &T::CrossAccountId,628		from: &T::CrossAccountId,629		to: &T::CrossAccountId,630		token: TokenId,631		amount: u128,632		nesting_budget: &dyn Budget,633	) -> DispatchResult {634		let allowance =635			Self::check_allowed(collection, spender, from, token, amount, nesting_budget)?;636637		// =========638639		Self::transfer(collection, from, to, token, amount, nesting_budget)?;640		if let Some(allowance) = allowance {641			Self::set_allowance_unchecked(collection, from, spender, token, allowance);642		}643		Ok(())644	}645646	pub fn burn_from(647		collection: &RefungibleHandle<T>,648		spender: &T::CrossAccountId,649		from: &T::CrossAccountId,650		token: TokenId,651		amount: u128,652		nesting_budget: &dyn Budget,653	) -> DispatchResult {654		let allowance =655			Self::check_allowed(collection, spender, from, token, amount, nesting_budget)?;656657		// =========658659		Self::burn(collection, from, token, amount)?;660		if let Some(allowance) = allowance {661			Self::set_allowance_unchecked(collection, from, spender, token, allowance);662		}663		Ok(())664	}665666	/// Delegated to `create_multiple_items`667	pub fn create_item(668		collection: &RefungibleHandle<T>,669		sender: &T::CrossAccountId,670		data: CreateRefungibleExData<T::CrossAccountId>,671		nesting_budget: &dyn Budget,672	) -> DispatchResult {673		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)674	}675}