difftreelog
fix cargo fmt
in: master
1 file changed
pallets/fungible/src/lib.rsdiffbeforeafterboth1// 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//! # Fungible Pallet18//!19//! The Fungible pallet provides functionality for dealing with fungible assets.20//!21//! - [`CreateItemData`]22//! - [`Config`]23//! - [`FungibleHandle`]24//! - [`Pallet`]25//! - [`TotalSupply`]26//! - [`Balance`]27//! - [`Allowance`]28//! - [`Error`]29//!30//! ## Fungible tokens31//!32//! Fungible tokens or assets are divisible and non-unique. For instance,33//! fiat currencies like the dollar are fungible: A $1 bill34//! in New York City has the same value as a $1 bill in Miami.35//! A fungible token can also be a cryptocurrency like Bitcoin: 1 BTC is worth 1 BTC,36//! no matter where it is issued. Thus, the fungibility refers to a specific currency’s37//! ability to maintain one standard value. As well, it needs to have uniform acceptance.38//! This means that a currency’s history should not be able to affect its value,39//! and this is due to the fact that each piece that is a part of the currency is equal40//! in value when compared to every other piece of that exact same currency.41//! In the world of cryptocurrencies, this is essentially a coin or a token42//! that can be replaced by another identical coin or token, and they are43//! both mutually interchangeable. A popular implementation of fungible tokens is44//! the ERC-20 token standard.45//!46//! ### ERC-2047//!48//! 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,49//! is a Token Standard that implements an API for tokens within Smart Contracts.50//!51//! Example functionalities ERC-20 provides:52//!53//! * transfer tokens from one account to another54//! * get the current token balance of an account55//! * get the total supply of the token available on the network56//! * approve whether an amount of token from an account can be spent by a third-party account57//!58//! ## Overview59//!60//! The module provides functionality for asset management of fungible asset, supports ERC-20 standart, includes:61//!62//! * Asset Issuance63//! * Asset Transferal64//! * Asset Destruction65//! * Delegated Asset Transfers66//!67//! **NOTE:** The created fungible asset always has `token_id` = 0.68//! So `tokenA` and `tokenB` will have different `collection_id`.69//!70//! ### Implementations71//!72//! The Fungible pallet provides implementations for the following traits.73//!74//! - [`WithRecorder`](pallet_evm_coder_substrate::WithRecorder):75//! - [`CommonCollectionOperations`](pallet_common::CommonCollectionOperations): Functions for dealing with collections76//! - [`CommonWeightInfo`](pallet_common::CommonWeightInfo): Functions for retrieval of transaction weight77//! - [`CommonEvmHandler`](pallet_common::erc::CommonEvmHandler): Function for handling EVM runtime calls7879#![cfg_attr(not(feature = "std"), no_std)]8081use core::ops::Deref;82use evm_coder::ToLog;83use frame_support::{ensure};84use pallet_evm::account::CrossAccountId;85use up_data_structs::{86 AccessMode, CollectionId, TokenId, CreateCollectionData, mapping::TokenAddressMapping,87 budget::Budget,88};89use pallet_common::{90 Error as CommonError, Event as CommonEvent, Pallet as PalletCommon,91 eth::collection_id_to_address,92};93use pallet_evm::Pallet as PalletEvm;94use pallet_structure::Pallet as PalletStructure;95use pallet_evm_coder_substrate::WithRecorder;96use sp_core::H160;97use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};98use sp_std::{collections::btree_map::BTreeMap};99100pub use pallet::*;101102use crate::erc::ERC20Events;103#[cfg(feature = "runtime-benchmarks")]104pub mod benchmarking;105pub mod common;106pub mod erc;107pub mod weights;108109pub type CreateItemData<T> = (<T as pallet_evm::account::Config>::CrossAccountId, u128);110pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;111112#[frame_support::pallet]113pub mod pallet {114 use frame_support::{Blake2_128, Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key};115 use up_data_structs::CollectionId;116 use super::weights::WeightInfo;117118 #[pallet::error]119 pub enum Error<T> {120 /// Not Fungible item data used to mint in Fungible collection.121 NotFungibleDataUsedToMintFungibleCollectionToken,122 /// Not default id passed as TokenId argument.123 FungibleItemsHaveNoId,124 /// Tried to set data for fungible item.125 FungibleItemsDontHaveData,126 /// Fungible token does not support nesting.127 FungibleDisallowsNesting,128 /// Setting item properties is not allowed.129 SettingPropertiesNotAllowed,130 }131132 #[pallet::config]133 pub trait Config:134 frame_system::Config + pallet_common::Config + pallet_structure::Config + pallet_evm::Config135 {136 type WeightInfo: WeightInfo;137 }138139 #[pallet::pallet]140 #[pallet::generate_store(pub(super) trait Store)]141 pub struct Pallet<T>(_);142143 /// Total amount of fungible tokens inside a collection.144 #[pallet::storage]145 pub type TotalSupply<T: Config> =146 StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u128, QueryKind = ValueQuery>;147148 /// Amount of tokens owned by an account inside a collection.149 #[pallet::storage]150 pub type Balance<T: Config> = StorageNMap<151 Key = (152 Key<Twox64Concat, CollectionId>,153 Key<Blake2_128Concat, T::CrossAccountId>,154 ),155 Value = u128,156 QueryKind = ValueQuery,157 >;158159 /// Storage for delegated assets.160 #[pallet::storage]161 pub type Allowance<T: Config> = StorageNMap<162 Key = (163 Key<Twox64Concat, CollectionId>,164 Key<Blake2_128, T::CrossAccountId>,165 Key<Blake2_128Concat, T::CrossAccountId>,166 ),167 Value = u128,168 QueryKind = ValueQuery,169 >;170}171/// Handler for fungible assets.172pub struct FungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);173impl<T: Config> FungibleHandle<T> {174 /// Casts [pallet_common::CollectionHandle] into [FungibleHandle].175 pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {176 Self(inner)177 }178179 /// Casts [FungibleHandle] into [pallet_common::CollectionHandle].180 pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {181 self.0182 }183 /// Returns a mutable reference to the internal [pallet_common::CollectionHandle].184 pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {185 &mut self.0186 }187}188impl<T: Config> WithRecorder<T> for FungibleHandle<T> {189 fn recorder(&self) -> &pallet_evm_coder_substrate::SubstrateRecorder<T> {190 self.0.recorder()191 }192 fn into_recorder(self) -> pallet_evm_coder_substrate::SubstrateRecorder<T> {193 self.0.into_recorder()194 }195}196impl<T: Config> Deref for FungibleHandle<T> {197 type Target = pallet_common::CollectionHandle<T>;198199 fn deref(&self) -> &Self::Target {200 &self.0201 }202}203204/// Pallet implementation for fungible assets205impl<T: Config> Pallet<T> {206 /// Initializes the collection. Returns [CollectionId] on success, [DispatchError] otherwise.207 pub fn init_collection(208 owner: T::CrossAccountId,209 data: CreateCollectionData<T::AccountId>,210 ) -> Result<CollectionId, DispatchError> {211 <PalletCommon<T>>::init_collection(owner, data, false)212 }213214 /// Destroys a collection.215 pub fn destroy_collection(216 collection: FungibleHandle<T>,217 sender: &T::CrossAccountId,218 ) -> DispatchResult {219 let id = collection.id;220221 if Self::collection_has_tokens(id) {222 return Err(<CommonError<T>>::CantDestroyNotEmptyCollection.into());223 }224225 // =========226227 PalletCommon::destroy_collection(collection.0, sender)?;228229 <TotalSupply<T>>::remove(id);230 <Balance<T>>::remove_prefix((id,), None);231 <Allowance<T>>::remove_prefix((id,), None);232 Ok(())233 }234235 ///Checks if collection has tokens. Return `true` if it has.236 fn collection_has_tokens(collection_id: CollectionId) -> bool {237 <TotalSupply<T>>::get(collection_id) != 0238 }239240 /// Burns the specified amount of the token. If the token balance241 /// or total supply is less than the given value,242 /// it will return [DispatchError].243 pub fn burn(244 collection: &FungibleHandle<T>,245 owner: &T::CrossAccountId,246 amount: u128,247 ) -> DispatchResult {248 let total_supply = <TotalSupply<T>>::get(collection.id)249 .checked_sub(amount)250 .ok_or(<CommonError<T>>::TokenValueTooLow)?;251252 let balance = <Balance<T>>::get((collection.id, owner))253 .checked_sub(amount)254 .ok_or(<CommonError<T>>::TokenValueTooLow)?;255256 if collection.permissions.access() == AccessMode::AllowList {257 collection.check_allowlist(owner)?;258 }259260 // =========261262 if balance == 0 {263 <Balance<T>>::remove((collection.id, owner));264 <PalletStructure<T>>::unnest_if_nested(owner, collection.id, TokenId::default());265 } else {266 <Balance<T>>::insert((collection.id, owner), balance);267 }268 <TotalSupply<T>>::insert(collection.id, total_supply);269270 <PalletEvm<T>>::deposit_log(271 ERC20Events::Transfer {272 from: *owner.as_eth(),273 to: H160::default(),274 value: amount.into(),275 }276 .to_log(collection_id_to_address(collection.id)),277 );278 <PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(279 collection.id,280 TokenId::default(),281 owner.clone(),282 amount,283 ));284 Ok(())285 }286287 /// Transfers the specified amount of tokens. Will check that288 /// the transfer is allowed for the token.289 pub fn transfer(290 collection: &FungibleHandle<T>,291 from: &T::CrossAccountId,292 to: &T::CrossAccountId,293 amount: u128,294 nesting_budget: &dyn Budget,295 ) -> DispatchResult {296 ensure!(297 collection.limits.transfers_enabled(),298 <CommonError<T>>::TransferNotAllowed,299 );300301 if collection.permissions.access() == AccessMode::AllowList {302 collection.check_allowlist(from)?;303 collection.check_allowlist(to)?;304 }305 <PalletCommon<T>>::ensure_correct_receiver(to)?;306307 let balance_from = <Balance<T>>::get((collection.id, from))308 .checked_sub(amount)309 .ok_or(<CommonError<T>>::TokenValueTooLow)?;310 let balance_to = if from != to {311 Some(312 <Balance<T>>::get((collection.id, to))313 .checked_add(amount)314 .ok_or(ArithmeticError::Overflow)?,315 )316 } else {317 None318 };319320 // =========321322 <PalletStructure<T>>::nest_if_sent_to_token(323 from.clone(),324 to,325 collection.id,326 TokenId::default(),327 nesting_budget,328 )?;329330 if let Some(balance_to) = balance_to {331 // from != to332 if balance_from == 0 {333 <Balance<T>>::remove((collection.id, from));334 <PalletStructure<T>>::unnest_if_nested(from, collection.id, TokenId::default());335 } else {336 <Balance<T>>::insert((collection.id, from), balance_from);337 }338 <Balance<T>>::insert((collection.id, to), balance_to);339 }340341 <PalletEvm<T>>::deposit_log(342 ERC20Events::Transfer {343 from: *from.as_eth(),344 to: *to.as_eth(),345 value: amount.into(),346 }347 .to_log(collection_id_to_address(collection.id)),348 );349 <PalletCommon<T>>::deposit_event(CommonEvent::Transfer(350 collection.id,351 TokenId::default(),352 from.clone(),353 to.clone(),354 amount,355 ));356 Ok(())357 }358359 /// Minting tokens for multiple IDs.360 pub fn create_multiple_items(361 collection: &FungibleHandle<T>,362 sender: &T::CrossAccountId,363 data: BTreeMap<T::CrossAccountId, u128>,364 nesting_budget: &dyn Budget,365 ) -> DispatchResult {366 if !collection.is_owner_or_admin(sender) {367 ensure!(368 collection.permissions.mint_mode(),369 <CommonError<T>>::PublicMintingNotAllowed370 );371 collection.check_allowlist(sender)?;372373 for (owner, _) in data.iter() {374 collection.check_allowlist(owner)?;375 }376 }377378 let total_supply = data379 .iter()380 .map(|(_, v)| *v)381 .try_fold(<TotalSupply<T>>::get(collection.id), |acc, v| {382 acc.checked_add(v)383 })384 .ok_or(ArithmeticError::Overflow)?;385386 let mut balances = data;387 for (k, v) in balances.iter_mut() {388 *v = <Balance<T>>::get((collection.id, &k))389 .checked_add(*v)390 .ok_or(ArithmeticError::Overflow)?;391 }392393 for (to, _) in balances.iter() {394 <PalletStructure<T>>::check_nesting(395 sender.clone(),396 to,397 collection.id,398 TokenId::default(),399 nesting_budget,400 )?;401 }402403 // =========404405 <TotalSupply<T>>::insert(collection.id, total_supply);406 for (user, amount) in balances {407 <Balance<T>>::insert((collection.id, &user), amount);408 <PalletStructure<T>>::nest_if_sent_to_token_unchecked(409 &user,410 collection.id,411 TokenId::default(),412 );413 <PalletEvm<T>>::deposit_log(414 ERC20Events::Transfer {415 from: H160::default(),416 to: *user.as_eth(),417 value: amount.into(),418 }419 .to_log(collection_id_to_address(collection.id)),420 );421 <PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(422 collection.id,423 TokenId::default(),424 user.clone(),425 amount,426 ));427 }428429 Ok(())430 }431432 fn set_allowance_unchecked(433 collection: &FungibleHandle<T>,434 owner: &T::CrossAccountId,435 spender: &T::CrossAccountId,436 amount: u128,437 ) {438 if amount == 0 {439 <Allowance<T>>::remove((collection.id, owner, spender));440 } else {441 <Allowance<T>>::insert((collection.id, owner, spender), amount);442 }443444 <PalletEvm<T>>::deposit_log(445 ERC20Events::Approval {446 owner: *owner.as_eth(),447 spender: *spender.as_eth(),448 value: amount.into(),449 }450 .to_log(collection_id_to_address(collection.id)),451 );452 <PalletCommon<T>>::deposit_event(CommonEvent::Approved(453 collection.id,454 TokenId(0),455 owner.clone(),456 spender.clone(),457 amount,458 ));459 }460461 /// Sets the amount of owner tokens that the spender can manage.462 pub fn set_allowance(463 collection: &FungibleHandle<T>,464 owner: &T::CrossAccountId,465 spender: &T::CrossAccountId,466 amount: u128,467 ) -> DispatchResult {468 if collection.permissions.access() == AccessMode::AllowList {469 collection.check_allowlist(owner)?;470 collection.check_allowlist(spender)?;471 }472473 if <Balance<T>>::get((collection.id, owner)) < amount {474 ensure!(475 collection.ignores_owned_amount(owner),476 <CommonError<T>>::CantApproveMoreThanOwned477 );478 }479480 // =========481482 Self::set_allowance_unchecked(collection, owner, spender, amount);483 Ok(())484 }485486 fn check_allowed(487 collection: &FungibleHandle<T>,488 spender: &T::CrossAccountId,489 from: &T::CrossAccountId,490 amount: u128,491 nesting_budget: &dyn Budget,492 ) -> Result<Option<u128>, DispatchError> {493 if spender.conv_eq(from) {494 return Ok(None);495 }496 if collection.permissions.access() == AccessMode::AllowList {497 // `from`, `to` checked in [`transfer`]498 collection.check_allowlist(spender)?;499 }500 if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {501 // TODO: should collection owner be allowed to perform this transfer?502 ensure!(503 <PalletStructure<T>>::check_indirectly_owned(504 spender.clone(),505 source.0,506 source.1,507 None,508 nesting_budget509 )?,510 <CommonError<T>>::ApprovedValueTooLow,511 );512 return Ok(None);513 }514 let allowance = <Allowance<T>>::get((collection.id, from, spender)).checked_sub(amount);515 if allowance.is_none() {516 ensure!(517 collection.ignores_allowance(spender),518 <CommonError<T>>::ApprovedValueTooLow519 );520 }521522 Ok(allowance)523 }524525 /// Transfers of tokens that `from` gave to `spender` to manage, to `to` ID.526 pub fn transfer_from(527 collection: &FungibleHandle<T>,528 spender: &T::CrossAccountId,529 from: &T::CrossAccountId,530 to: &T::CrossAccountId,531 amount: u128,532 nesting_budget: &dyn Budget,533 ) -> DispatchResult {534 let allowance = Self::check_allowed(collection, spender, from, amount, nesting_budget)?;535536 // =========537538 Self::transfer(collection, from, to, amount, nesting_budget)?;539 if let Some(allowance) = allowance {540 Self::set_allowance_unchecked(collection, from, spender, allowance);541 }542 Ok(())543 }544545 /// Burns managed tokens.546 pub fn burn_from(547 collection: &FungibleHandle<T>,548 spender: &T::CrossAccountId,549 from: &T::CrossAccountId,550 amount: u128,551 nesting_budget: &dyn Budget,552 ) -> DispatchResult {553 let allowance = Self::check_allowed(collection, spender, from, amount, nesting_budget)?;554555 // =========556557 Self::burn(collection, from, amount)?;558 if let Some(allowance) = allowance {559 Self::set_allowance_unchecked(collection, from, spender, allowance);560 }561 Ok(())562 }563564 /// Delegated to `create_multiple_items`565 pub fn create_item(566 collection: &FungibleHandle<T>,567 sender: &T::CrossAccountId,568 data: CreateItemData<T>,569 nesting_budget: &dyn Budget,570 ) -> DispatchResult {571 Self::create_multiple_items(572 collection,573 sender,574 [(data.0, data.1)].into_iter().collect(),575 nesting_budget,576 )577 }578}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//! # Fungible Pallet18//!19//! The Fungible pallet provides functionality for dealing with fungible assets.20//!21//! - [`CreateItemData`]22//! - [`Config`]23//! - [`FungibleHandle`]24//! - [`Pallet`]25//! - [`TotalSupply`]26//! - [`Balance`]27//! - [`Allowance`]28//! - [`Error`]29//!30//! ## Fungible tokens31//!32//! Fungible tokens or assets are divisible and non-unique. For instance,33//! fiat currencies like the dollar are fungible: A $1 bill34//! in New York City has the same value as a $1 bill in Miami.35//! A fungible token can also be a cryptocurrency like Bitcoin: 1 BTC is worth 1 BTC,36//! no matter where it is issued. Thus, the fungibility refers to a specific currency’s37//! ability to maintain one standard value. As well, it needs to have uniform acceptance.38//! This means that a currency’s history should not be able to affect its value,39//! and this is due to the fact that each piece that is a part of the currency is equal40//! in value when compared to every other piece of that exact same currency.41//! In the world of cryptocurrencies, this is essentially a coin or a token42//! that can be replaced by another identical coin or token, and they are43//! both mutually interchangeable. A popular implementation of fungible tokens is44//! the ERC-20 token standard.45//!46//! ### ERC-2047//!48//! 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,49//! is a Token Standard that implements an API for tokens within Smart Contracts.50//!51//! Example functionalities ERC-20 provides:52//!53//! * transfer tokens from one account to another54//! * get the current token balance of an account55//! * get the total supply of the token available on the network56//! * approve whether an amount of token from an account can be spent by a third-party account57//!58//! ## Overview59//!60//! The module provides functionality for asset management of fungible asset, supports ERC-20 standart, includes:61//!62//! * Asset Issuance63//! * Asset Transferal64//! * Asset Destruction65//! * Delegated Asset Transfers66//!67//! **NOTE:** The created fungible asset always has `token_id` = 0.68//! So `tokenA` and `tokenB` will have different `collection_id`.69//!70//! ### Implementations71//!72//! The Fungible pallet provides implementations for the following traits.73//!74//! - [`WithRecorder`](pallet_evm_coder_substrate::WithRecorder):75//! - [`CommonCollectionOperations`](pallet_common::CommonCollectionOperations): Functions for dealing with collections76//! - [`CommonWeightInfo`](pallet_common::CommonWeightInfo): Functions for retrieval of transaction weight77//! - [`CommonEvmHandler`](pallet_common::erc::CommonEvmHandler): Function for handling EVM runtime calls7879#![cfg_attr(not(feature = "std"), no_std)]8081use core::ops::Deref;82use evm_coder::ToLog;83use frame_support::{ensure};84use pallet_evm::account::CrossAccountId;85use up_data_structs::{86 AccessMode, CollectionId, TokenId, CreateCollectionData, mapping::TokenAddressMapping,87 budget::Budget,88};89use pallet_common::{90 Error as CommonError, Event as CommonEvent, Pallet as PalletCommon,91 eth::collection_id_to_address,92};93use pallet_evm::Pallet as PalletEvm;94use pallet_structure::Pallet as PalletStructure;95use pallet_evm_coder_substrate::WithRecorder;96use sp_core::H160;97use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};98use sp_std::{collections::btree_map::BTreeMap};99100pub use pallet::*;101102use crate::erc::ERC20Events;103#[cfg(feature = "runtime-benchmarks")]104pub mod benchmarking;105pub mod common;106pub mod erc;107pub mod weights;108109pub type CreateItemData<T> = (<T as pallet_evm::account::Config>::CrossAccountId, u128);110pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;111112#[frame_support::pallet]113pub mod pallet {114 use frame_support::{Blake2_128, Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key};115 use up_data_structs::CollectionId;116 use super::weights::WeightInfo;117118 #[pallet::error]119 pub enum Error<T> {120 /// Not Fungible item data used to mint in Fungible collection.121 NotFungibleDataUsedToMintFungibleCollectionToken,122 /// Not default id passed as TokenId argument.123 /// The default value of TokenId for Fungible collection is 0.124 FungibleItemsHaveNoId,125 /// Tried to set data for fungible item.126 FungibleItemsDontHaveData,127 /// Fungible token does not support nesting.128 FungibleDisallowsNesting,129 /// Setting item properties is not allowed.130 SettingPropertiesNotAllowed,131 }132133 #[pallet::config]134 pub trait Config:135 frame_system::Config + pallet_common::Config + pallet_structure::Config + pallet_evm::Config136 {137 type WeightInfo: WeightInfo;138 }139140 #[pallet::pallet]141 #[pallet::generate_store(pub(super) trait Store)]142 pub struct Pallet<T>(_);143144 /// Total amount of fungible tokens inside a collection.145 #[pallet::storage]146 pub type TotalSupply<T: Config> =147 StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u128, QueryKind = ValueQuery>;148149 /// Amount of tokens owned by an account inside a collection.150 #[pallet::storage]151 pub type Balance<T: Config> = StorageNMap<152 Key = (153 Key<Twox64Concat, CollectionId>,154 Key<Blake2_128Concat, T::CrossAccountId>,155 ),156 Value = u128,157 QueryKind = ValueQuery,158 >;159160 /// Storage for delegated assets.161 #[pallet::storage]162 pub type Allowance<T: Config> = StorageNMap<163 Key = (164 Key<Twox64Concat, CollectionId>,165 Key<Blake2_128, T::CrossAccountId>,166 Key<Blake2_128Concat, T::CrossAccountId>,167 ),168 Value = u128,169 QueryKind = ValueQuery,170 >;171}172/// Handler for fungible assets.173pub struct FungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);174impl<T: Config> FungibleHandle<T> {175 /// Casts [pallet_common::CollectionHandle] into [FungibleHandle].176 pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {177 Self(inner)178 }179180 /// Casts [FungibleHandle] into [pallet_common::CollectionHandle].181 pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {182 self.0183 }184 /// Returns a mutable reference to the internal [pallet_common::CollectionHandle].185 pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {186 &mut self.0187 }188}189impl<T: Config> WithRecorder<T> for FungibleHandle<T> {190 fn recorder(&self) -> &pallet_evm_coder_substrate::SubstrateRecorder<T> {191 self.0.recorder()192 }193 fn into_recorder(self) -> pallet_evm_coder_substrate::SubstrateRecorder<T> {194 self.0.into_recorder()195 }196}197impl<T: Config> Deref for FungibleHandle<T> {198 type Target = pallet_common::CollectionHandle<T>;199200 fn deref(&self) -> &Self::Target {201 &self.0202 }203}204205/// Pallet implementation for fungible assets206impl<T: Config> Pallet<T> {207 /// Initializes the collection. Returns [CollectionId] on success, [DispatchError] otherwise.208 pub fn init_collection(209 owner: T::CrossAccountId,210 data: CreateCollectionData<T::AccountId>,211 ) -> Result<CollectionId, DispatchError> {212 <PalletCommon<T>>::init_collection(owner, data, false)213 }214215 /// Destroys a collection.216 pub fn destroy_collection(217 collection: FungibleHandle<T>,218 sender: &T::CrossAccountId,219 ) -> DispatchResult {220 let id = collection.id;221222 if Self::collection_has_tokens(id) {223 return Err(<CommonError<T>>::CantDestroyNotEmptyCollection.into());224 }225226 // =========227228 PalletCommon::destroy_collection(collection.0, sender)?;229230 <TotalSupply<T>>::remove(id);231 <Balance<T>>::remove_prefix((id,), None);232 <Allowance<T>>::remove_prefix((id,), None);233 Ok(())234 }235236 ///Checks if collection has tokens. Return `true` if it has.237 fn collection_has_tokens(collection_id: CollectionId) -> bool {238 <TotalSupply<T>>::get(collection_id) != 0239 }240241 /// Burns the specified amount of the token. If the token balance242 /// or total supply is less than the given value,243 /// it will return [DispatchError].244 pub fn burn(245 collection: &FungibleHandle<T>,246 owner: &T::CrossAccountId,247 amount: u128,248 ) -> DispatchResult {249 let total_supply = <TotalSupply<T>>::get(collection.id)250 .checked_sub(amount)251 .ok_or(<CommonError<T>>::TokenValueTooLow)?;252253 let balance = <Balance<T>>::get((collection.id, owner))254 .checked_sub(amount)255 .ok_or(<CommonError<T>>::TokenValueTooLow)?;256257 if collection.permissions.access() == AccessMode::AllowList {258 collection.check_allowlist(owner)?;259 }260261 // =========262263 if balance == 0 {264 <Balance<T>>::remove((collection.id, owner));265 <PalletStructure<T>>::unnest_if_nested(owner, collection.id, TokenId::default());266 } else {267 <Balance<T>>::insert((collection.id, owner), balance);268 }269 <TotalSupply<T>>::insert(collection.id, total_supply);270271 <PalletEvm<T>>::deposit_log(272 ERC20Events::Transfer {273 from: *owner.as_eth(),274 to: H160::default(),275 value: amount.into(),276 }277 .to_log(collection_id_to_address(collection.id)),278 );279 <PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(280 collection.id,281 TokenId::default(),282 owner.clone(),283 amount,284 ));285 Ok(())286 }287288 /// Transfers the specified amount of tokens. Will check that289 /// the transfer is allowed for the token.290 pub fn transfer(291 collection: &FungibleHandle<T>,292 from: &T::CrossAccountId,293 to: &T::CrossAccountId,294 amount: u128,295 nesting_budget: &dyn Budget,296 ) -> DispatchResult {297 ensure!(298 collection.limits.transfers_enabled(),299 <CommonError<T>>::TransferNotAllowed,300 );301302 if collection.permissions.access() == AccessMode::AllowList {303 collection.check_allowlist(from)?;304 collection.check_allowlist(to)?;305 }306 <PalletCommon<T>>::ensure_correct_receiver(to)?;307308 let balance_from = <Balance<T>>::get((collection.id, from))309 .checked_sub(amount)310 .ok_or(<CommonError<T>>::TokenValueTooLow)?;311 let balance_to = if from != to {312 Some(313 <Balance<T>>::get((collection.id, to))314 .checked_add(amount)315 .ok_or(ArithmeticError::Overflow)?,316 )317 } else {318 None319 };320321 // =========322323 <PalletStructure<T>>::nest_if_sent_to_token(324 from.clone(),325 to,326 collection.id,327 TokenId::default(),328 nesting_budget,329 )?;330331 if let Some(balance_to) = balance_to {332 // from != to333 if balance_from == 0 {334 <Balance<T>>::remove((collection.id, from));335 <PalletStructure<T>>::unnest_if_nested(from, collection.id, TokenId::default());336 } else {337 <Balance<T>>::insert((collection.id, from), balance_from);338 }339 <Balance<T>>::insert((collection.id, to), balance_to);340 }341342 <PalletEvm<T>>::deposit_log(343 ERC20Events::Transfer {344 from: *from.as_eth(),345 to: *to.as_eth(),346 value: amount.into(),347 }348 .to_log(collection_id_to_address(collection.id)),349 );350 <PalletCommon<T>>::deposit_event(CommonEvent::Transfer(351 collection.id,352 TokenId::default(),353 from.clone(),354 to.clone(),355 amount,356 ));357 Ok(())358 }359360 /// Minting tokens for multiple IDs.361 pub fn create_multiple_items(362 collection: &FungibleHandle<T>,363 sender: &T::CrossAccountId,364 data: BTreeMap<T::CrossAccountId, u128>,365 nesting_budget: &dyn Budget,366 ) -> DispatchResult {367 if !collection.is_owner_or_admin(sender) {368 ensure!(369 collection.permissions.mint_mode(),370 <CommonError<T>>::PublicMintingNotAllowed371 );372 collection.check_allowlist(sender)?;373374 for (owner, _) in data.iter() {375 collection.check_allowlist(owner)?;376 }377 }378379 let total_supply = data380 .iter()381 .map(|(_, v)| *v)382 .try_fold(<TotalSupply<T>>::get(collection.id), |acc, v| {383 acc.checked_add(v)384 })385 .ok_or(ArithmeticError::Overflow)?;386387 let mut balances = data;388 for (k, v) in balances.iter_mut() {389 *v = <Balance<T>>::get((collection.id, &k))390 .checked_add(*v)391 .ok_or(ArithmeticError::Overflow)?;392 }393394 for (to, _) in balances.iter() {395 <PalletStructure<T>>::check_nesting(396 sender.clone(),397 to,398 collection.id,399 TokenId::default(),400 nesting_budget,401 )?;402 }403404 // =========405406 <TotalSupply<T>>::insert(collection.id, total_supply);407 for (user, amount) in balances {408 <Balance<T>>::insert((collection.id, &user), amount);409 <PalletStructure<T>>::nest_if_sent_to_token_unchecked(410 &user,411 collection.id,412 TokenId::default(),413 );414 <PalletEvm<T>>::deposit_log(415 ERC20Events::Transfer {416 from: H160::default(),417 to: *user.as_eth(),418 value: amount.into(),419 }420 .to_log(collection_id_to_address(collection.id)),421 );422 <PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(423 collection.id,424 TokenId::default(),425 user.clone(),426 amount,427 ));428 }429430 Ok(())431 }432433 fn set_allowance_unchecked(434 collection: &FungibleHandle<T>,435 owner: &T::CrossAccountId,436 spender: &T::CrossAccountId,437 amount: u128,438 ) {439 if amount == 0 {440 <Allowance<T>>::remove((collection.id, owner, spender));441 } else {442 <Allowance<T>>::insert((collection.id, owner, spender), amount);443 }444445 <PalletEvm<T>>::deposit_log(446 ERC20Events::Approval {447 owner: *owner.as_eth(),448 spender: *spender.as_eth(),449 value: amount.into(),450 }451 .to_log(collection_id_to_address(collection.id)),452 );453 <PalletCommon<T>>::deposit_event(CommonEvent::Approved(454 collection.id,455 TokenId(0),456 owner.clone(),457 spender.clone(),458 amount,459 ));460 }461462 /// Sets the amount of owner tokens that the spender can manage.463 pub fn set_allowance(464 collection: &FungibleHandle<T>,465 owner: &T::CrossAccountId,466 spender: &T::CrossAccountId,467 amount: u128,468 ) -> DispatchResult {469 if collection.permissions.access() == AccessMode::AllowList {470 collection.check_allowlist(owner)?;471 collection.check_allowlist(spender)?;472 }473474 if <Balance<T>>::get((collection.id, owner)) < amount {475 ensure!(476 collection.ignores_owned_amount(owner),477 <CommonError<T>>::CantApproveMoreThanOwned478 );479 }480481 // =========482483 Self::set_allowance_unchecked(collection, owner, spender, amount);484 Ok(())485 }486487 fn check_allowed(488 collection: &FungibleHandle<T>,489 spender: &T::CrossAccountId,490 from: &T::CrossAccountId,491 amount: u128,492 nesting_budget: &dyn Budget,493 ) -> Result<Option<u128>, DispatchError> {494 if spender.conv_eq(from) {495 return Ok(None);496 }497 if collection.permissions.access() == AccessMode::AllowList {498 // `from`, `to` checked in [`transfer`]499 collection.check_allowlist(spender)?;500 }501 if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {502 // TODO: should collection owner be allowed to perform this transfer?503 ensure!(504 <PalletStructure<T>>::check_indirectly_owned(505 spender.clone(),506 source.0,507 source.1,508 None,509 nesting_budget510 )?,511 <CommonError<T>>::ApprovedValueTooLow,512 );513 return Ok(None);514 }515 let allowance = <Allowance<T>>::get((collection.id, from, spender)).checked_sub(amount);516 if allowance.is_none() {517 ensure!(518 collection.ignores_allowance(spender),519 <CommonError<T>>::ApprovedValueTooLow520 );521 }522523 Ok(allowance)524 }525526 /// Transfers of tokens that `from` gave to `spender` to manage, to `to` ID.527 pub fn transfer_from(528 collection: &FungibleHandle<T>,529 spender: &T::CrossAccountId,530 from: &T::CrossAccountId,531 to: &T::CrossAccountId,532 amount: u128,533 nesting_budget: &dyn Budget,534 ) -> DispatchResult {535 let allowance = Self::check_allowed(collection, spender, from, amount, nesting_budget)?;536537 // =========538539 Self::transfer(collection, from, to, amount, nesting_budget)?;540 if let Some(allowance) = allowance {541 Self::set_allowance_unchecked(collection, from, spender, allowance);542 }543 Ok(())544 }545546 /// Burns managed tokens.547 pub fn burn_from(548 collection: &FungibleHandle<T>,549 spender: &T::CrossAccountId,550 from: &T::CrossAccountId,551 amount: u128,552 nesting_budget: &dyn Budget,553 ) -> DispatchResult {554 let allowance = Self::check_allowed(collection, spender, from, amount, nesting_budget)?;555556 // =========557558 Self::burn(collection, from, amount)?;559 if let Some(allowance) = allowance {560 Self::set_allowance_unchecked(collection, from, spender, allowance);561 }562 Ok(())563 }564565 /// Delegated to `create_multiple_items`566 pub fn create_item(567 collection: &FungibleHandle<T>,568 sender: &T::CrossAccountId,569 data: CreateItemData<T>,570 nesting_budget: &dyn Budget,571 ) -> DispatchResult {572 Self::create_multiple_items(573 collection,574 sender,575 [(data.0, data.1)].into_iter().collect(),576 nesting_budget,577 )578 }579}