git.delta.rocks / unique-network / refs/commits / 7c4183b4cb3a

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, CollectionHandle,27	dispatch::CollectionDispatch,28};29use pallet_structure::Pallet as PalletStructure;30use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};31use sp_std::{vec::Vec, vec, collections::btree_map::BTreeMap};32use core::ops::Deref;33use codec::{Encode, Decode, MaxEncodedLen};34use scale_info::TypeInfo;3536pub use pallet::*;37#[cfg(feature = "runtime-benchmarks")]38pub mod benchmarking;39pub mod common;40pub mod erc;41pub mod weights;42pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;4344#[struct_versioning::versioned(version = 2, upper)]45#[derive(Encode, Decode, Default, TypeInfo, MaxEncodedLen)]46pub struct ItemData {47	pub const_data: BoundedVec<u8, CustomDataLimit>,4849	#[version(..2)]50	pub variable_data: BoundedVec<u8, CustomDataLimit>,51}5253#[frame_support::pallet]54pub mod pallet {55	use super::*;56	use frame_support::{57		Blake2_128, Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key,58		traits::StorageVersion,59	};60	use frame_system::pallet_prelude::*;61	use up_data_structs::{CollectionId, TokenId};62	use super::weights::WeightInfo;6364	#[pallet::error]65	pub enum Error<T> {66		/// Not Refungible item data used to mint in Refungible collection.67		NotRefungibleDataUsedToMintFungibleCollectionToken,68		/// Maximum refungibility exceeded69		WrongRefungiblePieces,70		/// Refungible token can't nest other tokens71		RefungibleDisallowsNesting,72		/// Setting item properties is not allowed73		SettingPropertiesNotAllowed,74	}7576	#[pallet::config]77	pub trait Config:78		frame_system::Config + pallet_common::Config + pallet_structure::Config79	{80		type WeightInfo: WeightInfo;81	}8283	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);8485	#[pallet::pallet]86	#[pallet::storage_version(STORAGE_VERSION)]87	#[pallet::generate_store(pub(super) trait Store)]88	pub struct Pallet<T>(_);8990	#[pallet::storage]91	pub type TokensMinted<T: Config> =92		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;93	#[pallet::storage]94	pub type TokensBurnt<T: Config> =95		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;9697	#[pallet::storage]98	pub type TokenData<T: Config> = StorageNMap<99		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),100		Value = ItemData,101		QueryKind = ValueQuery,102	>;103104	#[pallet::storage]105	pub type TotalSupply<T: Config> = StorageNMap<106		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),107		Value = u128,108		QueryKind = ValueQuery,109	>;110111	/// Used to enumerate tokens owned by account112	#[pallet::storage]113	pub type Owned<T: Config> = StorageNMap<114		Key = (115			Key<Twox64Concat, CollectionId>,116			Key<Blake2_128Concat, T::CrossAccountId>,117			Key<Twox64Concat, TokenId>,118		),119		Value = bool,120		QueryKind = ValueQuery,121	>;122123	#[pallet::storage]124	pub type AccountBalance<T: Config> = StorageNMap<125		Key = (126			Key<Twox64Concat, CollectionId>,127			// Owner128			Key<Blake2_128Concat, T::CrossAccountId>,129		),130		Value = u32,131		QueryKind = ValueQuery,132	>;133134	#[pallet::storage]135	pub type Balance<T: Config> = StorageNMap<136		Key = (137			Key<Twox64Concat, CollectionId>,138			Key<Twox64Concat, TokenId>,139			// Owner140			Key<Blake2_128Concat, T::CrossAccountId>,141		),142		Value = u128,143		QueryKind = ValueQuery,144	>;145146	#[pallet::storage]147	pub type Allowance<T: Config> = StorageNMap<148		Key = (149			Key<Twox64Concat, CollectionId>,150			Key<Twox64Concat, TokenId>,151			// Owner152			Key<Blake2_128, T::CrossAccountId>,153			// Spender154			Key<Blake2_128Concat, T::CrossAccountId>,155		),156		Value = u128,157		QueryKind = ValueQuery,158	>;159160	#[pallet::hooks]161	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {162		fn on_runtime_upgrade() -> Weight {163			if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {164				<TokenData<T>>::translate_values::<ItemDataVersion1, _>(|v| {165					Some(<ItemDataVersion2>::from(v))166				})167			}168169			0170		}171	}172}173174pub struct RefungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);175impl<T: Config> RefungibleHandle<T> {176	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {177		Self(inner)178	}179	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {180		self.0181	}182}183impl<T: Config> Deref for RefungibleHandle<T> {184	type Target = pallet_common::CollectionHandle<T>;185186	fn deref(&self) -> &Self::Target {187		&self.0188	}189}190191impl<T: Config> Pallet<T> {192	pub fn total_supply(collection: &RefungibleHandle<T>) -> u32 {193		<TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)194	}195	pub fn token_exists(collection: &RefungibleHandle<T>, token: TokenId) -> bool {196		<TotalSupply<T>>::contains_key((collection.id, token))197	}198}199200// unchecked calls skips any permission checks201impl<T: Config> Pallet<T> {202	pub fn init_collection(203		owner: T::AccountId,204		data: CreateCollectionData<T::AccountId>,205	) -> Result<CollectionId, DispatchError> {206		<PalletCommon<T>>::init_collection(owner, data)207	}208	pub fn destroy_collection(209		collection: RefungibleHandle<T>,210		sender: &T::CrossAccountId,211	) -> DispatchResult {212		let id = collection.id;213214		// =========215216		PalletCommon::destroy_collection(collection.0, sender)?;217218		<TokensMinted<T>>::remove(id);219		<TokensBurnt<T>>::remove(id);220		<TokenData<T>>::remove_prefix((id,), None);221		<TotalSupply<T>>::remove_prefix((id,), None);222		<Balance<T>>::remove_prefix((id,), None);223		<Allowance<T>>::remove_prefix((id,), None);224		<Owned<T>>::remove_prefix((id,), None);225		<AccountBalance<T>>::remove_prefix((id,), None);226		Ok(())227	}228229	pub fn burn_token(collection: &RefungibleHandle<T>, token_id: TokenId) -> DispatchResult {230		let burnt = <TokensBurnt<T>>::get(collection.id)231			.checked_add(1)232			.ok_or(ArithmeticError::Overflow)?;233234		<TokensBurnt<T>>::insert(collection.id, burnt);235		<TokenData<T>>::remove((collection.id, token_id));236		<TotalSupply<T>>::remove((collection.id, token_id));237		<Balance<T>>::remove_prefix((collection.id, token_id), None);238		<Allowance<T>>::remove_prefix((collection.id, token_id), None);239		// TODO: ERC721 transfer event240		Ok(())241	}242243	pub fn burn(244		collection: &RefungibleHandle<T>,245		owner: &T::CrossAccountId,246		token: TokenId,247		amount: u128,248	) -> DispatchResult {249		let total_supply = <TotalSupply<T>>::get((collection.id, token))250			.checked_sub(amount)251			.ok_or(<CommonError<T>>::TokenValueTooLow)?;252253		// This was probally last owner of this token?254		if total_supply == 0 {255			// Ensure user actually owns this amount256			ensure!(257				<Balance<T>>::get((collection.id, token, owner)) == amount,258				<CommonError<T>>::TokenValueTooLow259			);260			let account_balance = <AccountBalance<T>>::get((collection.id, owner))261				.checked_sub(1)262				// Should not occur263				.ok_or(ArithmeticError::Underflow)?;264265			// =========266267			<Owned<T>>::remove((collection.id, owner, 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			<Balance<T>>::remove((collection.id, token, owner));296			<AccountBalance<T>>::insert((collection.id, owner), account_balance);297		} else {298			<Balance<T>>::insert((collection.id, token, owner), balance);299		}300		<TotalSupply<T>>::insert((collection.id, token), total_supply);301		// TODO: ERC20 transfer event302		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(303			collection.id,304			token,305			owner.clone(),306			amount,307		));308		Ok(())309	}310311	pub fn transfer(312		collection: &RefungibleHandle<T>,313		from: &T::CrossAccountId,314		to: &T::CrossAccountId,315		token: TokenId,316		amount: u128,317		nesting_budget: &dyn Budget,318	) -> DispatchResult {319		ensure!(320			collection.limits.transfers_enabled(),321			<CommonError<T>>::TransferNotAllowed322		);323324		if collection.access == AccessMode::AllowList {325			collection.check_allowlist(from)?;326			collection.check_allowlist(to)?;327		}328		<PalletCommon<T>>::ensure_correct_receiver(to)?;329330		let balance_from = <Balance<T>>::get((collection.id, token, from))331			.checked_sub(amount)332			.ok_or(<CommonError<T>>::TokenValueTooLow)?;333		let mut create_target = false;334		let from_to_differ = from != to;335		let balance_to = if from != to {336			let old_balance = <Balance<T>>::get((collection.id, token, to));337			if old_balance == 0 {338				create_target = true;339			}340			Some(341				old_balance342					.checked_add(amount)343					.ok_or(ArithmeticError::Overflow)?,344			)345		} else {346			None347		};348349		let account_balance_from = if balance_from == 0 {350			Some(351				<AccountBalance<T>>::get((collection.id, from))352					.checked_sub(1)353					// Should not occur354					.ok_or(ArithmeticError::Underflow)?,355			)356		} else {357			None358		};359		// Account data is created in token, AccountBalance should be increased360		// But only if from != to as we shouldn't check overflow in this case361		let account_balance_to = if create_target && from_to_differ {362			let account_balance_to = <AccountBalance<T>>::get((collection.id, to))363				.checked_add(1)364				.ok_or(ArithmeticError::Overflow)?;365			ensure!(366				account_balance_to < collection.limits.account_token_ownership_limit(),367				<CommonError<T>>::AccountTokenLimitExceeded,368			);369370			Some(account_balance_to)371		} else {372			None373		};374375		if let Some(target) = T::CrossTokenAddressMapping::address_to_token(to) {376			let handle = <CollectionHandle<T>>::try_get(target.0)?;377			let dispatch = T::CollectionDispatch::dispatch(handle);378			let dispatch = dispatch.as_dyn();379380			dispatch.check_nesting(381				from.clone(),382				(collection.id, token),383				target.1,384				nesting_budget,385			)?;386		}387388		// =========389390		if let Some(balance_to) = balance_to {391			// from != to392			if balance_from == 0 {393				<Balance<T>>::remove((collection.id, token, from));394			} else {395				<Balance<T>>::insert((collection.id, token, from), balance_from);396			}397			<Balance<T>>::insert((collection.id, token, to), balance_to);398			if let Some(account_balance_from) = account_balance_from {399				<AccountBalance<T>>::insert((collection.id, from), account_balance_from);400				<Owned<T>>::remove((collection.id, from, token));401			}402			if let Some(account_balance_to) = account_balance_to {403				<AccountBalance<T>>::insert((collection.id, to), account_balance_to);404				<Owned<T>>::insert((collection.id, to, token), true);405			}406		}407408		// TODO: ERC20 transfer event409		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(410			collection.id,411			token,412			from.clone(),413			to.clone(),414			amount,415		));416		Ok(())417	}418419	pub fn create_multiple_items(420		collection: &RefungibleHandle<T>,421		sender: &T::CrossAccountId,422		data: Vec<CreateRefungibleExData<T::CrossAccountId>>,423		nesting_budget: &dyn Budget,424	) -> DispatchResult {425		if !collection.is_owner_or_admin(sender) {426			ensure!(427				collection.mint_mode,428				<CommonError<T>>::PublicMintingNotAllowed429			);430			collection.check_allowlist(sender)?;431432			for item in data.iter() {433				for user in item.users.keys() {434					collection.check_allowlist(user)?;435				}436			}437		}438439		for item in data.iter() {440			for (owner, _) in item.users.iter() {441				<PalletCommon<T>>::ensure_correct_receiver(owner)?;442			}443		}444445		// Total pieces per tokens446		let totals = data447			.iter()448			.map(|data| {449				Ok(data450					.users451					.iter()452					.map(|u| u.1)453					.try_fold(0u128, |acc, v| acc.checked_add(*v))454					.ok_or(ArithmeticError::Overflow)?)455			})456			.collect::<Result<Vec<_>, DispatchError>>()?;457		for total in &totals {458			ensure!(459				*total <= MAX_REFUNGIBLE_PIECES,460				<Error<T>>::WrongRefungiblePieces461			);462		}463464		let first_token_id = <TokensMinted<T>>::get(collection.id);465		let tokens_minted = first_token_id466			.checked_add(data.len() as u32)467			.ok_or(ArithmeticError::Overflow)?;468		ensure!(469			tokens_minted < collection.limits.token_limit(),470			<CommonError<T>>::CollectionTokenLimitExceeded471		);472473		let mut balances = BTreeMap::new();474		for data in &data {475			for owner in data.users.keys() {476				let balance = balances477					.entry(owner)478					.or_insert_with(|| <AccountBalance<T>>::get((collection.id, owner)));479				*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;480481				ensure!(482					*balance <= collection.limits.account_token_ownership_limit(),483					<CommonError<T>>::AccountTokenLimitExceeded,484				);485			}486		}487488		for (i, token) in data.iter().enumerate() {489			let token_id = TokenId(first_token_id + i as u32 + 1);490			for (to, _) in token.users.iter() {491				if let Some(target) = T::CrossTokenAddressMapping::address_to_token(to) {492					let handle = <CollectionHandle<T>>::try_get(target.0)?;493					let dispatch = T::CollectionDispatch::dispatch(handle);494					let dispatch = dispatch.as_dyn();495496					dispatch.check_nesting(497						sender.clone(),498						(collection.id, token_id),499						target.1,500						nesting_budget,501					)?;502				}503			}504		}505506		// =========507508		<TokensMinted<T>>::insert(collection.id, tokens_minted);509		for (account, balance) in balances {510			<AccountBalance<T>>::insert((collection.id, account), balance);511		}512		for (i, token) in data.into_iter().enumerate() {513			let token_id = first_token_id + i as u32 + 1;514			<TotalSupply<T>>::insert((collection.id, token_id), totals[i]);515516			<TokenData<T>>::insert(517				(collection.id, token_id),518				ItemData {519					const_data: token.const_data,520				},521			);522			for (user, amount) in token.users.into_iter() {523				if amount == 0 {524					continue;525				}526				<Balance<T>>::insert((collection.id, token_id, &user), amount);527				<Owned<T>>::insert((collection.id, &user, TokenId(token_id)), true);528				// TODO: ERC20 transfer event529				<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(530					collection.id,531					TokenId(token_id),532					user,533					amount,534				));535			}536		}537		Ok(())538	}539540	pub fn set_allowance_unchecked(541		collection: &RefungibleHandle<T>,542		sender: &T::CrossAccountId,543		spender: &T::CrossAccountId,544		token: TokenId,545		amount: u128,546	) {547		if amount == 0 {548			<Allowance<T>>::remove((collection.id, token, sender, spender));549		} else {550			<Allowance<T>>::insert((collection.id, token, sender, spender), amount);551		}552		// TODO: ERC20 approval event553		<PalletCommon<T>>::deposit_event(CommonEvent::Approved(554			collection.id,555			token,556			sender.clone(),557			spender.clone(),558			amount,559		))560	}561562	pub fn set_allowance(563		collection: &RefungibleHandle<T>,564		sender: &T::CrossAccountId,565		spender: &T::CrossAccountId,566		token: TokenId,567		amount: u128,568	) -> DispatchResult {569		if collection.access == AccessMode::AllowList {570			collection.check_allowlist(sender)?;571			collection.check_allowlist(spender)?;572		}573574		<PalletCommon<T>>::ensure_correct_receiver(spender)?;575576		if <Balance<T>>::get((collection.id, token, sender)) < amount {577			ensure!(578				collection.ignores_owned_amount(sender) && Self::token_exists(collection, token),579				<CommonError<T>>::CantApproveMoreThanOwned580			);581		}582583		// =========584585		Self::set_allowance_unchecked(collection, sender, spender, token, amount);586		Ok(())587	}588589	/// Returns allowance, which should be set after transaction590	fn check_allowed(591		collection: &RefungibleHandle<T>,592		spender: &T::CrossAccountId,593		from: &T::CrossAccountId,594		token: TokenId,595		amount: u128,596		nesting_budget: &dyn Budget,597	) -> Result<Option<u128>, DispatchError> {598		if spender.conv_eq(from) {599			return Ok(None);600		}601		if collection.access == AccessMode::AllowList {602			// `from`, `to` checked in [`transfer`]603			collection.check_allowlist(spender)?;604		}605		if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {606			// TODO: should collection owner be allowed to perform this transfer?607			ensure!(608				<PalletStructure<T>>::check_indirectly_owned(609					spender.clone(),610					source.0,611					source.1,612					None,613					nesting_budget614				)?,615				<CommonError<T>>::ApprovedValueTooLow,616			);617			return Ok(None);618		}619		let allowance =620			<Allowance<T>>::get((collection.id, token, from, &spender)).checked_sub(amount);621		if allowance.is_none() {622			ensure!(623				collection.ignores_allowance(spender),624				<CommonError<T>>::ApprovedValueTooLow625			);626		}627		Ok(allowance)628	}629630	pub fn transfer_from(631		collection: &RefungibleHandle<T>,632		spender: &T::CrossAccountId,633		from: &T::CrossAccountId,634		to: &T::CrossAccountId,635		token: TokenId,636		amount: u128,637		nesting_budget: &dyn Budget,638	) -> DispatchResult {639		let allowance =640			Self::check_allowed(collection, spender, from, token, amount, nesting_budget)?;641642		// =========643644		Self::transfer(collection, from, to, token, amount, nesting_budget)?;645		if let Some(allowance) = allowance {646			Self::set_allowance_unchecked(collection, from, spender, token, allowance);647		}648		Ok(())649	}650651	pub fn burn_from(652		collection: &RefungibleHandle<T>,653		spender: &T::CrossAccountId,654		from: &T::CrossAccountId,655		token: TokenId,656		amount: u128,657		nesting_budget: &dyn Budget,658	) -> DispatchResult {659		let allowance =660			Self::check_allowed(collection, spender, from, token, amount, nesting_budget)?;661662		// =========663664		Self::burn(collection, from, token, amount)?;665		if let Some(allowance) = allowance {666			Self::set_allowance_unchecked(collection, from, spender, token, allowance);667		}668		Ok(())669	}670671	/// Delegated to `create_multiple_items`672	pub fn create_item(673		collection: &RefungibleHandle<T>,674		sender: &T::CrossAccountId,675		data: CreateRefungibleExData<T::CrossAccountId>,676		nesting_budget: &dyn Budget,677	) -> DispatchResult {678		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)679	}680}