1#![cfg_attr(not(feature = "std"), no_std)]23use core::ops::Deref;4use frame_support::{ensure};5use nft_data_structs::{AccessMode, Collection, CollectionId, TokenId};6use pallet_common::{7 Error as CommonError, Event as CommonEvent, Pallet as PalletCommon, account::CrossAccountId,8};9use sp_core::H160;10use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};11use sp_std::{vec::Vec, vec, collections::btree_map::BTreeMap};1213pub use pallet::*;1415use crate::erc::ERC20Events;16pub mod benchmarking;17pub mod common;18pub mod erc;19pub mod weights;2021pub type CreateItemData<T> = (<T as pallet_common::Config>::CrossAccountId, u128);22pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;2324#[frame_support::pallet]25pub mod pallet {26 use frame_support::{Blake2_128, Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key};27 use nft_data_structs::CollectionId;28 use super::weights::WeightInfo;2930 #[pallet::error]31 pub enum Error<T> {32 33 NotFungibleDataUsedToMintFungibleCollectionToken,34 35 FungibleItemsHaveNoId,36 37 FungibleItemsHaveData,38 }3940 #[pallet::config]41 pub trait Config: frame_system::Config + pallet_common::Config {42 type WeightInfo: WeightInfo;43 }4445 #[pallet::pallet]46 #[pallet::generate_store(pub(super) trait Store)]47 pub struct Pallet<T>(_);4849 #[pallet::storage]50 pub(super) type TotalSupply<T: Config> =51 StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u128, QueryKind = ValueQuery>;5253 #[pallet::storage]54 pub(super) type Balance<T: Config> = StorageNMap<55 Key = (56 Key<Twox64Concat, CollectionId>,57 Key<Blake2_128Concat, T::AccountId>,58 ),59 Value = u128,60 QueryKind = ValueQuery,61 >;6263 #[pallet::storage]64 pub(super) type Allowance<T: Config> = StorageNMap<65 Key = (66 Key<Twox64Concat, CollectionId>,67 Key<Blake2_128, T::AccountId>,68 Key<Blake2_128Concat, T::AccountId>,69 ),70 Value = u128,71 QueryKind = ValueQuery,72 >;73}7475pub struct FungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);76impl<T: Config> FungibleHandle<T> {77 pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {78 Self(inner)79 }80 pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {81 self.082 }83}84impl<T: Config> Deref for FungibleHandle<T> {85 type Target = pallet_common::CollectionHandle<T>;8687 fn deref(&self) -> &Self::Target {88 &self.089 }90}9192impl<T: Config> Pallet<T> {93 pub fn init_collection(data: Collection<T>) -> Result<CollectionId, DispatchError> {94 PalletCommon::init_collection(data)95 }96 pub fn destroy_collection(97 collection: FungibleHandle<T>,98 sender: &T::CrossAccountId,99 ) -> DispatchResult {100 let id = collection.id;101102 103104 PalletCommon::destroy_collection(collection.0, sender)?;105106 <TotalSupply<T>>::remove(id);107 <Balance<T>>::remove_prefix((id,), None);108 <Allowance<T>>::remove_prefix((id,), None);109 Ok(())110 }111112 pub fn burn(113 collection: &FungibleHandle<T>,114 owner: &T::CrossAccountId,115 amount: u128,116 ) -> DispatchResult {117 let total_supply = <TotalSupply<T>>::get(collection.id)118 .checked_sub(amount)119 .ok_or(<CommonError<T>>::TokenValueTooLow)?;120121 let balance = <Balance<T>>::get((collection.id, owner.as_sub()))122 .checked_sub(amount)123 .ok_or(<CommonError<T>>::TokenValueTooLow)?;124125 if collection.access == AccessMode::WhiteList {126 collection.check_whitelist(owner)?;127 }128129 130131 if balance == 0 {132 <Balance<T>>::remove((collection.id, owner.as_sub()));133 } else {134 <Balance<T>>::insert((collection.id, owner.as_sub()), balance);135 }136 <TotalSupply<T>>::insert(collection.id, total_supply);137138 collection.log_infallible(ERC20Events::Transfer {139 from: *owner.as_eth(),140 to: H160::default(),141 value: amount.into(),142 });143 <PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(144 collection.id,145 TokenId::default(),146 owner.clone(),147 amount,148 ));149 Ok(())150 }151152 pub fn transfer(153 collection: &FungibleHandle<T>,154 from: &T::CrossAccountId,155 to: &T::CrossAccountId,156 amount: u128,157 ) -> DispatchResult {158 ensure!(159 collection.transfers_enabled,160 <CommonError<T>>::TransferNotAllowed161 );162163 if collection.access == AccessMode::WhiteList {164 collection.check_whitelist(from)?;165 collection.check_whitelist(to)?;166 }167 <PalletCommon<T>>::ensure_correct_receiver(to)?;168169 let balance_from = <Balance<T>>::get((collection.id, from.as_sub()))170 .checked_sub(amount)171 .ok_or(<CommonError<T>>::TokenValueTooLow)?;172 let balance_to = if from != to {173 Some(174 <Balance<T>>::get((collection.id, to.as_sub()))175 .checked_add(amount)176 .ok_or(ArithmeticError::Overflow)?,177 )178 } else {179 None180 };181182 collection.consume_sstore()?;183 collection.consume_sstore()?;184 collection.consume_log(2, 32)?;185 collection.consume_sstore()?;186187 188189 if let Some(balance_to) = balance_to {190 191 if balance_from == 0 {192 <Balance<T>>::remove((collection.id, from.as_sub()));193 } else {194 <Balance<T>>::insert((collection.id, from.as_sub()), balance_from);195 }196 <Balance<T>>::insert((collection.id, to.as_sub()), balance_to);197 }198199 collection.log_infallible(ERC20Events::Transfer {200 from: *from.as_eth(),201 to: *to.as_eth(),202 value: amount.into(),203 });204 <PalletCommon<T>>::deposit_event(CommonEvent::Transfer(205 collection.id,206 TokenId::default(),207 from.clone(),208 to.clone(),209 amount,210 ));211 Ok(())212 }213214 pub fn create_multiple_items(215 collection: &FungibleHandle<T>,216 sender: &T::CrossAccountId,217 data: Vec<CreateItemData<T>>,218 ) -> DispatchResult {219 let unrestricted_minting = collection.is_owner_or_admin(sender)?;220 if !unrestricted_minting {221 ensure!(222 collection.mint_mode,223 <CommonError<T>>::PublicMintingNotAllowed224 );225 collection.check_whitelist(sender)?;226227 for (owner, _) in data.iter() {228 collection.check_whitelist(owner)?;229 }230 }231232 let mut balances = BTreeMap::new();233234 let total_supply = data235 .iter()236 .map(|u| u.1)237 .try_fold(0u128, |acc, v| acc.checked_add(v))238 .ok_or(ArithmeticError::Overflow)?;239240 for (user, amount) in data.into_iter() {241 collection.consume_sload()?;242 let balance = balances243 .entry(user.clone())244 .or_insert_with(|| <Balance<T>>::get((collection.id, user.as_sub())));245 *balance = (*balance)246 .checked_add(amount)247 .ok_or(ArithmeticError::Overflow)?;248 }249250 collection.consume_sstore()?;251 for _ in &balances {252 collection.consume_sstore()?;253 collection.consume_log(2, 32)?;254 collection.consume_sstore()?;255 }256257 258259 <TotalSupply<T>>::insert(collection.id, total_supply);260 for (user, amount) in balances {261 <Balance<T>>::insert((collection.id, user.as_sub()), amount);262263 collection.log_infallible(ERC20Events::Transfer {264 from: H160::default(),265 to: *user.as_eth(),266 value: amount.into(),267 });268 <PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(269 collection.id,270 TokenId::default(),271 user.clone(),272 amount,273 ));274 }275276 Ok(())277 }278279 fn set_allowance_unchecked(280 collection: &FungibleHandle<T>,281 owner: &T::CrossAccountId,282 spender: &T::CrossAccountId,283 amount: u128,284 ) {285 <Allowance<T>>::insert((collection.id, owner.as_sub(), spender.as_sub()), amount);286287 collection.log_infallible(ERC20Events::Approval {288 owner: *owner.as_eth(),289 spender: *spender.as_eth(),290 value: amount.into(),291 });292 <PalletCommon<T>>::deposit_event(CommonEvent::Approved(293 collection.id,294 TokenId(0),295 owner.clone(),296 spender.clone(),297 amount,298 ));299 }300301 pub fn set_allowance(302 collection: &FungibleHandle<T>,303 owner: &T::CrossAccountId,304 spender: &T::CrossAccountId,305 amount: u128,306 ) -> DispatchResult {307 if collection.access == AccessMode::WhiteList {308 collection.check_whitelist(&owner)?;309 collection.check_whitelist(&spender)?;310 }311312 if <Balance<T>>::get((collection.id, owner.as_sub())) < amount {313 ensure!(314 collection.ignores_owned_amount(owner)?,315 <CommonError<T>>::CantApproveMoreThanOwned316 );317 }318319 320321 Self::set_allowance_unchecked(collection, owner, spender, amount);322 Ok(())323 }324325 pub fn transfer_from(326 collection: &FungibleHandle<T>,327 spender: &T::CrossAccountId,328 from: &T::CrossAccountId,329 to: &T::CrossAccountId,330 amount: u128,331 ) -> DispatchResult {332 if spender == from {333 return Self::transfer(collection, from, to, amount);334 }335 if collection.access == AccessMode::WhiteList {336 337 collection.check_whitelist(spender)?;338 }339340 let allowance = <Allowance<T>>::get((collection.id, from.as_sub(), spender.as_sub()))341 .checked_sub(amount);342 if allowance.is_none() {343 ensure!(344 collection.ignores_allowance(spender)?,345 <CommonError<T>>::TokenValueNotEnough346 );347 }348349 350351 Self::transfer(collection, from, to, amount)?;352 if let Some(allowance) = allowance {353 Self::set_allowance_unchecked(collection, from, spender, allowance);354 }355 Ok(())356 }357358 359 pub fn create_item(360 collection: &FungibleHandle<T>,361 sender: &T::CrossAccountId,362 data: CreateItemData<T>,363 ) -> DispatchResult {364 Self::create_multiple_items(collection, sender, vec![data])365 }366}