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

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, TokenData};26use pallet_evm::account::CrossAccountId;2728pub use pallet::*;2930pub mod misc;31pub mod property;3233use misc::*;34pub use property::*;3536use RmrkProperty::*;3738#[frame_support::pallet]39pub mod pallet {40    use super::*;41    use pallet_evm::account;4243	#[pallet::config]44	pub trait Config: frame_system::Config45                    + pallet_common::Config46                    + pallet_nonfungible::Config47                    + account::Config {48		type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;49	}5051    #[pallet::storage]52	#[pallet::getter(fn collection_index)]53	pub type CollectionIndex<T: Config> = StorageValue<_, RmrkCollectionId, ValueQuery>;5455	#[pallet::pallet]56	#[pallet::generate_store(pub(super) trait Store)]57	pub struct Pallet<T>(_);5859	#[pallet::event]60	#[pallet::generate_deposit(pub(super) fn deposit_event)]61	pub enum Event<T: Config> {62        CollectionCreated {63			issuer: T::AccountId,64			collection_id: RmrkCollectionId,65		},66        CollectionDestroyed {67			issuer: T::AccountId,68			collection_id: RmrkCollectionId,69		},70        IssuerChanged {71			old_issuer: T::AccountId,72			new_issuer: T::AccountId,73			collection_id: RmrkCollectionId,74		},75        CollectionLocked {76			issuer: T::AccountId,77			collection_id: RmrkCollectionId,78		},79        NftMinted {80			owner: T::AccountId,81			collection_id: RmrkCollectionId,82			nft_id: RmrkNftId,83		},84        NFTBurned {85			owner: T::AccountId,86			nft_id: RmrkNftId,87		},88	}8990	#[pallet::error]91	pub enum Error<T> {92        /* Unique-specific events */93        CorruptedCollectionType,94        NftTypeEncodeError,95        RmrkPropertyKeyIsTooLong,96        RmrkPropertyValueIsTooLong,9798        /* RMRK compatible events */99        CollectionNotEmpty,100        NoAvailableCollectionId,101        NoAvailableNftId,102        CollectionUnknown,103        NoPermission,104        CollectionFullOrLocked,105	}106107	#[pallet::call]108	impl<T: Config> Pallet<T> {109        #[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]110		#[transactional]111		pub fn create_collection(112			origin: OriginFor<T>,113			metadata: RmrkString,114			max: Option<u32>,115			symbol: RmrkCollectionSymbol,116		) -> DispatchResult {117            let sender = ensure_signed(origin)?;118119            let limits = CollectionLimits {120                owner_can_transfer: Some(false),121                token_limit: max,122                ..Default::default()123            };124125            let data = CreateCollectionData {126                limits: Some(limits),127                token_prefix: symbol.into_inner()128                    .try_into()129                    .map_err(|_| <CommonError<T>>::CollectionTokenPrefixLimitExceeded)?,130                ..Default::default()131            };132133            let collection_id_res = <PalletNft<T>>::init_collection(sender.clone(), data);134135            if let Err(DispatchError::Arithmetic(_)) = &collection_id_res {136                return Err(<Error<T>>::NoAvailableCollectionId.into());137            }138139            let collection_id = collection_id_res?;140141            <PalletCommon<T>>::set_scoped_collection_properties(142                collection_id,143                PropertyScope::Rmrk,144                [145                    Self::rmrk_property(Metadata, &metadata)?,146                    Self::rmrk_property(CollectionType, &misc::CollectionType::Regular)?,147                ].into_iter()148            )?;149150            <CollectionIndex<T>>::mutate(|n| *n += 1);151152            Self::deposit_event(Event::CollectionCreated {153                issuer: sender,154                collection_id: collection_id.0155            });156157            Ok(())158        }159160        #[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]161		#[transactional]162		pub fn destroy_collection(163			origin: OriginFor<T>,164			collection_id: RmrkCollectionId,165		) -> DispatchResult {166            let sender = ensure_signed(origin)?;167            let cross_sender = T::CrossAccountId::from_sub(sender.clone());168169            let unique_collection_id = collection_id.into();170171            let collection = Self::get_typed_nft_collection(unique_collection_id, misc::CollectionType::Regular)?;172173            ensure!(collection.total_supply() == 0, <Error<T>>::CollectionNotEmpty);174175            <PalletNft<T>>::destroy_collection(collection, &cross_sender)176                .map_err(Self::map_common_err_to_proxy)?;177178            Self::deposit_event(Event::CollectionDestroyed { issuer: sender, collection_id });179180            Ok(())181        }182183        #[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]184		#[transactional]185		pub fn change_collection_issuer(186			origin: OriginFor<T>,187			collection_id: RmrkCollectionId,188			new_issuer: <T::Lookup as StaticLookup>::Source,189		) -> DispatchResult {190            let sender = ensure_signed(origin)?;191192            let new_issuer = T::Lookup::lookup(new_issuer)?;193194            Self::change_collection_owner(195                collection_id.into(),196                misc::CollectionType::Regular,197                sender.clone(),198                new_issuer.clone()199            )?;200201            Self::deposit_event(Event::IssuerChanged {202				old_issuer: sender,203				new_issuer,204				collection_id,205			});206207            Ok(())208        }209210        #[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]211		#[transactional]212		pub fn lock_collection(213			origin: OriginFor<T>,214			collection_id: RmrkCollectionId,215		) -> DispatchResult {216            let sender = ensure_signed(origin)?;217            let cross_sender = T::CrossAccountId::from_sub(sender.clone());218219            let collection = Self::get_typed_nft_collection(220                collection_id.into(),221                misc::CollectionType::Regular222            )?;223224            Self::check_collection_owner(&collection, &cross_sender)?;225226            let token_count = collection.total_supply();227228            let mut collection = collection.into_inner();229            collection.limits.token_limit = Some(token_count);230            collection.save()?;231232			Self::deposit_event(Event::CollectionLocked { issuer: sender, collection_id });233234            Ok(())235        }236237        #[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]238		#[transactional]239		pub fn mint_nft(240			origin: OriginFor<T>,241			owner: T::AccountId,242			collection_id: RmrkCollectionId,243			recipient: Option<T::AccountId>,244			royalty_amount: Option<Permill>,245			metadata: RmrkString,246		) -> DispatchResult {247            let sender = ensure_signed(origin)?;248            let sender = T::CrossAccountId::from_sub(sender);249            let cross_owner = T::CrossAccountId::from_sub(owner.clone());250251            let royalty_info = royalty_amount.map(|amount| rmrk::RoyaltyInfo {252                recipient: recipient.unwrap_or_else(|| owner.clone()),253                amount254            });255256            let collection = Self::get_typed_nft_collection(257                collection_id.into(),258                misc::CollectionType::Regular,259            )?;260261            let nft_id = Self::create_nft(262                &sender,263                &cross_owner,264                &collection,265                NftType::Regular,266                [267                    Self::rmrk_property(RoyaltyInfo, &royalty_info)?,268                    Self::rmrk_property(Metadata, &metadata)?,269                    Self::rmrk_property(Equipped, &false)?,270                    Self::rmrk_property(ResourceCollection, &None::<CollectionId>)?,271                    Self::rmrk_property(ResourcePriorities, &<Vec<u8>>::new())?,272                ].into_iter()273            ).map_err(|err| match err {274                DispatchError::Arithmetic(_) => <Error<T>>::NoAvailableNftId.into(),275                err => Self::map_common_err_to_proxy(err)276            })?;277278            Self::deposit_event(Event::NftMinted {279                owner,280                collection_id,281                nft_id: nft_id.0282            });283284            Ok(())285        }286287        #[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]288		#[transactional]289		pub fn burn_nft(290			origin: OriginFor<T>,291			collection_id: RmrkCollectionId,292			nft_id: RmrkNftId,293		) -> DispatchResult {294			let sender = ensure_signed(origin.clone())?;295            let cross_sender = T::CrossAccountId::from_sub(sender.clone());296297            Self::destroy_nft(298                cross_sender,299                collection_id.into(),300                misc::CollectionType::Regular,301                nft_id.into()302            )?;303304            Self::deposit_event(Event::NFTBurned { owner: sender, nft_id });305306            Ok(())307        }308	}309}310311impl<T: Config> Pallet<T> {312    pub fn rmrk_property_key(rmrk_key: RmrkProperty) -> Result<PropertyKey, DispatchError> {313        let key = rmrk_key.to_key::<T>()?;314315        let scoped_key = PropertyScope::Rmrk.apply(key)316            .map_err(|_| <Error<T>>::RmrkPropertyKeyIsTooLong)?;317318        Ok(scoped_key)319    }320321    pub fn rmrk_property<E: Encode>(rmrk_key: RmrkProperty, value: &E) -> Result<Property, DispatchError> {322        let key = rmrk_key.to_key::<T>()?;323324        let value = value.encode()325            .try_into()326            .map_err(|_| <Error<T>>::RmrkPropertyValueIsTooLong)?;327328        let property = Property {329            key,330            value,331        };332333        Ok(property)334    }335336    pub fn create_nft(337        sender: &T::CrossAccountId,338        owner: &T::CrossAccountId,339        collection: &NonfungibleHandle<T>,340        nft_type: NftType,341        properties: impl Iterator<Item=Property>342    ) -> Result<TokenId, DispatchError> {343        let data = CreateNftExData {344            const_data: nft_type.encode()345                .try_into()346                .map_err(|_| <Error<T>>::NftTypeEncodeError)?,347            properties: BoundedVec::default(),348            owner: owner.clone(),349        };350351        let budget = budget::Value::new(2);352353        <PalletNft<T>>::create_item(354            collection,355            sender,356            data,357            &budget,358        )?;359360        let nft_id = <PalletNft<T>>::current_token_id(collection.id);361362        <PalletNft<T>>::set_scoped_token_properties(363            collection.id,364            nft_id,365            PropertyScope::Rmrk,366            properties367        )?;368369        Ok(nft_id)370    }371372    fn destroy_nft(373        sender: T::CrossAccountId,374        collection_id: CollectionId,375        collection_type: misc::CollectionType,376        token_id: TokenId377    ) -> DispatchResult {378        let collection = Self::get_typed_nft_collection(379            collection_id,380            collection_type381        )?;382383        <PalletNft<T>>::burn(&collection, &sender, token_id)384            .map_err(Self::map_common_err_to_proxy)?;385386        Ok(())387    }388389    fn change_collection_owner(390        collection_id: CollectionId,391        collection_type: misc::CollectionType,392        sender: T::AccountId,393        new_owner: T::AccountId,394    ) -> DispatchResult {395        let collection = Self::get_typed_nft_collection(396            collection_id,397            collection_type398        )?;399        Self::check_collection_owner(&collection, &T::CrossAccountId::from_sub(sender))?;400401        let mut collection = collection.into_inner();402403        collection.owner = new_owner;404        collection.save()405    }406407    fn check_collection_owner(collection: &NonfungibleHandle<T>, account: &T::CrossAccountId) -> DispatchResult {408        collection.check_is_owner(account)409            .map_err(Self::map_common_err_to_proxy)410    }411412    pub fn last_collection_idx() -> RmrkCollectionId {413        <CollectionIndex<T>>::get()414    }415416    pub fn get_nft_collection(collection_id: CollectionId) -> Result<NonfungibleHandle<T>, DispatchError> {417        let collection = <CollectionHandle<T>>::try_get(collection_id)418            .map_err(|_| <Error<T>>::CollectionUnknown)?;419420        match collection.mode {421            CollectionMode::NFT => Ok(NonfungibleHandle::cast(collection)),422            _ => Err(<Error<T>>::CollectionUnknown.into())423        }424    }425426    // should this even be here, might displace it to common/nonfungible -- but they did not need it, only rmrk does427    pub fn collection_exists(collection_id: CollectionId) -> bool {428        <pallet_common::CollectionById<T>>::contains_key(collection_id)429    }430431    pub fn nft_exists(collection_id: CollectionId, nft_id: TokenId) -> bool {432        <TokenData<T>>::contains_key((collection_id, nft_id))433    }434435    pub fn get_collection_property(collection_id: CollectionId, key: RmrkProperty) -> Result<PropertyValue, DispatchError> {436        let collection_property = <PalletCommon<T>>::collection_properties(collection_id)437            .get(&Self::rmrk_property_key(key)?)438            .ok_or(<Error<T>>::CollectionUnknown)?439            .clone();440441        Ok(collection_property)442    }443444    pub fn get_collection_type(collection_id: CollectionId) -> Result<misc::CollectionType, DispatchError> {445        let value = Self::get_collection_property(collection_id, CollectionType)?;446447        let mut value = value.as_slice();448449        misc::CollectionType::decode(&mut value)450            .map_err(|_| <Error<T>>::CorruptedCollectionType.into())451    }452453    pub fn ensure_collection_type(collection_id: CollectionId, collection_type: misc::CollectionType) -> DispatchResult {454        let actual_type = Self::get_collection_type(collection_id)?;455        ensure!(actual_type == collection_type, <CommonError<T>>::NoPermission);456457        Ok(())458    }459460    pub fn get_nft_property(collection_id: CollectionId, nft_id: TokenId, key: RmrkProperty) -> Result<PropertyValue, DispatchError> {461        let nft_property = <PalletNft<T>>::token_properties((collection_id, nft_id))462            .get(&Self::rmrk_property_key(key)?)463            .ok_or(<Error<T>>::NoAvailableNftId)?464            .clone();465466        Ok(nft_property)467    }468469    pub fn get_nft_type(collection_id: CollectionId, token_id: TokenId) -> Result<NftType, DispatchError> {470        let token_data = <TokenData<T>>::get((collection_id, token_id))471            .ok_or(<Error<T>>::NoAvailableNftId)?;472473        let mut const_data = token_data.const_data.as_slice();474475        NftType::decode(&mut const_data).map_err(|_| <Error<T>>::NoAvailableNftId.into())476    }477478    pub fn ensure_nft_type(collection_id: CollectionId, token_id: TokenId, nft_type: NftType) -> DispatchResult {479        let actual_type = Self::get_nft_type(collection_id, token_id)?;480        ensure!(actual_type == nft_type, <CommonError<T>>::NoPermission);481482        Ok(())483    }484485    pub fn filter_theme_properties(486        collection_id: CollectionId,487        token_id: TokenId,488        filter_keys: Option<Vec<RmrkPropertyKey>>489    ) -> Result<Vec<RmrkThemeProperty>, DispatchError> {490        filter_keys.map(|keys| {491            let properties = keys.into_iter()492                .filter_map(|key| {493                    let key: RmrkString = key.try_into().ok()?;494495                    let value = Self::get_nft_property(496                        collection_id,497                        token_id,498                        ThemeProperty(&key)499                    ).ok()?.decode_or_default();500501                    let property = RmrkThemeProperty {502                        key,503                        value504                    };505506                    Some(property)507                })508                .collect();509510            Ok(properties)511        }).unwrap_or_else(|| {512            let properties = Self::iterate_theme_properties(collection_id, token_id)?513                .collect();514515            Ok(properties)516        })517    }518519    pub fn iterate_theme_properties(520        collection_id: CollectionId,521        token_id: TokenId522    ) -> Result<impl Iterator<Item=RmrkThemeProperty>, DispatchError> {523        let key_prefix = Self::rmrk_property_key(ThemeProperty(&RmrkString::default()))?;524525        let properties = <PalletNft<T>>::token_properties((collection_id, token_id))526            .into_iter()527            .filter_map(move |(key, value)| {528                let key = key.as_slice().strip_prefix(key_prefix.as_slice())?;529530                let key: RmrkString = key.to_vec().try_into().ok()?;531                let value: RmrkString = value.decode_or_default();532533                let property = RmrkThemeProperty {534                    key,535                    value536                };537538                Some(property)539            });540541        Ok(properties)542    }543544    pub fn get_typed_nft_collection(545        collection_id: CollectionId,546        collection_type: misc::CollectionType547    ) -> Result<NonfungibleHandle<T>, DispatchError> {548        Self::ensure_collection_type(collection_id, collection_type)?;549550        Self::get_nft_collection(collection_id)551    }552553    fn map_common_err_to_proxy(err: DispatchError) -> DispatchError {554        map_common_err_to_proxy! {555            match err {556                NoPermission => NoPermission,557                CollectionTokenLimitExceeded => CollectionFullOrLocked,558                PublicMintingNotAllowed => NoPermission,559                TokenNotFound => NoAvailableNftId560            }561        }562    }563}