git.delta.rocks / unique-network / refs/commits / d15bc44d3ad9

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::{pallet_prelude::*, transactional, BoundedVec, dispatch::DispatchResult};20use frame_system::{pallet_prelude::*, ensure_signed};21use sp_runtime::{DispatchError, Permill, traits::StaticLookup};22use sp_std::vec::Vec;23use up_data_structs::*;24use pallet_common::{Pallet as PalletCommon, Error as CommonError, CollectionHandle, CommonCollectionOperations};25use pallet_nonfungible::{Pallet as PalletNft, NonfungibleHandle};26use pallet_evm::account::CrossAccountId;2728pub use pallet::*;2930pub mod misc;31pub mod property;3233use misc::*;34pub use property::*;3536#[frame_support::pallet]37pub mod pallet {38    use super::*;39    use pallet_evm::account;4041	#[pallet::config]42	pub trait Config: frame_system::Config43                    + pallet_common::Config44                    + pallet_nonfungible::Config45                    + account::Config {46		type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;47	}4849	#[pallet::pallet]50	#[pallet::generate_store(pub(super) trait Store)]51	pub struct Pallet<T>(_);5253	#[pallet::event]54	#[pallet::generate_deposit(pub(super) fn deposit_event)]55	pub enum Event<T: Config> {56        CollectionCreated {57			issuer: T::AccountId,58			collection_id: RmrkCollectionId,59		},60        CollectionDestroyed {61			issuer: T::AccountId,62			collection_id: RmrkCollectionId,63		},64        IssuerChanged {65			old_issuer: T::AccountId,66			new_issuer: T::AccountId,67			collection_id: RmrkCollectionId,68		},69        CollectionLocked {70			issuer: T::AccountId,71			collection_id: RmrkCollectionId,72		},73        NftMinted {74			owner: T::AccountId,75			collection_id: RmrkCollectionId,76			nft_id: RmrkNftId,77		},78	}7980	#[pallet::error]81	pub enum Error<T> {82        /* Unique-specific events */83        CorruptedCollectionType,84        NftTypeEncodeError,85        RmrkPropertyKeyIsTooLong,86        RmrkPropertyValueIsTooLong,8788        /* RMRK compatible events */89        CollectionNotEmpty,90        NoAvailableCollectionId,91        NoAvailableNftId,92        CollectionUnknown,93        NoPermission,94        CollectionFullOrLocked,95	}9697	#[pallet::call]98	impl<T: Config> Pallet<T> {99        #[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]100		#[transactional]101		pub fn create_collection(102			origin: OriginFor<T>,103			metadata: RmrkString,104			max: Option<u32>,105			symbol: RmrkCollectionSymbol,106		) -> DispatchResult {107            let sender = ensure_signed(origin)?;108109            let limits = max.map(|max| CollectionLimits {110                token_limit: Some(max),111                ..Default::default()112            });113114            let data = CreateCollectionData {115                limits,116                token_prefix: symbol.into_inner()117                    .try_into()118                    .map_err(|_| <CommonError<T>>::CollectionTokenPrefixLimitExceeded)?,119                ..Default::default()120            };121122            let collection_id_res = <PalletNft<T>>::init_collection(sender.clone(), data);123124            if let Err(DispatchError::Arithmetic(_)) = &collection_id_res {125                return Err(<Error<T>>::NoAvailableCollectionId.into());126            }127128            let collection_id = collection_id_res?;129130            let collection = Self::get_nft_collection(collection_id)?.into_inner();131132            <PalletCommon<T>>::set_scoped_collection_properties(133                &collection,134                PropertyScope::Rmrk,135                [136                    rmrk_property!(Config=T, Metadata: metadata)?,137                    rmrk_property!(Config=T, CollectionType: CollectionType::Regular)?,138                ].into_iter()139            )?;140141            Self::deposit_event(Event::CollectionCreated {142                issuer: sender,143                collection_id: collection_id.0144            });145146            Ok(())147        }148149        #[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]150		#[transactional]151		pub fn destroy_collection(152			origin: OriginFor<T>,153			collection_id: RmrkCollectionId,154		) -> DispatchResult {155            let sender = ensure_signed(origin)?;156            let cross_sender = T::CrossAccountId::from_sub(sender.clone());157158            let unique_collection_id = collection_id.into();159160            let collection = Self::get_typed_nft_collection(unique_collection_id, CollectionType::Regular)?;161162            ensure!(collection.total_supply() == 0, <Error<T>>::CollectionNotEmpty);163164            <PalletNft<T>>::destroy_collection(collection, &cross_sender)?;165166            Self::deposit_event(Event::CollectionDestroyed { issuer: sender, collection_id });167168            Ok(())169        }170171        #[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]172		#[transactional]173		pub fn change_collection_issuer(174			origin: OriginFor<T>,175			collection_id: RmrkCollectionId,176			new_issuer: <T::Lookup as StaticLookup>::Source,177		) -> DispatchResult {178            let sender = ensure_signed(origin)?;179180            let new_issuer = T::Lookup::lookup(new_issuer)?;181182            Self::change_collection_owner(183                collection_id.into(),184                CollectionType::Regular,185                sender.clone(),186                new_issuer.clone()187            )?;188189            Self::deposit_event(Event::IssuerChanged {190				old_issuer: sender,191				new_issuer,192				collection_id,193			});194195            Ok(())196        }197198        #[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]199		#[transactional]200		pub fn lock_collection(201			origin: OriginFor<T>,202			collection_id: RmrkCollectionId,203		) -> DispatchResult {204            let sender = ensure_signed(origin)?;205            let cross_sender = T::CrossAccountId::from_sub(sender.clone());206207            let collection = Self::get_typed_nft_collection(208                collection_id.into(),209                CollectionType::Regular210            )?;211            collection.check_is_owner(&cross_sender)?;212213            let token_count = collection.total_supply();214215            let mut collection = collection.into_inner();216            collection.limits.token_limit = Some(token_count);217            collection.save()?;218219			Self::deposit_event(Event::CollectionLocked { issuer: sender, collection_id });220221            Ok(())222        }223224        #[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]225		#[transactional]226		pub fn mint_nft(227			origin: OriginFor<T>,228			owner: T::AccountId,229			collection_id: RmrkCollectionId,230			recipient: Option<T::AccountId>,231			royalty_amount: Option<Permill>,232			metadata: RmrkString,233		) -> DispatchResult {234            let sender = ensure_signed(origin)?;235            let sender = T::CrossAccountId::from_sub(sender);236            let cross_owner = T::CrossAccountId::from_sub(owner.clone());237238            let royalty_info = royalty_amount.map(|amount| rmrk::RoyaltyInfo {239                recipient: recipient.unwrap_or_else(|| owner.clone()),240                amount241            });242243            let nft_id = Self::create_nft(244                sender,245                cross_owner,246                collection_id.into(),247                CollectionType::Regular,248                NftType::Regular,249                [250                    rmrk_property!(Config=T, RoyaltyInfo: royalty_info)?,251                    rmrk_property!(Config=T, Metadata: metadata)?,252                    rmrk_property!(Config=T, Equipped: false)?,253                    rmrk_property!(Config=T, ResourceCollection: None::<CollectionId>)?,254                    rmrk_property!(Config=T, ResourcePriorities: <Vec<u8>>::new())?,255                ].into_iter()256            )?;257258            Self::deposit_event(Event::NftMinted {259                owner,260                collection_id,261                nft_id: nft_id.0262            });263264            Ok(())265        }266	}267}268269impl<T: Config> Pallet<T> {270    fn create_nft(271        sender: T::CrossAccountId,272        owner: T::CrossAccountId,273        collection_id: CollectionId,274        collection_type: CollectionType,275        nft_type: NftType,276        properties: impl Iterator<Item=Property>277    ) -> Result<TokenId, DispatchError> {278        let collection = Self::get_typed_nft_collection(279            collection_id,280            collection_type281        )?;282283        let data = CreateNftExData {284            const_data: nft_type.encode()285                .try_into()286                .map_err(|_| <Error<T>>::NftTypeEncodeError)?,287            properties: BoundedVec::default(),288            owner,289        };290291        let budget = budget::Value::new(2);292293        <PalletNft<T>>::create_item(294            &collection,295            &sender,296            data,297            &budget,298        ).map_err(|err| {299            map_common_err_to_proxy!(300                match err {301                    NoPermission => NoPermission,302                    CollectionTokenLimitExceeded => CollectionFullOrLocked303                }304            )305        })?;306307        let nft_id = <PalletNft<T>>::current_token_id(&collection);308309        <PalletNft<T>>::set_scoped_token_properties(310            &collection,311            nft_id,312            PropertyScope::Rmrk,313            properties314        )?;315316        Ok(nft_id)317    }318319    fn change_collection_owner(320        collection_id: CollectionId,321        collection_type: CollectionType,322        sender: T::AccountId,323        new_owner: T::AccountId,324    ) -> DispatchResult {325        let mut collection = Self::get_typed_nft_collection(326            collection_id,327            collection_type328        )?.into_inner();329        collection.check_is_owner(&T::CrossAccountId::from_sub(sender))?;330331        collection.owner = new_owner;332        collection.save()333    }334335    pub fn get_nft_collection(collection_id: CollectionId) -> Result<NonfungibleHandle<T>, DispatchError> {336        let collection = <CollectionHandle<T>>::try_get(collection_id)337            .map_err(|_| <Error<T>>::CollectionUnknown)?338            .into_nft_collection()?;339340        Ok(collection)341    }342343    pub fn get_collection_property(collection_id: CollectionId, key: RmrkProperty) -> Result<PropertyValue, DispatchError> {344        let collection_property = <PalletCommon<T>>::collection_properties(collection_id)345            .get(&rmrk_property!(Config=T, key)?)346            .ok_or(<Error<T>>::CollectionUnknown)?347            .clone();348349        Ok(collection_property)350    }351352    pub fn get_collection_type(collection_id: CollectionId) -> Result<CollectionType, DispatchError> {353        let value = Self::get_collection_property(collection_id, RmrkProperty::CollectionType)?;354        let collection_type: CollectionType = (&value)355            .try_into()356            .map_err(<Error<T>>::from)?;357358        Ok(collection_type)359    }360361    pub fn get_nft_property(collection_id: CollectionId, nft_id: TokenId, key: RmrkProperty) -> Result<PropertyValue, DispatchError> {362        let nft_property = <PalletNft<T>>::token_properties((collection_id, nft_id))363            .get(&rmrk_property!(Config=T, key)?)364            .ok_or(<Error<T>>::NoAvailableNftId)?365            .clone();366367        Ok(nft_property)368    }369370    pub fn check_collection_type(collection_id: CollectionId, collection_type: CollectionType) -> DispatchResult {371        let actual_type = Self::get_collection_type(collection_id)?;372        ensure!(actual_type == collection_type, <CommonError<T>>::NoPermission);373374        Ok(())375    }376377    fn get_typed_nft_collection(378        collection_id: CollectionId,379        collection_type: CollectionType380    ) -> Result<NonfungibleHandle<T>, DispatchError> {381        Self::check_collection_type(collection_id, collection_type)?;382383        Self::get_nft_collection(collection_id)384    }385}