git.delta.rocks / unique-network / refs/commits / 49a12f2c8527

difftreelog

Merge pull request #437 from UniqueNetwork/doc/pallet-fungible

Yaroslav Bolyukin2022-07-19parents: #e2730ed #95d6df7.patch.diff
in: master
doc(pallet-fungible): document public api

3 files changed

modifiedpallets/fungible/src/common.rsdiffbeforeafterboth
before · pallets/fungible/src/common.rs
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/>.1617use core::marker::PhantomData;1819use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight, traits::Get};20use up_data_structs::{TokenId, CollectionId, CreateItemExData, budget::Budget, CreateItemData};21use pallet_common::{CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions, with_weight};22use pallet_structure::Error as StructureError;23use sp_runtime::ArithmeticError;24use sp_std::{vec::Vec, vec};25use up_data_structs::{Property, PropertyKey, PropertyValue, PropertyKeyPermission};2627use crate::{28	Allowance, TotalSupply, Balance, Config, Error, FungibleHandle, Pallet, SelfWeightOf,29	weights::WeightInfo,30};3132pub struct CommonWeights<T: Config>(PhantomData<T>);33impl<T: Config> CommonWeightInfo<T::CrossAccountId> for CommonWeights<T> {34	fn create_item() -> Weight {35		<SelfWeightOf<T>>::create_item()36	}3738	fn create_multiple_items(_data: &[CreateItemData]) -> Weight {39		// All items minted for the same user, so it works same as create_item40		Self::create_item()41	}4243	fn create_multiple_items_ex(data: &CreateItemExData<T::CrossAccountId>) -> Weight {44		match data {45			CreateItemExData::Fungible(f) => {46				<SelfWeightOf<T>>::create_multiple_items_ex(f.len() as u32)47			}48			_ => 0,49		}50	}5152	fn burn_item() -> Weight {53		<SelfWeightOf<T>>::burn_item()54	}5556	fn set_collection_properties(_amount: u32) -> Weight {57		// Error58		059	}6061	fn delete_collection_properties(_amount: u32) -> Weight {62		// Error63		064	}6566	fn set_token_properties(_amount: u32) -> Weight {67		// Error68		069	}7071	fn delete_token_properties(_amount: u32) -> Weight {72		// Error73		074	}7576	fn set_token_property_permissions(_amount: u32) -> Weight {77		// Error78		079	}8081	fn transfer() -> Weight {82		<SelfWeightOf<T>>::transfer()83	}8485	fn approve() -> Weight {86		<SelfWeightOf<T>>::approve()87	}8889	fn transfer_from() -> Weight {90		<SelfWeightOf<T>>::transfer_from()91	}9293	fn burn_from() -> Weight {94		<SelfWeightOf<T>>::burn_from()95	}9697	fn burn_recursively_self_raw() -> Weight {98		// Read to get total balance99		Self::burn_item() + T::DbWeight::get().reads(1)100	}101102	fn burn_recursively_breadth_raw(_amount: u32) -> Weight {103		// Fungible tokens can't have children104		0105	}106}107108impl<T: Config> CommonCollectionOperations<T> for FungibleHandle<T> {109	fn create_item(110		&self,111		sender: T::CrossAccountId,112		to: T::CrossAccountId,113		data: up_data_structs::CreateItemData,114		nesting_budget: &dyn Budget,115	) -> DispatchResultWithPostInfo {116		match data {117			up_data_structs::CreateItemData::Fungible(data) => with_weight(118				<Pallet<T>>::create_item(self, &sender, (to, data.value), nesting_budget),119				<CommonWeights<T>>::create_item(),120			),121			_ => fail!(<Error<T>>::NotFungibleDataUsedToMintFungibleCollectionToken),122		}123	}124125	fn create_multiple_items(126		&self,127		sender: T::CrossAccountId,128		to: T::CrossAccountId,129		data: Vec<up_data_structs::CreateItemData>,130		nesting_budget: &dyn Budget,131	) -> DispatchResultWithPostInfo {132		let mut sum: u128 = 0;133		for data in data {134			match data {135				up_data_structs::CreateItemData::Fungible(data) => {136					sum = sum137						.checked_add(data.value)138						.ok_or(ArithmeticError::Overflow)?;139				}140				_ => fail!(<Error<T>>::NotFungibleDataUsedToMintFungibleCollectionToken),141			}142		}143144		with_weight(145			<Pallet<T>>::create_item(self, &sender, (to, sum), nesting_budget),146			<CommonWeights<T>>::create_item(),147		)148	}149150	fn create_multiple_items_ex(151		&self,152		sender: <T>::CrossAccountId,153		data: up_data_structs::CreateItemExData<<T>::CrossAccountId>,154		nesting_budget: &dyn Budget,155	) -> DispatchResultWithPostInfo {156		let weight = <CommonWeights<T>>::create_multiple_items_ex(&data);157		let data = match data {158			up_data_structs::CreateItemExData::Fungible(f) => f,159			_ => fail!(<Error<T>>::NotFungibleDataUsedToMintFungibleCollectionToken),160		};161162		with_weight(163			<Pallet<T>>::create_multiple_items(self, &sender, data.into_inner(), nesting_budget),164			weight,165		)166	}167168	fn burn_item(169		&self,170		sender: T::CrossAccountId,171		token: TokenId,172		amount: u128,173	) -> DispatchResultWithPostInfo {174		ensure!(175			token == TokenId::default(),176			<Error<T>>::FungibleItemsHaveNoId177		);178179		with_weight(180			<Pallet<T>>::burn(self, &sender, amount),181			<CommonWeights<T>>::burn_item(),182		)183	}184185	fn burn_item_recursively(186		&self,187		sender: T::CrossAccountId,188		token: TokenId,189		self_budget: &dyn Budget,190		_breadth_budget: &dyn Budget,191	) -> DispatchResultWithPostInfo {192		// Should not happen?193		ensure!(194			token == TokenId::default(),195			<Error<T>>::FungibleItemsHaveNoId196		);197		ensure!(self_budget.consume(), <StructureError<T>>::DepthLimit,);198199		with_weight(200			<Pallet<T>>::burn(self, &sender, <Balance<T>>::get((self.id, &sender))),201			<CommonWeights<T>>::burn_recursively_self_raw(),202		)203	}204205	fn transfer(206		&self,207		from: T::CrossAccountId,208		to: T::CrossAccountId,209		token: TokenId,210		amount: u128,211		nesting_budget: &dyn Budget,212	) -> DispatchResultWithPostInfo {213		ensure!(214			token == TokenId::default(),215			<Error<T>>::FungibleItemsHaveNoId216		);217218		with_weight(219			<Pallet<T>>::transfer(self, &from, &to, amount, nesting_budget),220			<CommonWeights<T>>::transfer(),221		)222	}223224	fn approve(225		&self,226		sender: T::CrossAccountId,227		spender: T::CrossAccountId,228		token: TokenId,229		amount: u128,230	) -> DispatchResultWithPostInfo {231		ensure!(232			token == TokenId::default(),233			<Error<T>>::FungibleItemsHaveNoId234		);235236		with_weight(237			<Pallet<T>>::set_allowance(self, &sender, &spender, amount),238			<CommonWeights<T>>::approve(),239		)240	}241242	fn transfer_from(243		&self,244		sender: T::CrossAccountId,245		from: T::CrossAccountId,246		to: T::CrossAccountId,247		token: TokenId,248		amount: u128,249		nesting_budget: &dyn Budget,250	) -> DispatchResultWithPostInfo {251		ensure!(252			token == TokenId::default(),253			<Error<T>>::FungibleItemsHaveNoId254		);255256		with_weight(257			<Pallet<T>>::transfer_from(self, &sender, &from, &to, amount, nesting_budget),258			<CommonWeights<T>>::transfer_from(),259		)260	}261262	fn burn_from(263		&self,264		sender: T::CrossAccountId,265		from: T::CrossAccountId,266		token: TokenId,267		amount: u128,268		nesting_budget: &dyn Budget,269	) -> DispatchResultWithPostInfo {270		ensure!(271			token == TokenId::default(),272			<Error<T>>::FungibleItemsHaveNoId273		);274275		with_weight(276			<Pallet<T>>::burn_from(self, &sender, &from, amount, nesting_budget),277			<CommonWeights<T>>::burn_from(),278		)279	}280281	fn set_collection_properties(282		&self,283		_sender: T::CrossAccountId,284		_property: Vec<Property>,285	) -> DispatchResultWithPostInfo {286		fail!(<Error<T>>::SettingPropertiesNotAllowed)287	}288289	fn delete_collection_properties(290		&self,291		_sender: &T::CrossAccountId,292		_property_keys: Vec<PropertyKey>,293	) -> DispatchResultWithPostInfo {294		fail!(<Error<T>>::SettingPropertiesNotAllowed)295	}296297	fn set_token_properties(298		&self,299		_sender: T::CrossAccountId,300		_token_id: TokenId,301		_property: Vec<Property>,302		_nesting_budget: &dyn Budget,303	) -> DispatchResultWithPostInfo {304		fail!(<Error<T>>::SettingPropertiesNotAllowed)305	}306307	fn set_token_property_permissions(308		&self,309		_sender: &T::CrossAccountId,310		_property_permissions: Vec<PropertyKeyPermission>,311	) -> DispatchResultWithPostInfo {312		fail!(<Error<T>>::SettingPropertiesNotAllowed)313	}314315	fn delete_token_properties(316		&self,317		_sender: T::CrossAccountId,318		_token_id: TokenId,319		_property_keys: Vec<PropertyKey>,320		_nesting_budget: &dyn Budget,321	) -> DispatchResultWithPostInfo {322		fail!(<Error<T>>::SettingPropertiesNotAllowed)323	}324325	fn check_nesting(326		&self,327		_sender: <T>::CrossAccountId,328		_from: (CollectionId, TokenId),329		_under: TokenId,330		_nesting_budget: &dyn Budget,331	) -> sp_runtime::DispatchResult {332		fail!(<Error<T>>::FungibleDisallowsNesting)333	}334335	fn nest(&self, _under: TokenId, _to_nest: (CollectionId, TokenId)) {}336337	fn unnest(&self, _under: TokenId, _to_nest: (CollectionId, TokenId)) {}338339	fn collection_tokens(&self) -> Vec<TokenId> {340		vec![TokenId::default()]341	}342343	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId> {344		if <Balance<T>>::get((self.id, account)) != 0 {345			vec![TokenId::default()]346		} else {347			vec![]348		}349	}350351	fn token_exists(&self, token: TokenId) -> bool {352		token == TokenId::default()353	}354355	fn last_token_id(&self) -> TokenId {356		TokenId::default()357	}358359	fn token_owner(&self, _token: TokenId) -> Option<T::CrossAccountId> {360		None361	}362363	fn token_property(&self, _token_id: TokenId, _key: &PropertyKey) -> Option<PropertyValue> {364		None365	}366367	fn token_properties(368		&self,369		_token_id: TokenId,370		_keys: Option<Vec<PropertyKey>>,371	) -> Vec<Property> {372		Vec::new()373	}374375	fn total_supply(&self) -> u32 {376		1377	}378379	fn account_balance(&self, account: T::CrossAccountId) -> u32 {380		if <Balance<T>>::get((self.id, account)) != 0 {381			1382		} else {383			0384		}385	}386387	fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128 {388		if token != TokenId::default() {389			return 0;390		}391		<Balance<T>>::get((self.id, account))392	}393394	fn allowance(395		&self,396		sender: T::CrossAccountId,397		spender: T::CrossAccountId,398		token: TokenId,399	) -> u128 {400		if token != TokenId::default() {401			return 0;402		}403		<Allowance<T>>::get((self.id, sender, spender))404	}405406	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>> {407		None408	}409410	fn total_pieces(&self, token: TokenId) -> Option<u128> {411		if token != TokenId::default() {412			return None;413		}414		<TotalSupply<T>>::try_get(self.id).ok()415	}416}
after · pallets/fungible/src/common.rs
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/>.1617use core::marker::PhantomData;1819use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight, traits::Get};20use up_data_structs::{TokenId, CollectionId, CreateItemExData, budget::Budget, CreateItemData};21use pallet_common::{CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions, with_weight};22use pallet_structure::Error as StructureError;23use sp_runtime::ArithmeticError;24use sp_std::{vec::Vec, vec};25use up_data_structs::{Property, PropertyKey, PropertyValue, PropertyKeyPermission};2627use crate::{28	Allowance, TotalSupply, Balance, Config, Error, FungibleHandle, Pallet, SelfWeightOf,29	weights::WeightInfo,30};3132pub struct CommonWeights<T: Config>(PhantomData<T>);33impl<T: Config> CommonWeightInfo<T::CrossAccountId> for CommonWeights<T> {34	fn create_item() -> Weight {35		<SelfWeightOf<T>>::create_item()36	}3738	fn create_multiple_items(_data: &[CreateItemData]) -> Weight {39		// All items minted for the same user, so it works same as create_item40		Self::create_item()41	}4243	fn create_multiple_items_ex(data: &CreateItemExData<T::CrossAccountId>) -> Weight {44		match data {45			CreateItemExData::Fungible(f) => {46				<SelfWeightOf<T>>::create_multiple_items_ex(f.len() as u32)47			}48			_ => 0,49		}50	}5152	fn burn_item() -> Weight {53		<SelfWeightOf<T>>::burn_item()54	}5556	fn set_collection_properties(_amount: u32) -> Weight {57		// Error58		059	}6061	fn delete_collection_properties(_amount: u32) -> Weight {62		// Error63		064	}6566	fn set_token_properties(_amount: u32) -> Weight {67		// Error68		069	}7071	fn delete_token_properties(_amount: u32) -> Weight {72		// Error73		074	}7576	fn set_token_property_permissions(_amount: u32) -> Weight {77		// Error78		079	}8081	fn transfer() -> Weight {82		<SelfWeightOf<T>>::transfer()83	}8485	fn approve() -> Weight {86		<SelfWeightOf<T>>::approve()87	}8889	fn transfer_from() -> Weight {90		<SelfWeightOf<T>>::transfer_from()91	}9293	fn burn_from() -> Weight {94		<SelfWeightOf<T>>::burn_from()95	}9697	fn burn_recursively_self_raw() -> Weight {98		// Read to get total balance99		Self::burn_item() + T::DbWeight::get().reads(1)100	}101102	fn burn_recursively_breadth_raw(_amount: u32) -> Weight {103		// Fungible tokens can't have children104		0105	}106}107108/// Implementation of `CommonCollectionOperations` for `FungibleHandle`. It wraps FungibleHandle Pallete109/// methods and adds weight info.110impl<T: Config> CommonCollectionOperations<T> for FungibleHandle<T> {111	fn create_item(112		&self,113		sender: T::CrossAccountId,114		to: T::CrossAccountId,115		data: up_data_structs::CreateItemData,116		nesting_budget: &dyn Budget,117	) -> DispatchResultWithPostInfo {118		match data {119			up_data_structs::CreateItemData::Fungible(data) => with_weight(120				<Pallet<T>>::create_item(self, &sender, (to, data.value), nesting_budget),121				<CommonWeights<T>>::create_item(),122			),123			_ => fail!(<Error<T>>::NotFungibleDataUsedToMintFungibleCollectionToken),124		}125	}126127	fn create_multiple_items(128		&self,129		sender: T::CrossAccountId,130		to: T::CrossAccountId,131		data: Vec<up_data_structs::CreateItemData>,132		nesting_budget: &dyn Budget,133	) -> DispatchResultWithPostInfo {134		let mut sum: u128 = 0;135		for data in data {136			match data {137				up_data_structs::CreateItemData::Fungible(data) => {138					sum = sum139						.checked_add(data.value)140						.ok_or(ArithmeticError::Overflow)?;141				}142				_ => fail!(<Error<T>>::NotFungibleDataUsedToMintFungibleCollectionToken),143			}144		}145146		with_weight(147			<Pallet<T>>::create_item(self, &sender, (to, sum), nesting_budget),148			<CommonWeights<T>>::create_item(),149		)150	}151152	fn create_multiple_items_ex(153		&self,154		sender: <T>::CrossAccountId,155		data: up_data_structs::CreateItemExData<<T>::CrossAccountId>,156		nesting_budget: &dyn Budget,157	) -> DispatchResultWithPostInfo {158		let weight = <CommonWeights<T>>::create_multiple_items_ex(&data);159		let data = match data {160			up_data_structs::CreateItemExData::Fungible(f) => f,161			_ => fail!(<Error<T>>::NotFungibleDataUsedToMintFungibleCollectionToken),162		};163164		with_weight(165			<Pallet<T>>::create_multiple_items(self, &sender, data.into_inner(), nesting_budget),166			weight,167		)168	}169170	fn burn_item(171		&self,172		sender: T::CrossAccountId,173		token: TokenId,174		amount: u128,175	) -> DispatchResultWithPostInfo {176		ensure!(177			token == TokenId::default(),178			<Error<T>>::FungibleItemsHaveNoId179		);180181		with_weight(182			<Pallet<T>>::burn(self, &sender, amount),183			<CommonWeights<T>>::burn_item(),184		)185	}186187	fn burn_item_recursively(188		&self,189		sender: T::CrossAccountId,190		token: TokenId,191		self_budget: &dyn Budget,192		_breadth_budget: &dyn Budget,193	) -> DispatchResultWithPostInfo {194		// Should not happen?195		ensure!(196			token == TokenId::default(),197			<Error<T>>::FungibleItemsHaveNoId198		);199		ensure!(self_budget.consume(), <StructureError<T>>::DepthLimit,);200201		with_weight(202			<Pallet<T>>::burn(self, &sender, <Balance<T>>::get((self.id, &sender))),203			<CommonWeights<T>>::burn_recursively_self_raw(),204		)205	}206207	fn transfer(208		&self,209		from: T::CrossAccountId,210		to: T::CrossAccountId,211		token: TokenId,212		amount: u128,213		nesting_budget: &dyn Budget,214	) -> DispatchResultWithPostInfo {215		ensure!(216			token == TokenId::default(),217			<Error<T>>::FungibleItemsHaveNoId218		);219220		with_weight(221			<Pallet<T>>::transfer(self, &from, &to, amount, nesting_budget),222			<CommonWeights<T>>::transfer(),223		)224	}225226	fn approve(227		&self,228		sender: T::CrossAccountId,229		spender: T::CrossAccountId,230		token: TokenId,231		amount: u128,232	) -> DispatchResultWithPostInfo {233		ensure!(234			token == TokenId::default(),235			<Error<T>>::FungibleItemsHaveNoId236		);237238		with_weight(239			<Pallet<T>>::set_allowance(self, &sender, &spender, amount),240			<CommonWeights<T>>::approve(),241		)242	}243244	fn transfer_from(245		&self,246		sender: T::CrossAccountId,247		from: T::CrossAccountId,248		to: T::CrossAccountId,249		token: TokenId,250		amount: u128,251		nesting_budget: &dyn Budget,252	) -> DispatchResultWithPostInfo {253		ensure!(254			token == TokenId::default(),255			<Error<T>>::FungibleItemsHaveNoId256		);257258		with_weight(259			<Pallet<T>>::transfer_from(self, &sender, &from, &to, amount, nesting_budget),260			<CommonWeights<T>>::transfer_from(),261		)262	}263264	fn burn_from(265		&self,266		sender: T::CrossAccountId,267		from: T::CrossAccountId,268		token: TokenId,269		amount: u128,270		nesting_budget: &dyn Budget,271	) -> DispatchResultWithPostInfo {272		ensure!(273			token == TokenId::default(),274			<Error<T>>::FungibleItemsHaveNoId275		);276277		with_weight(278			<Pallet<T>>::burn_from(self, &sender, &from, amount, nesting_budget),279			<CommonWeights<T>>::burn_from(),280		)281	}282283	fn set_collection_properties(284		&self,285		_sender: T::CrossAccountId,286		_property: Vec<Property>,287	) -> DispatchResultWithPostInfo {288		fail!(<Error<T>>::SettingPropertiesNotAllowed)289	}290291	fn delete_collection_properties(292		&self,293		_sender: &T::CrossAccountId,294		_property_keys: Vec<PropertyKey>,295	) -> DispatchResultWithPostInfo {296		fail!(<Error<T>>::SettingPropertiesNotAllowed)297	}298299	fn set_token_properties(300		&self,301		_sender: T::CrossAccountId,302		_token_id: TokenId,303		_property: Vec<Property>,304		_nesting_budget: &dyn Budget,305	) -> DispatchResultWithPostInfo {306		fail!(<Error<T>>::SettingPropertiesNotAllowed)307	}308309	fn set_token_property_permissions(310		&self,311		_sender: &T::CrossAccountId,312		_property_permissions: Vec<PropertyKeyPermission>,313	) -> DispatchResultWithPostInfo {314		fail!(<Error<T>>::SettingPropertiesNotAllowed)315	}316317	fn delete_token_properties(318		&self,319		_sender: T::CrossAccountId,320		_token_id: TokenId,321		_property_keys: Vec<PropertyKey>,322		_nesting_budget: &dyn Budget,323	) -> DispatchResultWithPostInfo {324		fail!(<Error<T>>::SettingPropertiesNotAllowed)325	}326327	fn check_nesting(328		&self,329		_sender: <T>::CrossAccountId,330		_from: (CollectionId, TokenId),331		_under: TokenId,332		_nesting_budget: &dyn Budget,333	) -> sp_runtime::DispatchResult {334		fail!(<Error<T>>::FungibleDisallowsNesting)335	}336337	fn nest(&self, _under: TokenId, _to_nest: (CollectionId, TokenId)) {}338339	fn unnest(&self, _under: TokenId, _to_nest: (CollectionId, TokenId)) {}340341	fn collection_tokens(&self) -> Vec<TokenId> {342		vec![TokenId::default()]343	}344345	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId> {346		if <Balance<T>>::get((self.id, account)) != 0 {347			vec![TokenId::default()]348		} else {349			vec![]350		}351	}352353	fn token_exists(&self, token: TokenId) -> bool {354		token == TokenId::default()355	}356357	fn last_token_id(&self) -> TokenId {358		TokenId::default()359	}360361	fn token_owner(&self, _token: TokenId) -> Option<T::CrossAccountId> {362		None363	}364365	fn token_property(&self, _token_id: TokenId, _key: &PropertyKey) -> Option<PropertyValue> {366		None367	}368369	fn token_properties(370		&self,371		_token_id: TokenId,372		_keys: Option<Vec<PropertyKey>>,373	) -> Vec<Property> {374		Vec::new()375	}376377	fn total_supply(&self) -> u32 {378		1379	}380381	fn account_balance(&self, account: T::CrossAccountId) -> u32 {382		if <Balance<T>>::get((self.id, account)) != 0 {383			1384		} else {385			0386		}387	}388389	fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128 {390		if token != TokenId::default() {391			return 0;392		}393		<Balance<T>>::get((self.id, account))394	}395396	fn allowance(397		&self,398		sender: T::CrossAccountId,399		spender: T::CrossAccountId,400		token: TokenId,401	) -> u128 {402		if token != TokenId::default() {403			return 0;404		}405		<Allowance<T>>::get((self.id, sender, spender))406	}407408	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>> {409		None410	}411412	fn total_pieces(&self, token: TokenId) -> Option<u128> {413		if token != TokenId::default() {414			return None;415		}416		<TotalSupply<T>>::try_get(self.id).ok()417	}418}
modifiedpallets/fungible/src/erc.rsdiffbeforeafterboth
--- a/pallets/fungible/src/erc.rs
+++ b/pallets/fungible/src/erc.rs
@@ -14,6 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
+//! ERC-20 standart support implementation.
+
 use core::char::{REPLACEMENT_CHARACTER, decode_utf16};
 use core::convert::TryInto;
 use evm_coder::{ToLog, execution::*, generate_stubgen, solidity_interface, types::*, weight};
modifiedpallets/fungible/src/lib.rsdiffbeforeafterboth
--- a/pallets/fungible/src/lib.rs
+++ b/pallets/fungible/src/lib.rs
@@ -14,6 +14,68 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
+//! # Fungible Pallet
+//!
+//! The Fungible pallet provides functionality for dealing with fungible assets.
+//!
+//! - [`CreateItemData`]
+//! - [`Config`]
+//! - [`FungibleHandle`]
+//! - [`Pallet`]
+//! - [`TotalSupply`]
+//! - [`Balance`]
+//! - [`Allowance`]
+//! - [`Error`]
+//!
+//! ## Fungible tokens
+//!
+//! Fungible tokens or assets are divisible and non-unique. For instance,
+//! fiat currencies like the dollar are fungible: A $1 bill
+//! in New York City has the same value as a $1 bill in Miami.
+//! A fungible token can also be a cryptocurrency like Bitcoin: 1 BTC is worth 1 BTC,
+//! no matter where it is issued. Thus, the fungibility refers to a specific currency’s
+//! ability to maintain one standard value. As well, it needs to have uniform acceptance.
+//! This means that a currency’s history should not be able to affect its value,
+//! and this is due to the fact that each piece that is a part of the currency is equal
+//! in value when compared to every other piece of that exact same currency.
+//! In the world of cryptocurrencies, this is essentially a coin or a token
+//! that can be replaced by another identical coin or token, and they are
+//! both mutually interchangeable. A popular implementation of fungible tokens is
+//! the ERC-20 token standard.
+//!
+//! ### ERC-20
+//!
+//! The [ERC-20](https://ethereum.org/en/developers/docs/standards/tokens/erc-20/) (Ethereum Request for Comments 20), proposed by Fabian Vogelsteller in November 2015,
+//! is a Token Standard that implements an API for tokens within Smart Contracts.
+//!
+//! Example functionalities ERC-20 provides:
+//!
+//! * transfer tokens from one account to another
+//! * get the current token balance of an account
+//! * get the total supply of the token available on the network
+//! * approve whether an amount of token from an account can be spent by a third-party account
+//!
+//! ## Overview
+//!
+//! The module provides functionality for asset management of fungible asset, supports ERC-20 standart, includes:
+//!
+//! * Asset Issuance
+//! * Asset Transferal
+//! * Asset Destruction
+//! * Delegated Asset Transfers
+//!
+//! **NOTE:** The created fungible asset always has `token_id` = 0.
+//! So `tokenA` and `tokenB` will have different `collection_id`.
+//!
+//! ### Implementations
+//!
+//! The Fungible pallet provides implementations for the following traits.
+//!
+//! - [`WithRecorder`](pallet_evm_coder_substrate::WithRecorder): Trait for EVM support
+//! - [`CommonCollectionOperations`](pallet_common::CommonCollectionOperations): Functions for dealing with collections
+//!	- [`CommonWeightInfo`](pallet_common::CommonWeightInfo): Functions for retrieval of transaction weight
+//! - [`CommonEvmHandler`](pallet_common::erc::CommonEvmHandler): Function for handling EVM runtime calls
+
 #![cfg_attr(not(feature = "std"), no_std)]
 
 use core::ops::Deref;
@@ -57,13 +119,14 @@
 	pub enum Error<T> {
 		/// Not Fungible item data used to mint in Fungible collection.
 		NotFungibleDataUsedToMintFungibleCollectionToken,
-		/// Not default id passed as TokenId argument
+		/// Not default id passed as TokenId argument.
+		/// The default value of TokenId for Fungible collection is 0.
 		FungibleItemsHaveNoId,
-		/// Tried to set data for fungible item
+		/// Tried to set data for fungible item.
 		FungibleItemsDontHaveData,
-		/// Fungible token does not support nested
+		/// Fungible token does not support nesting.
 		FungibleDisallowsNesting,
-		/// Setting item properties is not allowed
+		/// Setting item properties is not allowed.
 		SettingPropertiesNotAllowed,
 	}
 
@@ -78,10 +141,12 @@
 	#[pallet::generate_store(pub(super) trait Store)]
 	pub struct Pallet<T>(_);
 
+	/// Total amount of fungible tokens inside a collection.
 	#[pallet::storage]
 	pub type TotalSupply<T: Config> =
 		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u128, QueryKind = ValueQuery>;
 
+	/// Amount of tokens owned by an account inside a collection.
 	#[pallet::storage]
 	pub type Balance<T: Config> = StorageNMap<
 		Key = (
@@ -92,6 +157,7 @@
 		QueryKind = ValueQuery,
 	>;
 
+	/// Storage for delegated assets.
 	#[pallet::storage]
 	pub type Allowance<T: Config> = StorageNMap<
 		Key = (
@@ -104,14 +170,23 @@
 	>;
 }
 
+/// Wrapper around untyped collection handle, asserting inner collection is of fungible type.
+/// Required for interaction with Fungible collections, type safety and implementation [`solidity_interface`][`evm_coder::solidity_interface`].
+
 pub struct FungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);
+
+/// Implementation of methods required for dispatching during runtime.
 impl<T: Config> FungibleHandle<T> {
+	/// Casts [`CollectionHandle`][`pallet_common::CollectionHandle`] into [`FungibleHandle`].
 	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {
 		Self(inner)
 	}
+
+	/// Casts [`FungibleHandle`] into [`CollectionHandle`][`pallet_common::CollectionHandle`].
 	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {
 		self.0
 	}
+	/// Returns a mutable reference to the internal [`CollectionHandle`][`pallet_common::CollectionHandle`].
 	pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {
 		&mut self.0
 	}
@@ -132,13 +207,17 @@
 	}
 }
 
+/// Pallet implementation for fungible assets
 impl<T: Config> Pallet<T> {
+	/// Initializes the collection. Returns [CollectionId] on success, [DispatchError] otherwise.
 	pub fn init_collection(
 		owner: T::CrossAccountId,
 		data: CreateCollectionData<T::AccountId>,
 	) -> Result<CollectionId, DispatchError> {
 		<PalletCommon<T>>::init_collection(owner, data, false)
 	}
+
+	/// Destroys a collection.
 	pub fn destroy_collection(
 		collection: FungibleHandle<T>,
 		sender: &T::CrossAccountId,
@@ -159,10 +238,14 @@
 		Ok(())
 	}
 
+	///Checks if collection has tokens. Return `true` if it has.
 	fn collection_has_tokens(collection_id: CollectionId) -> bool {
 		<TotalSupply<T>>::get(collection_id) != 0
 	}
 
+	/// Burns the specified amount of the token. If the token balance
+	/// or total supply is less than the given value,
+	/// it will return [DispatchError].
 	pub fn burn(
 		collection: &FungibleHandle<T>,
 		owner: &T::CrossAccountId,
@@ -207,6 +290,13 @@
 		Ok(())
 	}
 
+	/// Transfers the specified amount of tokens. Will check that
+	/// the transfer is allowed for the token.
+	///
+	/// - `from`: Owner of tokens to transfer.
+	/// - `to`: Recepient of transfered tokens.
+	/// - `amount`: Amount of tokens to transfer.
+	/// - `collection`: Collection that contains the token
 	pub fn transfer(
 		collection: &FungibleHandle<T>,
 		from: &T::CrossAccountId,
@@ -277,6 +367,8 @@
 		Ok(())
 	}
 
+	/// Minting tokens for multiple IDs.
+	/// See [`create_item`][`Pallet::create_item`] for more details.
 	pub fn create_multiple_items(
 		collection: &FungibleHandle<T>,
 		sender: &T::CrossAccountId,
@@ -378,6 +470,12 @@
 		));
 	}
 
+	/// Set allowance for the spender to `transfer` or `burn` owner's tokens.
+	///
+	/// - `collection`: Collection that contains the token
+	/// - `owner`: Owner of tokens that sets the allowance.
+	/// - `spender`: Recipient of the allowance rights.
+	/// - `amount`: Amount of tokens the spender is allowed to `transfer` or `burn`.
 	pub fn set_allowance(
 		collection: &FungibleHandle<T>,
 		owner: &T::CrossAccountId,
@@ -402,6 +500,13 @@
 		Ok(())
 	}
 
+	/// Checks if a non-owner has (enough) allowance from the owner to perform operations on the tokens.
+	/// Returns the expected remaining allowance - it should be set manually if the transaction proceeds.
+	///
+	/// - `collection`: Collection that contains the token.
+	/// - `spender`: CrossAccountId who has the allowance rights.
+	/// - `from`: The owner of the tokens who sets the allowance.
+	/// - `amount`: Amount of tokens by which the allowance sholud be reduced.
 	fn check_allowed(
 		collection: &FungibleHandle<T>,
 		spender: &T::CrossAccountId,
@@ -441,6 +546,11 @@
 		Ok(allowance)
 	}
 
+	/// Transfer fungible tokens from one account to another.
+	/// Same as the [`transfer`][`Pallet::transfer`] but spender doesn't needs to be an owner of the token pieces.
+	/// The owner should set allowance for the spender to transfer pieces.
+	///	See [`set_allowance`][`Pallet::set_allowance`] for more details.
+
 	pub fn transfer_from(
 		collection: &FungibleHandle<T>,
 		spender: &T::CrossAccountId,
@@ -460,6 +570,11 @@
 		Ok(())
 	}
 
+	/// Burn fungible tokens from the account.
+	///
+	/// Same as the [`burn`][`Pallet::burn`] but spender doesn't need to be an owner of the tokens. The `from` should
+	/// set allowance for the spender to burn tokens.
+	/// See [`set_allowance`][`Pallet::set_allowance`] for more details.
 	pub fn burn_from(
 		collection: &FungibleHandle<T>,
 		spender: &T::CrossAccountId,
@@ -478,7 +593,13 @@
 		Ok(())
 	}
 
-	/// Delegated to `create_multiple_items`
+	///	Creates fungible token.
+	///
+	/// The sender should be the owner/admin of the collection or collection should be configured
+	/// to allow public minting.
+	///
+	/// - `data`: Contains user who will become the owners of the tokens and amount
+	///   of tokens he will receive.
 	pub fn create_item(
 		collection: &FungibleHandle<T>,
 		sender: &T::CrossAccountId,