git.delta.rocks / unique-network / refs/commits / 22251a0f47f9

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,23};24use pallet_common::{25	Error as CommonError, Event as CommonEvent, Pallet as PalletCommon,26};27use frame_common::account::CrossAccountId;28use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};29use sp_std::{vec::Vec, vec, collections::btree_map::BTreeMap};30use core::ops::Deref;31use codec::{Encode, Decode, MaxEncodedLen};32use scale_info::TypeInfo;3334pub use pallet::*;35#[cfg(feature = "runtime-benchmarks")]36pub mod benchmarking;37pub mod common;38pub mod erc;39pub mod weights;40pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;4142#[derive(Encode, Decode, Default, TypeInfo, MaxEncodedLen)]43pub struct ItemData {44	pub const_data: BoundedVec<u8, CustomDataLimit>,45	pub variable_data: BoundedVec<u8, CustomDataLimit>,46}4748#[frame_support::pallet]49pub mod pallet {50	use super::*;51	use frame_support::{Blake2_128, Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key};52	use up_data_structs::{CollectionId, TokenId};53	use super::weights::WeightInfo;5455	#[pallet::error]56	pub enum Error<T> {57		/// Not Refungible item data used to mint in Refungible collection.58		NotRefungibleDataUsedToMintFungibleCollectionToken,59		/// Maximum refungibility exceeded60		WrongRefungiblePieces,61	}6263	#[pallet::config]64	pub trait Config: frame_system::Config + pallet_common::Config {65		type WeightInfo: WeightInfo;66	}6768	#[pallet::pallet]69	#[pallet::generate_store(pub(super) trait Store)]70	pub struct Pallet<T>(_);7172	#[pallet::storage]73	pub type TokensMinted<T: Config> =74		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;75	#[pallet::storage]76	pub type TokensBurnt<T: Config> =77		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;7879	#[pallet::storage]80	pub type TokenData<T: Config> = StorageNMap<81		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),82		Value = ItemData,83		QueryKind = ValueQuery,84	>;8586	#[pallet::storage]87	pub type TotalSupply<T: Config> = StorageNMap<88		Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),89		Value = u128,90		QueryKind = ValueQuery,91	>;9293	/// Used to enumerate tokens owned by account94	#[pallet::storage]95	pub type Owned<T: Config> = StorageNMap<96		Key = (97			Key<Twox64Concat, CollectionId>,98			Key<Blake2_128Concat, T::CrossAccountId>,99			Key<Twox64Concat, TokenId>,100		),101		Value = bool,102		QueryKind = ValueQuery,103	>;104105	#[pallet::storage]106	pub type AccountBalance<T: Config> = StorageNMap<107		Key = (108			Key<Twox64Concat, CollectionId>,109			// Owner110			Key<Blake2_128Concat, T::CrossAccountId>,111		),112		Value = u32,113		QueryKind = ValueQuery,114	>;115116	#[pallet::storage]117	pub type Balance<T: Config> = StorageNMap<118		Key = (119			Key<Twox64Concat, CollectionId>,120			Key<Twox64Concat, TokenId>,121			// Owner122			Key<Blake2_128Concat, T::CrossAccountId>,123		),124		Value = u128,125		QueryKind = ValueQuery,126	>;127128	#[pallet::storage]129	pub type Allowance<T: Config> = StorageNMap<130		Key = (131			Key<Twox64Concat, CollectionId>,132			Key<Twox64Concat, TokenId>,133			// Owner134			Key<Blake2_128, T::CrossAccountId>,135			// Spender136			Key<Blake2_128Concat, T::CrossAccountId>,137		),138		Value = u128,139		QueryKind = ValueQuery,140	>;141}142143pub struct RefungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);144impl<T: Config> RefungibleHandle<T> {145	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {146		Self(inner)147	}148	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {149		self.0150	}151}152impl<T: Config> Deref for RefungibleHandle<T> {153	type Target = pallet_common::CollectionHandle<T>;154155	fn deref(&self) -> &Self::Target {156		&self.0157	}158}159160impl<T: Config> Pallet<T> {161	pub fn total_supply(collection: &RefungibleHandle<T>) -> u32 {162		<TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)163	}164	pub fn token_exists(collection: &RefungibleHandle<T>, token: TokenId) -> bool {165		<TotalSupply<T>>::contains_key((collection.id, token))166	}167}168169// unchecked calls skips any permission checks170impl<T: Config> Pallet<T> {171	pub fn init_collection(172		owner: T::AccountId,173		data: CreateCollectionData<T::AccountId>,174	) -> Result<CollectionId, DispatchError> {175		<PalletCommon<T>>::init_collection(owner, data)176	}177	pub fn destroy_collection(178		collection: RefungibleHandle<T>,179		sender: &T::CrossAccountId,180	) -> DispatchResult {181		let id = collection.id;182183		// =========184185		PalletCommon::destroy_collection(collection.0, sender)?;186187		<TokensMinted<T>>::remove(id);188		<TokensBurnt<T>>::remove(id);189		<TokenData<T>>::remove_prefix((id,), None);190		<TotalSupply<T>>::remove_prefix((id,), None);191		<Balance<T>>::remove_prefix((id,), None);192		<Allowance<T>>::remove_prefix((id,), None);193		<Owned<T>>::remove_prefix((id,), None);194		<AccountBalance<T>>::remove_prefix((id,), None);195		Ok(())196	}197198	pub fn burn_token(collection: &RefungibleHandle<T>, token_id: TokenId) -> DispatchResult {199		let burnt = <TokensBurnt<T>>::get(collection.id)200			.checked_add(1)201			.ok_or(ArithmeticError::Overflow)?;202203		<TokensBurnt<T>>::insert(collection.id, burnt);204		<TokenData<T>>::remove((collection.id, token_id));205		<TotalSupply<T>>::remove((collection.id, token_id));206		<Balance<T>>::remove_prefix((collection.id, token_id), None);207		<Allowance<T>>::remove_prefix((collection.id, token_id), None);208		// TODO: ERC721 transfer event209		Ok(())210	}211212	pub fn burn(213		collection: &RefungibleHandle<T>,214		owner: &T::CrossAccountId,215		token: TokenId,216		amount: u128,217	) -> DispatchResult {218		let total_supply = <TotalSupply<T>>::get((collection.id, token))219			.checked_sub(amount)220			.ok_or(<CommonError<T>>::TokenValueTooLow)?;221222		// This was probally last owner of this token?223		if total_supply == 0 {224			// Ensure user actually owns this amount225			ensure!(226				<Balance<T>>::get((collection.id, token, owner)) == amount,227				<CommonError<T>>::TokenValueTooLow228			);229			let account_balance = <AccountBalance<T>>::get((collection.id, owner))230				.checked_sub(1)231				// Should not occur232				.ok_or(ArithmeticError::Underflow)?;233234			// =========235236			<Owned<T>>::remove((collection.id, owner, token));237			<AccountBalance<T>>::insert((collection.id, owner), account_balance);238			Self::burn_token(collection, token)?;239			<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(240				collection.id,241				token,242				owner.clone(),243				amount,244			));245			return Ok(());246		}247248		let balance = <Balance<T>>::get((collection.id, token, owner))249			.checked_sub(amount)250			.ok_or(<CommonError<T>>::TokenValueTooLow)?;251		let account_balance = if balance == 0 {252			<AccountBalance<T>>::get((collection.id, owner))253				.checked_sub(1)254				// Should not occur255				.ok_or(ArithmeticError::Underflow)?256		} else {257			0258		};259260		// =========261262		if balance == 0 {263			<Owned<T>>::remove((collection.id, owner, token));264			<Balance<T>>::remove((collection.id, token, owner));265			<AccountBalance<T>>::insert((collection.id, owner), account_balance);266		} else {267			<Balance<T>>::insert((collection.id, token, owner), balance);268		}269		<TotalSupply<T>>::insert((collection.id, token), total_supply);270		// TODO: ERC20 transfer event271		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(272			collection.id,273			token,274			owner.clone(),275			amount,276		));277		Ok(())278	}279280	pub fn transfer(281		collection: &RefungibleHandle<T>,282		from: &T::CrossAccountId,283		to: &T::CrossAccountId,284		token: TokenId,285		amount: u128,286	) -> DispatchResult {287		ensure!(288			collection.limits.transfers_enabled(),289			<CommonError<T>>::TransferNotAllowed290		);291292		if collection.access == AccessMode::AllowList {293			collection.check_allowlist(from)?;294			collection.check_allowlist(to)?;295		}296		<PalletCommon<T>>::ensure_correct_receiver(to)?;297298		let balance_from = <Balance<T>>::get((collection.id, token, from))299			.checked_sub(amount)300			.ok_or(<CommonError<T>>::TokenValueTooLow)?;301		let mut create_target = false;302		let from_to_differ = from != to;303		let balance_to = if from != to {304			let old_balance = <Balance<T>>::get((collection.id, token, to));305			if old_balance == 0 {306				create_target = true;307			}308			Some(309				old_balance310					.checked_add(amount)311					.ok_or(ArithmeticError::Overflow)?,312			)313		} else {314			None315		};316317		let account_balance_from = if balance_from == 0 {318			Some(319				<AccountBalance<T>>::get((collection.id, from))320					.checked_sub(1)321					// Should not occur322					.ok_or(ArithmeticError::Underflow)?,323			)324		} else {325			None326		};327		// Account data is created in token, AccountBalance should be increased328		// But only if from != to as we shouldn't check overflow in this case329		let account_balance_to = if create_target && from_to_differ {330			let account_balance_to = <AccountBalance<T>>::get((collection.id, to))331				.checked_add(1)332				.ok_or(ArithmeticError::Overflow)?;333			ensure!(334				account_balance_to < collection.limits.account_token_ownership_limit(),335				<CommonError<T>>::AccountTokenLimitExceeded,336			);337338			Some(account_balance_to)339		} else {340			None341		};342343		// =========344345		if let Some(balance_to) = balance_to {346			// from != to347			if balance_from == 0 {348				<Balance<T>>::remove((collection.id, token, from));349			} else {350				<Balance<T>>::insert((collection.id, token, from), balance_from);351			}352			<Balance<T>>::insert((collection.id, token, to), balance_to);353			if let Some(account_balance_from) = account_balance_from {354				<AccountBalance<T>>::insert((collection.id, from), account_balance_from);355				<Owned<T>>::remove((collection.id, from, token));356			}357			if let Some(account_balance_to) = account_balance_to {358				<AccountBalance<T>>::insert((collection.id, to), account_balance_to);359				<Owned<T>>::insert((collection.id, to, token), true);360			}361		}362363		// TODO: ERC20 transfer event364		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(365			collection.id,366			token,367			from.clone(),368			to.clone(),369			amount,370		));371		Ok(())372	}373374	pub fn create_multiple_items(375		collection: &RefungibleHandle<T>,376		sender: &T::CrossAccountId,377		data: Vec<CreateRefungibleExData<T::CrossAccountId>>,378	) -> DispatchResult {379		if !collection.is_owner_or_admin(sender) {380			ensure!(381				collection.mint_mode,382				<CommonError<T>>::PublicMintingNotAllowed383			);384			collection.check_allowlist(sender)?;385386			for item in data.iter() {387				for user in item.users.keys() {388					collection.check_allowlist(user)?;389				}390			}391		}392393		for item in data.iter() {394			for (owner, _) in item.users.iter() {395				<PalletCommon<T>>::ensure_correct_receiver(owner)?;396			}397		}398399		// Total pieces per tokens400		let totals = data401			.iter()402			.map(|data| {403				Ok(data404					.users405					.iter()406					.map(|u| u.1)407					.try_fold(0u128, |acc, v| acc.checked_add(*v))408					.ok_or(ArithmeticError::Overflow)?)409			})410			.collect::<Result<Vec<_>, DispatchError>>()?;411		for total in &totals {412			ensure!(413				*total <= MAX_REFUNGIBLE_PIECES,414				<Error<T>>::WrongRefungiblePieces415			);416		}417418		let first_token_id = <TokensMinted<T>>::get(collection.id);419		let tokens_minted = first_token_id420			.checked_add(data.len() as u32)421			.ok_or(ArithmeticError::Overflow)?;422		ensure!(423			tokens_minted < collection.limits.token_limit(),424			<CommonError<T>>::CollectionTokenLimitExceeded425		);426427		let mut balances = BTreeMap::new();428		for data in &data {429			for owner in data.users.keys() {430				let balance = balances431					.entry(owner)432					.or_insert_with(|| <AccountBalance<T>>::get((collection.id, owner)));433				*balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;434435				ensure!(436					*balance <= collection.limits.account_token_ownership_limit(),437					<CommonError<T>>::AccountTokenLimitExceeded,438				);439			}440		}441442		// =========443444		<TokensMinted<T>>::insert(collection.id, tokens_minted);445		for (account, balance) in balances {446			<AccountBalance<T>>::insert((collection.id, account), balance);447		}448		for (i, token) in data.into_iter().enumerate() {449			let token_id = first_token_id + i as u32 + 1;450			<TotalSupply<T>>::insert((collection.id, token_id), totals[i]);451452			<TokenData<T>>::insert(453				(collection.id, token_id),454				ItemData {455					const_data: token.const_data,456					variable_data: token.variable_data,457				},458			);459			for (user, amount) in token.users.into_iter() {460				if amount == 0 {461					continue;462				}463				<Balance<T>>::insert((collection.id, token_id, &user), amount);464				<Owned<T>>::insert((collection.id, &user, TokenId(token_id)), true);465				// TODO: ERC20 transfer event466				<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(467					collection.id,468					TokenId(token_id),469					user,470					amount,471				));472			}473		}474		Ok(())475	}476477	pub fn set_allowance_unchecked(478		collection: &RefungibleHandle<T>,479		sender: &T::CrossAccountId,480		spender: &T::CrossAccountId,481		token: TokenId,482		amount: u128,483	) {484		if amount == 0 {485			<Allowance<T>>::remove((collection.id, token, sender, spender));486		} else {487			<Allowance<T>>::insert((collection.id, token, sender, spender), amount);488		}489		// TODO: ERC20 approval event490		<PalletCommon<T>>::deposit_event(CommonEvent::Approved(491			collection.id,492			token,493			sender.clone(),494			spender.clone(),495			amount,496		))497	}498499	pub fn set_allowance(500		collection: &RefungibleHandle<T>,501		sender: &T::CrossAccountId,502		spender: &T::CrossAccountId,503		token: TokenId,504		amount: u128,505	) -> DispatchResult {506		if collection.access == AccessMode::AllowList {507			collection.check_allowlist(sender)?;508			collection.check_allowlist(spender)?;509		}510511		<PalletCommon<T>>::ensure_correct_receiver(spender)?;512513		if <Balance<T>>::get((collection.id, token, sender)) < amount {514			ensure!(515				collection.ignores_owned_amount(sender) && Self::token_exists(collection, token),516				<CommonError<T>>::CantApproveMoreThanOwned517			);518		}519520		// =========521522		Self::set_allowance_unchecked(collection, sender, spender, token, amount);523		Ok(())524	}525526	pub fn transfer_from(527		collection: &RefungibleHandle<T>,528		spender: &T::CrossAccountId,529		from: &T::CrossAccountId,530		to: &T::CrossAccountId,531		token: TokenId,532		amount: u128,533	) -> DispatchResult {534		if spender.conv_eq(from) {535			return Self::transfer(collection, from, to, token, amount);536		}537		if collection.access == AccessMode::AllowList {538			// `from`, `to` checked in [`transfer`]539			collection.check_allowlist(spender)?;540		}541542		let allowance =543			<Allowance<T>>::get((collection.id, token, from, &spender)).checked_sub(amount);544		if allowance.is_none() {545			ensure!(546				collection.ignores_allowance(spender),547				<CommonError<T>>::ApprovedValueTooLow548			);549		}550551		// =========552553		Self::transfer(collection, from, to, token, amount)?;554		if let Some(allowance) = allowance {555			Self::set_allowance_unchecked(collection, from, spender, token, allowance);556		}557		Ok(())558	}559560	pub fn burn_from(561		collection: &RefungibleHandle<T>,562		spender: &T::CrossAccountId,563		from: &T::CrossAccountId,564		token: TokenId,565		amount: u128,566	) -> DispatchResult {567		if spender.conv_eq(from) {568			return Self::burn(collection, from, token, amount);569		}570		if collection.access == AccessMode::AllowList {571			// `from` checked in [`burn`]572			collection.check_allowlist(spender)?;573		}574575		let allowance =576			<Allowance<T>>::get((collection.id, token, from, &spender)).checked_sub(amount);577		if allowance.is_none() {578			ensure!(579				collection.ignores_allowance(spender),580				<CommonError<T>>::ApprovedValueTooLow581			);582		}583584		// =========585586		Self::burn(collection, from, token, amount)?;587		if let Some(allowance) = allowance {588			Self::set_allowance_unchecked(collection, from, spender, token, allowance);589		}590		Ok(())591	}592593	pub fn set_variable_metadata(594		collection: &RefungibleHandle<T>,595		sender: &T::CrossAccountId,596		token: TokenId,597		data: BoundedVec<u8, CustomDataLimit>,598	) -> DispatchResult {599		collection.check_can_update_meta(600			sender,601			&T::CrossAccountId::from_sub(collection.owner.clone()),602		)?;603604		let token_data = <TokenData<T>>::get((collection.id, token));605606		// =========607608		<TokenData<T>>::insert(609			(collection.id, token),610			ItemData {611				variable_data: data,612				..token_data613			},614		);615		Ok(())616	}617618	/// Delegated to `create_multiple_items`619	pub fn create_item(620		collection: &RefungibleHandle<T>,621		sender: &T::CrossAccountId,622		data: CreateRefungibleExData<T::CrossAccountId>,623	) -> DispatchResult {624		Self::create_multiple_items(collection, sender, vec![data])625	}626}