difftreelog
feat add scoped properties adding to pallet common
in: master
1 file changed
pallets/common/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#![cfg_attr(not(feature = "std"), no_std)]1819use core::ops::{Deref, DerefMut};20use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};21use sp_std::vec::Vec;22use pallet_evm::account::CrossAccountId;23use frame_support::{24 dispatch::{DispatchErrorWithPostInfo, DispatchResultWithPostInfo, Weight, PostDispatchInfo},25 ensure,26 traits::{Imbalance, Get, Currency, WithdrawReasons, ExistenceRequirement},27 BoundedVec,28 weights::Pays,29 transactional,30};31use pallet_evm::GasWeightMapping;32use up_data_structs::{33 COLLECTION_NUMBER_LIMIT,34 Collection,35 RpcCollection,36 CollectionId,37 CreateItemData,38 MAX_TOKEN_PREFIX_LENGTH,39 COLLECTION_ADMINS_LIMIT,40 TokenId,41 CollectionStats,42 MAX_TOKEN_OWNERSHIP,43 CollectionMode,44 NFT_SPONSOR_TRANSFER_TIMEOUT,45 FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,46 REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,47 MAX_SPONSOR_TIMEOUT,48 CUSTOM_DATA_LIMIT,49 CollectionLimits,50 CreateCollectionData,51 SponsorshipState,52 CreateItemExData,53 SponsoringRateLimit,54 budget::Budget,55 COLLECTION_FIELD_LIMIT,56 CollectionField,57 PhantomType,58 Property,59 Properties,60 PropertiesPermissionMap,61 PropertyKey,62 PropertyPermission,63 PropertiesError,64 PropertyKeyPermission,65 TokenData,66 TrySetProperty,67 // RMRK68 RmrkCollectionInfo,69 RmrkInstanceInfo,70 RmrkResourceInfo,71 RmrkPropertyInfo,72 RmrkBaseInfo,73 RmrkPartType,74 RmrkTheme,75 RmrkNftChild,76};7778pub use pallet::*;79use sp_core::H160;80use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};81#[cfg(feature = "runtime-benchmarks")]82pub mod benchmarking;83pub mod dispatch;84pub mod erc;85pub mod eth;8687#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]88pub struct CollectionHandle<T: Config> {89 pub id: CollectionId,90 collection: Collection<T::AccountId>,91 pub recorder: SubstrateRecorder<T>,92}93impl<T: Config> WithRecorder<T> for CollectionHandle<T> {94 fn recorder(&self) -> &SubstrateRecorder<T> {95 &self.recorder96 }97 fn into_recorder(self) -> SubstrateRecorder<T> {98 self.recorder99 }100}101impl<T: Config> CollectionHandle<T> {102 pub fn new_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {103 <CollectionById<T>>::get(id).map(|collection| Self {104 id,105 collection,106 recorder: SubstrateRecorder::new(gas_limit),107 })108 }109 pub fn new(id: CollectionId) -> Option<Self> {110 Self::new_with_gas_limit(id, u64::MAX)111 }112 pub fn try_get(id: CollectionId) -> Result<Self, DispatchError> {113 Ok(Self::new(id).ok_or(<Error<T>>::CollectionNotFound)?)114 }115 pub fn consume_store_reads(&self, reads: u64) -> evm_coder::execution::Result<()> {116 self.recorder117 .consume_gas(T::GasWeightMapping::weight_to_gas(118 <T as frame_system::Config>::DbWeight::get()119 .read120 .saturating_mul(reads),121 ))122 }123 pub fn consume_store_writes(&self, writes: u64) -> evm_coder::execution::Result<()> {124 self.recorder125 .consume_gas(T::GasWeightMapping::weight_to_gas(126 <T as frame_system::Config>::DbWeight::get()127 .write128 .saturating_mul(writes),129 ))130 }131 pub fn save(self) -> DispatchResult {132 <CollectionById<T>>::insert(self.id, self.collection);133 Ok(())134 }135}136impl<T: Config> Deref for CollectionHandle<T> {137 type Target = Collection<T::AccountId>;138139 fn deref(&self) -> &Self::Target {140 &self.collection141 }142}143144impl<T: Config> DerefMut for CollectionHandle<T> {145 fn deref_mut(&mut self) -> &mut Self::Target {146 &mut self.collection147 }148}149150impl<T: Config> CollectionHandle<T> {151 pub fn check_is_owner(&self, subject: &T::CrossAccountId) -> DispatchResult {152 ensure!(*subject.as_sub() == self.owner, <Error<T>>::NoPermission);153 Ok(())154 }155 pub fn is_owner_or_admin(&self, subject: &T::CrossAccountId) -> bool {156 *subject.as_sub() == self.owner || <IsAdmin<T>>::get((self.id, subject))157 }158 pub fn check_is_owner_or_admin(&self, subject: &T::CrossAccountId) -> DispatchResult {159 ensure!(self.is_owner_or_admin(subject), <Error<T>>::NoPermission);160 Ok(())161 }162 pub fn ignores_allowance(&self, user: &T::CrossAccountId) -> bool {163 self.limits.owner_can_transfer() && self.is_owner_or_admin(user)164 }165 pub fn ignores_owned_amount(&self, user: &T::CrossAccountId) -> bool {166 self.limits.owner_can_transfer() && self.is_owner_or_admin(user)167 }168 pub fn check_allowlist(&self, user: &T::CrossAccountId) -> DispatchResult {169 ensure!(170 <Allowlist<T>>::get((self.id, user)),171 <Error<T>>::AddressNotInAllowlist172 );173 Ok(())174 }175}176177#[frame_support::pallet]178pub mod pallet {179 use super::*;180 use pallet_evm::account;181 use dispatch::CollectionDispatch;182 use frame_support::{Blake2_128Concat, pallet_prelude::*, storage::Key, traits::StorageVersion};183 use frame_system::pallet_prelude::*;184 use frame_support::traits::Currency;185 use up_data_structs::{TokenId, mapping::TokenAddressMapping};186 use scale_info::TypeInfo;187188 #[pallet::config]189 pub trait Config:190 frame_system::Config + pallet_evm_coder_substrate::Config + TypeInfo + account::Config191 {192 type Event: IsType<<Self as frame_system::Config>::Event> + From<Event<Self>>;193194 type Currency: Currency<Self::AccountId>;195196 #[pallet::constant]197 type CollectionCreationPrice: Get<198 <<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,199 >;200 type CollectionDispatch: CollectionDispatch<Self>;201202 type TreasuryAccountId: Get<Self::AccountId>;203204 type EvmTokenAddressMapping: TokenAddressMapping<H160>;205 type CrossTokenAddressMapping: TokenAddressMapping<Self::CrossAccountId>;206 }207208 const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);209210 #[pallet::pallet]211 #[pallet::storage_version(STORAGE_VERSION)]212 #[pallet::generate_store(pub(super) trait Store)]213 pub struct Pallet<T>(_);214215 #[pallet::extra_constants]216 impl<T: Config> Pallet<T> {217 pub fn collection_admins_limit() -> u32 {218 COLLECTION_ADMINS_LIMIT219 }220 }221222 #[pallet::event]223 #[pallet::generate_deposit(pub fn deposit_event)]224 pub enum Event<T: Config> {225 /// New collection was created226 ///227 /// # Arguments228 ///229 /// * collection_id: Globally unique identifier of newly created collection.230 ///231 /// * mode: [CollectionMode] converted into u8.232 ///233 /// * account_id: Collection owner.234 CollectionCreated(CollectionId, u8, T::AccountId),235236 /// New collection was destroyed237 ///238 /// # Arguments239 ///240 /// * collection_id: Globally unique identifier of collection.241 CollectionDestroyed(CollectionId),242243 /// New item was created.244 ///245 /// # Arguments246 ///247 /// * collection_id: Id of the collection where item was created.248 ///249 /// * item_id: Id of an item. Unique within the collection.250 ///251 /// * recipient: Owner of newly created item252 ///253 /// * amount: Always 1 for NFT254 ItemCreated(CollectionId, TokenId, T::CrossAccountId, u128),255256 /// Collection item was burned.257 ///258 /// # Arguments259 ///260 /// * collection_id.261 ///262 /// * item_id: Identifier of burned NFT.263 ///264 /// * owner: which user has destroyed its tokens265 ///266 /// * amount: Always 1 for NFT267 ItemDestroyed(CollectionId, TokenId, T::CrossAccountId, u128),268269 /// Item was transferred270 ///271 /// * collection_id: Id of collection to which item is belong272 ///273 /// * item_id: Id of an item274 ///275 /// * sender: Original owner of item276 ///277 /// * recipient: New owner of item278 ///279 /// * amount: Always 1 for NFT280 Transfer(281 CollectionId,282 TokenId,283 T::CrossAccountId,284 T::CrossAccountId,285 u128,286 ),287288 /// * collection_id289 ///290 /// * item_id291 ///292 /// * sender293 ///294 /// * spender295 ///296 /// * amount297 Approved(298 CollectionId,299 TokenId,300 T::CrossAccountId,301 T::CrossAccountId,302 u128,303 ),304305 CollectionPropertySet(CollectionId, PropertyKey),306307 CollectionPropertyDeleted(CollectionId, PropertyKey),308309 TokenPropertySet(CollectionId, TokenId, PropertyKey),310311 TokenPropertyDeleted(CollectionId, TokenId, PropertyKey),312313 PropertyPermissionSet(CollectionId, PropertyKey),314 }315316 #[pallet::error]317 pub enum Error<T> {318 /// This collection does not exist.319 CollectionNotFound,320 /// Sender parameter and item owner must be equal.321 MustBeTokenOwner,322 /// No permission to perform action323 NoPermission,324 /// Collection is not in mint mode.325 PublicMintingNotAllowed,326 /// Address is not in allow list.327 AddressNotInAllowlist,328329 /// Collection name can not be longer than 63 char.330 CollectionNameLimitExceeded,331 /// Collection description can not be longer than 255 char.332 CollectionDescriptionLimitExceeded,333 /// Token prefix can not be longer than 15 char.334 CollectionTokenPrefixLimitExceeded,335 /// Total collections bound exceeded.336 TotalCollectionsLimitExceeded,337 /// Exceeded max admin count338 CollectionAdminCountExceeded,339 /// Collection limit bounds per collection exceeded340 CollectionLimitBoundsExceeded,341 /// Tried to enable permissions which are only permitted to be disabled342 OwnerPermissionsCantBeReverted,343 /// Collection settings not allowing items transferring344 TransferNotAllowed,345 /// Account token limit exceeded per collection346 AccountTokenLimitExceeded,347 /// Collection token limit exceeded348 CollectionTokenLimitExceeded,349 /// Metadata flag frozen350 MetadataFlagFrozen,351352 /// Item not exists.353 TokenNotFound,354 /// Item balance not enough.355 TokenValueTooLow,356 /// Requested value more than approved.357 ApprovedValueTooLow,358 /// Tried to approve more than owned359 CantApproveMoreThanOwned,360361 /// Can't transfer tokens to ethereum zero address362 AddressIsZero,363 /// Target collection doesn't supports this operation364 UnsupportedOperation,365366 /// Not sufficient founds to perform action367 NotSufficientFounds,368369 /// Collection has nesting disabled370 NestingIsDisabled,371 /// Only owner may nest tokens under this collection372 OnlyOwnerAllowedToNest,373 /// Only tokens from specific collections may nest tokens under this374 SourceCollectionIsNotAllowedToNest,375376 /// Tried to store more data than allowed in collection field377 CollectionFieldSizeExceeded,378379 /// Tried to store more property data than allowed380 NoSpaceForProperty,381382 /// Tried to store more property keys than allowed383 PropertyLimitReached,384385 /// Property key is too long386 PropertyKeyIsTooLong,387388 /// Only ASCII letters, digits, and '_', '-' are allowed389 InvalidCharacterInPropertyKey,390391 /// Empty property keys are forbidden392 EmptyPropertyKey,393 }394395 #[pallet::storage]396 pub type CreatedCollectionCount<T> = StorageValue<Value = CollectionId, QueryKind = ValueQuery>;397 #[pallet::storage]398 pub type DestroyedCollectionCount<T> =399 StorageValue<Value = CollectionId, QueryKind = ValueQuery>;400401 /// Collection info402 #[pallet::storage]403 pub type CollectionById<T> = StorageMap<404 Hasher = Blake2_128Concat,405 Key = CollectionId,406 Value = Collection<<T as frame_system::Config>::AccountId>,407 QueryKind = OptionQuery,408 >;409410 /// Collection properties411 #[pallet::storage]412 #[pallet::getter(fn collection_properties)]413 pub type CollectionProperties<T> = StorageMap<414 Hasher = Blake2_128Concat,415 Key = CollectionId,416 Value = Properties,417 QueryKind = ValueQuery,418 OnEmpty = up_data_structs::CollectionProperties,419 >;420421 #[pallet::storage]422 #[pallet::getter(fn property_permissions)]423 pub type CollectionPropertyPermissions<T> = StorageMap<424 Hasher = Blake2_128Concat,425 Key = CollectionId,426 Value = PropertiesPermissionMap,427 QueryKind = ValueQuery,428 >;429430 /// Large variable-size collection fields are extracted here431 #[pallet::storage]432 pub type CollectionData<T> = StorageNMap<433 Key = (434 Key<Twox64Concat, CollectionId>,435 Key<Twox64Concat, CollectionField>,436 ),437 Value = BoundedVec<u8, ConstU32<COLLECTION_FIELD_LIMIT>>,438 QueryKind = ValueQuery,439 >;440441 #[pallet::storage]442 pub type AdminAmount<T> = StorageMap<443 Hasher = Blake2_128Concat,444 Key = CollectionId,445 Value = u32,446 QueryKind = ValueQuery,447 >;448449 /// List of collection admins450 #[pallet::storage]451 pub type IsAdmin<T: Config> = StorageNMap<452 Key = (453 Key<Blake2_128Concat, CollectionId>,454 Key<Blake2_128Concat, T::CrossAccountId>,455 ),456 Value = bool,457 QueryKind = ValueQuery,458 >;459460 /// Allowlisted collection users461 #[pallet::storage]462 pub type Allowlist<T: Config> = StorageNMap<463 Key = (464 Key<Blake2_128Concat, CollectionId>,465 Key<Blake2_128Concat, T::CrossAccountId>,466 ),467 Value = bool,468 QueryKind = ValueQuery,469 >;470471 /// Not used by code, exists only to provide some types to metadata472 #[pallet::storage]473 pub type DummyStorageValue<T: Config> = StorageValue<474 Value = (475 CollectionStats,476 CollectionId,477 TokenId,478 PhantomType<TokenData<T::CrossAccountId>>,479 PhantomType<RpcCollection<T::AccountId>>,480 // RMRK481 PhantomType<RmrkCollectionInfo<T::AccountId>>,482 PhantomType<RmrkInstanceInfo<T::AccountId>>,483 PhantomType<RmrkResourceInfo>,484 PhantomType<RmrkPropertyInfo>,485 PhantomType<RmrkBaseInfo<T::AccountId>>,486 PhantomType<RmrkPartType>,487 PhantomType<RmrkTheme>,488 PhantomType<RmrkNftChild>,489 ),490 QueryKind = OptionQuery,491 >;492493 #[pallet::hooks]494 impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {495 fn on_runtime_upgrade() -> Weight {496 if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {497 use up_data_structs::{CollectionVersion1, CollectionVersion2};498 <CollectionById<T>>::translate::<CollectionVersion1<T::AccountId>, _>(|id, v| {499 Self::set_field_raw(500 id,501 CollectionField::OffchainSchema,502 v.offchain_schema.clone().into_inner(),503 )504 .expect("data has lower bounds than field");505 Self::set_field_raw(506 id,507 CollectionField::ConstOnChainSchema,508 v.const_on_chain_schema.clone().into_inner(),509 )510 .expect("data has lower bounds than field");511512 Some(CollectionVersion2::from(v))513 });514 }515516 0517 }518 }519}520521impl<T: Config> Pallet<T> {522 /// Ethereum receiver 0x0000000000000000000000000000000000000000 is reserved, and shouldn't own tokens523 pub fn ensure_correct_receiver(receiver: &T::CrossAccountId) -> DispatchResult {524 ensure!(525 &T::CrossAccountId::from_eth(H160([0; 20])) != receiver,526 <Error<T>>::AddressIsZero527 );528 Ok(())529 }530 pub fn adminlist(collection: CollectionId) -> Vec<T::CrossAccountId> {531 <IsAdmin<T>>::iter_prefix((collection,))532 .map(|(a, _)| a)533 .collect()534 }535 pub fn allowlist(collection: CollectionId) -> Vec<T::CrossAccountId> {536 <Allowlist<T>>::iter_prefix((collection,))537 .map(|(a, _)| a)538 .collect()539 }540 pub fn allowed(collection: CollectionId, user: T::CrossAccountId) -> bool {541 <Allowlist<T>>::get((collection, user))542 }543 pub fn collection_stats() -> CollectionStats {544 let created = <CreatedCollectionCount<T>>::get();545 let destroyed = <DestroyedCollectionCount<T>>::get();546 CollectionStats {547 created: created.0,548 destroyed: destroyed.0,549 alive: created.0 - destroyed.0,550 }551 }552553 pub fn effective_collection_limits(collection: CollectionId) -> Option<CollectionLimits> {554 let collection = <CollectionById<T>>::get(collection);555 if collection.is_none() {556 return None;557 }558559 let collection = collection.unwrap();560 let limits = collection.limits;561 let effective_limits = CollectionLimits {562 account_token_ownership_limit: Some(limits.account_token_ownership_limit()),563 sponsored_data_size: Some(limits.sponsored_data_size()),564 sponsored_data_rate_limit: Some(565 limits566 .sponsored_data_rate_limit567 .unwrap_or(SponsoringRateLimit::SponsoringDisabled),568 ),569 token_limit: Some(limits.token_limit()),570 sponsor_transfer_timeout: Some(limits.sponsor_transfer_timeout(571 match collection.mode {572 CollectionMode::NFT => NFT_SPONSOR_TRANSFER_TIMEOUT,573 CollectionMode::Fungible(_) => FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,574 CollectionMode::ReFungible => REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,575 },576 )),577 sponsor_approve_timeout: Some(limits.sponsor_approve_timeout()),578 owner_can_transfer: Some(limits.owner_can_transfer()),579 owner_can_destroy: Some(limits.owner_can_destroy()),580 transfers_enabled: Some(limits.transfers_enabled()),581 nesting_rule: Some(limits.nesting_rule().clone()),582 };583584 Some(effective_limits)585 }586587 pub fn rpc_collection(collection: CollectionId) -> Option<RpcCollection<T::AccountId>> {588 let Collection {589 name,590 description,591 owner,592 mode,593 access,594 token_prefix,595 mint_mode,596 schema_version,597 sponsorship,598 limits,599 } = <CollectionById<T>>::get(collection)?;600601 let token_property_permissions = <CollectionPropertyPermissions<T>>::get(collection)602 .iter()603 .map(|(key, permission)| PropertyKeyPermission {604 key: key.clone(),605 permission: permission.clone(),606 })607 .collect();608609 let properties = <CollectionProperties<T>>::get(collection)610 .iter()611 .map(|(key, value)| Property {612 key: key.clone(),613 value: value.clone(),614 })615 .collect();616617 Some(RpcCollection {618 name: name.into_inner(),619 description: description.into_inner(),620 owner,621 mode,622 access,623 token_prefix: token_prefix.into_inner(),624 mint_mode,625 schema_version,626 sponsorship,627 limits,628 offchain_schema: <CollectionData<T>>::get((629 collection,630 CollectionField::OffchainSchema,631 ))632 .into_inner(),633 const_on_chain_schema: <CollectionData<T>>::get((634 collection,635 CollectionField::ConstOnChainSchema,636 ))637 .into_inner(),638 token_property_permissions,639 properties,640 })641 }642}643644impl<T: Config> Pallet<T> {645 pub fn init_collection(646 owner: T::AccountId,647 data: CreateCollectionData<T::AccountId>,648 ) -> Result<CollectionId, DispatchError> {649 {650 ensure!(651 data.token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH as usize,652 Error::<T>::CollectionTokenPrefixLimitExceeded653 );654 }655656 let created_count = <CreatedCollectionCount<T>>::get()657 .0658 .checked_add(1)659 .ok_or(ArithmeticError::Overflow)?;660 let destroyed_count = <DestroyedCollectionCount<T>>::get().0;661 let id = CollectionId(created_count);662663 // bound Total number of collections664 ensure!(665 created_count - destroyed_count <= COLLECTION_NUMBER_LIMIT,666 <Error<T>>::TotalCollectionsLimitExceeded667 );668669 // =========670671 let collection = Collection {672 owner: owner.clone(),673 name: data.name,674 mode: data.mode.clone(),675 mint_mode: false,676 access: data.access.unwrap_or_default(),677 description: data.description,678 token_prefix: data.token_prefix,679 schema_version: data.schema_version.unwrap_or_default(),680 sponsorship: data681 .pending_sponsor682 .map(SponsorshipState::Unconfirmed)683 .unwrap_or_default(),684 limits: data685 .limits686 .map(|limits| Self::clamp_limits(data.mode.clone(), &Default::default(), limits))687 .unwrap_or_else(|| Ok(CollectionLimits::default()))?,688 };689690 let mut collection_properties = up_data_structs::CollectionProperties::get();691 collection_properties692 .try_set_from_iter(data.properties.into_iter().map(|p| (p.key, p.value)))693 .map_err(<Error<T>>::from)?;694695 CollectionProperties::<T>::insert(id, collection_properties);696697 let mut token_props_permissions = PropertiesPermissionMap::new();698 token_props_permissions699 .try_set_from_iter(700 data.token_property_permissions701 .into_iter()702 .map(|property| (property.key, property.permission)),703 )704 .map_err(<Error<T>>::from)?;705706 CollectionPropertyPermissions::<T>::insert(id, token_props_permissions);707708 // Take a (non-refundable) deposit of collection creation709 {710 let mut imbalance =711 <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();712 imbalance.subsume(713 <<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(714 &T::TreasuryAccountId::get(),715 T::CollectionCreationPrice::get(),716 ),717 );718 <T as Config>::Currency::settle(719 &owner,720 imbalance,721 WithdrawReasons::TRANSFER,722 ExistenceRequirement::KeepAlive,723 )724 .map_err(|_| Error::<T>::NotSufficientFounds)?;725 }726727 <CreatedCollectionCount<T>>::put(created_count);728 <Pallet<T>>::deposit_event(Event::CollectionCreated(id, data.mode.id(), owner.clone()));729 <CollectionById<T>>::insert(id, collection);730 Self::set_field_raw(731 id,732 CollectionField::OffchainSchema,733 data.offchain_schema.into_inner(),734 )735 .expect("data has lower bounds than field");736 Self::set_field_raw(737 id,738 CollectionField::ConstOnChainSchema,739 data.const_on_chain_schema.into_inner(),740 )741 .expect("data has lower bounds than field");742 Ok(id)743 }744745 pub fn destroy_collection(746 collection: CollectionHandle<T>,747 sender: &T::CrossAccountId,748 ) -> DispatchResult {749 ensure!(750 collection.limits.owner_can_destroy(),751 <Error<T>>::NoPermission,752 );753 collection.check_is_owner(sender)?;754755 let destroyed_collections = <DestroyedCollectionCount<T>>::get()756 .0757 .checked_add(1)758 .ok_or(ArithmeticError::Overflow)?;759760 // =========761762 <DestroyedCollectionCount<T>>::put(destroyed_collections);763 <CollectionById<T>>::remove(collection.id);764 <CollectionData<T>>::remove_prefix((collection.id,), None);765 <AdminAmount<T>>::remove(collection.id);766 <IsAdmin<T>>::remove_prefix((collection.id,), None);767 <Allowlist<T>>::remove_prefix((collection.id,), None);768769 <Pallet<T>>::deposit_event(Event::CollectionDestroyed(collection.id));770 Ok(())771 }772773 pub fn set_collection_property(774 collection: &CollectionHandle<T>,775 sender: &T::CrossAccountId,776 property: Property,777 ) -> DispatchResult {778 collection.check_is_owner_or_admin(sender)?;779780 CollectionProperties::<T>::try_mutate(collection.id, |properties| {781 let property = property.clone();782 properties.try_set(property.key, property.value)783 })784 .map_err(<Error<T>>::from)?;785786 Self::deposit_event(Event::CollectionPropertySet(collection.id, property.key));787788 Ok(())789 }790791 #[transactional]792 pub fn set_collection_properties(793 collection: &CollectionHandle<T>,794 sender: &T::CrossAccountId,795 properties: Vec<Property>,796 ) -> DispatchResult {797 for property in properties {798 Self::set_collection_property(collection, sender, property)?;799 }800801 Ok(())802 }803804 pub fn delete_collection_property(805 collection: &CollectionHandle<T>,806 sender: &T::CrossAccountId,807 property_key: PropertyKey,808 ) -> DispatchResult {809 collection.check_is_owner_or_admin(sender)?;810811 CollectionProperties::<T>::try_mutate(collection.id, |properties| {812 properties.remove(&property_key)813 })814 .map_err(<Error<T>>::from)?;815816 Self::deposit_event(Event::CollectionPropertyDeleted(817 collection.id,818 property_key,819 ));820821 Ok(())822 }823824 #[transactional]825 pub fn delete_collection_properties(826 collection: &CollectionHandle<T>,827 sender: &T::CrossAccountId,828 property_keys: Vec<PropertyKey>,829 ) -> DispatchResult {830 for key in property_keys {831 Self::delete_collection_property(collection, sender, key)?;832 }833834 Ok(())835 }836837 pub fn set_property_permission(838 collection: &CollectionHandle<T>,839 sender: &T::CrossAccountId,840 property_permission: PropertyKeyPermission,841 ) -> DispatchResult {842 collection.check_is_owner_or_admin(sender)?;843844 let all_permissions = CollectionPropertyPermissions::<T>::get(collection.id);845 let current_permission = all_permissions.get(&property_permission.key);846 if matches![847 current_permission,848 Some(PropertyPermission { mutable: false, .. })849 ] {850 return Err(<Error<T>>::NoPermission.into());851 }852853 CollectionPropertyPermissions::<T>::try_mutate(collection.id, |permissions| {854 let property_permission = property_permission.clone();855 permissions.try_set(property_permission.key, property_permission.permission)856 })857 .map_err(<Error<T>>::from)?;858859 Self::deposit_event(Event::PropertyPermissionSet(860 collection.id,861 property_permission.key,862 ));863864 Ok(())865 }866867 #[transactional]868 pub fn set_property_permissions(869 collection: &CollectionHandle<T>,870 sender: &T::CrossAccountId,871 property_permissions: Vec<PropertyKeyPermission>,872 ) -> DispatchResult {873 for prop_pemission in property_permissions {874 Self::set_property_permission(collection, sender, prop_pemission)?;875 }876877 Ok(())878 }879880 pub fn bytes_keys_to_property_keys(881 keys: Vec<Vec<u8>>,882 ) -> Result<Vec<PropertyKey>, DispatchError> {883 keys.into_iter()884 .map(|key| -> Result<PropertyKey, DispatchError> {885 key.try_into()886 .map_err(|_| <Error<T>>::PropertyKeyIsTooLong.into())887 })888 .collect::<Result<Vec<PropertyKey>, DispatchError>>()889 }890891 pub fn filter_collection_properties(892 collection_id: CollectionId,893 keys: Option<Vec<PropertyKey>>,894 ) -> Result<Vec<Property>, DispatchError> {895 let properties = Self::collection_properties(collection_id);896897 let properties = keys898 .map(|keys| {899 keys.into_iter()900 .filter_map(|key| {901 properties.get(&key).map(|value| Property {902 key,903 value: value.clone(),904 })905 })906 .collect()907 })908 .unwrap_or_else(|| {909 properties910 .iter()911 .map(|(key, value)| Property {912 key: key.clone(),913 value: value.clone(),914 })915 .collect()916 });917918 Ok(properties)919 }920921 pub fn filter_property_permissions(922 collection_id: CollectionId,923 keys: Option<Vec<PropertyKey>>,924 ) -> Result<Vec<PropertyKeyPermission>, DispatchError> {925 let permissions = Self::property_permissions(collection_id);926927 let key_permissions = keys928 .map(|keys| {929 keys.into_iter()930 .filter_map(|key| {931 permissions932 .get(&key)933 .map(|permission| PropertyKeyPermission {934 key,935 permission: permission.clone(),936 })937 })938 .collect()939 })940 .unwrap_or_else(|| {941 permissions942 .iter()943 .map(|(key, permission)| PropertyKeyPermission {944 key: key.clone(),945 permission: permission.clone(),946 })947 .collect()948 });949950 Ok(key_permissions)951 }952953 fn set_field_raw(954 collection_id: CollectionId,955 field: CollectionField,956 value: Vec<u8>,957 ) -> DispatchResult {958 if !value.is_empty() {959 <CollectionData<T>>::insert(960 (collection_id, field),961 BoundedVec::try_from(value).map_err(|_| <Error<T>>::CollectionFieldSizeExceeded)?,962 )963 } else {964 <CollectionData<T>>::remove((collection_id, field));965 }966 Ok(())967 }968969 pub fn set_field(970 collection: &CollectionHandle<T>,971 sender: &T::CrossAccountId,972 field: CollectionField,973 value: Vec<u8>,974 ) -> DispatchResult {975 collection.check_is_owner_or_admin(sender)?;976977 // =========978979 Self::set_field_raw(collection.id, field, value)980 }981982 pub fn toggle_allowlist(983 collection: &CollectionHandle<T>,984 sender: &T::CrossAccountId,985 user: &T::CrossAccountId,986 allowed: bool,987 ) -> DispatchResult {988 collection.check_is_owner_or_admin(sender)?;989990 // =========991992 if allowed {993 <Allowlist<T>>::insert((collection.id, user), true);994 } else {995 <Allowlist<T>>::remove((collection.id, user));996 }997998 Ok(())999 }10001001 pub fn toggle_admin(1002 collection: &CollectionHandle<T>,1003 sender: &T::CrossAccountId,1004 user: &T::CrossAccountId,1005 admin: bool,1006 ) -> DispatchResult {1007 collection.check_is_owner_or_admin(sender)?;10081009 let was_admin = <IsAdmin<T>>::get((collection.id, user));1010 if was_admin == admin {1011 return Ok(());1012 }1013 let amount = <AdminAmount<T>>::get(collection.id);10141015 if admin {1016 let amount = amount1017 .checked_add(1)1018 .ok_or(<Error<T>>::CollectionAdminCountExceeded)?;1019 ensure!(1020 amount <= Self::collection_admins_limit(),1021 <Error<T>>::CollectionAdminCountExceeded,1022 );10231024 // =========10251026 <AdminAmount<T>>::insert(collection.id, amount);1027 <IsAdmin<T>>::insert((collection.id, user), true);1028 } else {1029 <AdminAmount<T>>::insert(collection.id, amount.saturating_sub(1));1030 <IsAdmin<T>>::remove((collection.id, user));1031 }10321033 Ok(())1034 }10351036 pub fn clamp_limits(1037 mode: CollectionMode,1038 old_limit: &CollectionLimits,1039 mut new_limit: CollectionLimits,1040 ) -> Result<CollectionLimits, DispatchError> {1041 macro_rules! limit_default {1042 ($old:ident, $new:ident, $($field:ident $(($arg:expr))? => $check:expr),* $(,)?) => {{1043 $(1044 if let Some($new) = $new.$field {1045 let $old = $old.$field($($arg)?);1046 let _ = $new;1047 let _ = $old;1048 $check1049 } else {1050 $new.$field = $old.$field1051 }1052 )*1053 }};1054 }10551056 limit_default!(old_limit, new_limit,1057 account_token_ownership_limit => ensure!(1058 new_limit <= MAX_TOKEN_OWNERSHIP,1059 <Error<T>>::CollectionLimitBoundsExceeded,1060 ),1061 sponsor_transfer_timeout(match mode {1062 CollectionMode::NFT => NFT_SPONSOR_TRANSFER_TIMEOUT,1063 CollectionMode::Fungible(_) => FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,1064 CollectionMode::ReFungible => REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,1065 }) => ensure!(1066 new_limit <= MAX_SPONSOR_TIMEOUT,1067 <Error<T>>::CollectionLimitBoundsExceeded,1068 ),1069 sponsored_data_size => ensure!(1070 new_limit <= CUSTOM_DATA_LIMIT,1071 <Error<T>>::CollectionLimitBoundsExceeded,1072 ),1073 token_limit => ensure!(1074 old_limit >= new_limit && new_limit > 0,1075 <Error<T>>::CollectionTokenLimitExceeded1076 ),1077 owner_can_transfer => ensure!(1078 old_limit || !new_limit,1079 <Error<T>>::OwnerPermissionsCantBeReverted,1080 ),1081 owner_can_destroy => ensure!(1082 old_limit || !new_limit,1083 <Error<T>>::OwnerPermissionsCantBeReverted,1084 ),1085 sponsored_data_rate_limit => {},1086 transfers_enabled => {},1087 );1088 Ok(new_limit)1089 }1090}10911092#[macro_export]1093macro_rules! unsupported {1094 () => {1095 Err(<Error<T>>::UnsupportedOperation.into())1096 };1097}10981099/// Worst cases1100pub trait CommonWeightInfo<CrossAccountId> {1101 fn create_item() -> Weight;1102 fn create_multiple_items(amount: u32) -> Weight;1103 fn create_multiple_items_ex(cost: &CreateItemExData<CrossAccountId>) -> Weight;1104 fn burn_item() -> Weight;1105 fn set_collection_properties(amount: u32) -> Weight;1106 fn delete_collection_properties(amount: u32) -> Weight;1107 fn set_token_properties(amount: u32) -> Weight;1108 fn delete_token_properties(amount: u32) -> Weight;1109 fn set_property_permissions(amount: u32) -> Weight;1110 fn transfer() -> Weight;1111 fn approve() -> Weight;1112 fn transfer_from() -> Weight;1113 fn burn_from() -> Weight;1114}11151116pub trait CommonCollectionOperations<T: Config> {1117 fn create_item(1118 &self,1119 sender: T::CrossAccountId,1120 to: T::CrossAccountId,1121 data: CreateItemData,1122 nesting_budget: &dyn Budget,1123 ) -> DispatchResultWithPostInfo;1124 fn create_multiple_items(1125 &self,1126 sender: T::CrossAccountId,1127 to: T::CrossAccountId,1128 data: Vec<CreateItemData>,1129 nesting_budget: &dyn Budget,1130 ) -> DispatchResultWithPostInfo;1131 fn create_multiple_items_ex(1132 &self,1133 sender: T::CrossAccountId,1134 data: CreateItemExData<T::CrossAccountId>,1135 nesting_budget: &dyn Budget,1136 ) -> DispatchResultWithPostInfo;1137 fn burn_item(1138 &self,1139 sender: T::CrossAccountId,1140 token: TokenId,1141 amount: u128,1142 ) -> DispatchResultWithPostInfo;1143 fn set_collection_properties(1144 &self,1145 sender: T::CrossAccountId,1146 properties: Vec<Property>,1147 ) -> DispatchResultWithPostInfo;1148 fn delete_collection_properties(1149 &self,1150 sender: &T::CrossAccountId,1151 property_keys: Vec<PropertyKey>,1152 ) -> DispatchResultWithPostInfo;1153 fn set_token_properties(1154 &self,1155 sender: T::CrossAccountId,1156 token_id: TokenId,1157 property: Vec<Property>,1158 ) -> DispatchResultWithPostInfo;1159 fn delete_token_properties(1160 &self,1161 sender: T::CrossAccountId,1162 token_id: TokenId,1163 property_keys: Vec<PropertyKey>,1164 ) -> DispatchResultWithPostInfo;1165 fn set_property_permissions(1166 &self,1167 sender: &T::CrossAccountId,1168 property_permissions: Vec<PropertyKeyPermission>,1169 ) -> DispatchResultWithPostInfo;1170 fn transfer(1171 &self,1172 sender: T::CrossAccountId,1173 to: T::CrossAccountId,1174 token: TokenId,1175 amount: u128,1176 nesting_budget: &dyn Budget,1177 ) -> DispatchResultWithPostInfo;1178 fn approve(1179 &self,1180 sender: T::CrossAccountId,1181 spender: T::CrossAccountId,1182 token: TokenId,1183 amount: u128,1184 ) -> DispatchResultWithPostInfo;1185 fn transfer_from(1186 &self,1187 sender: T::CrossAccountId,1188 from: T::CrossAccountId,1189 to: T::CrossAccountId,1190 token: TokenId,1191 amount: u128,1192 nesting_budget: &dyn Budget,1193 ) -> DispatchResultWithPostInfo;1194 fn burn_from(1195 &self,1196 sender: T::CrossAccountId,1197 from: T::CrossAccountId,1198 token: TokenId,1199 amount: u128,1200 nesting_budget: &dyn Budget,1201 ) -> DispatchResultWithPostInfo;12021203 fn check_nesting(1204 &self,1205 sender: T::CrossAccountId,1206 from: (CollectionId, TokenId),1207 under: TokenId,1208 budget: &dyn Budget,1209 ) -> DispatchResult;12101211 fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId>;1212 fn collection_tokens(&self) -> Vec<TokenId>;1213 fn token_exists(&self, token: TokenId) -> bool;1214 fn last_token_id(&self) -> TokenId;12151216 fn token_owner(&self, token: TokenId) -> Option<T::CrossAccountId>;1217 fn const_metadata(&self, token: TokenId) -> Vec<u8>;1218 fn token_properties(&self, token_id: TokenId, keys: Option<Vec<PropertyKey>>) -> Vec<Property>;1219 /// Amount of unique collection tokens1220 fn total_supply(&self) -> u32;1221 /// Amount of different tokens account has (Applicable to nonfungible/refungible)1222 fn account_balance(&self, account: T::CrossAccountId) -> u32;1223 /// Amount of specific token account have (Applicable to fungible/refungible)1224 fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128;1225 fn allowance(1226 &self,1227 sender: T::CrossAccountId,1228 spender: T::CrossAccountId,1229 token: TokenId,1230 ) -> u128;1231}12321233// Flexible enough for implementing CommonCollectionOperations1234pub fn with_weight(res: DispatchResult, weight: Weight) -> DispatchResultWithPostInfo {1235 let post_info = PostDispatchInfo {1236 actual_weight: Some(weight),1237 pays_fee: Pays::Yes,1238 };1239 match res {1240 Ok(()) => Ok(post_info),1241 Err(error) => Err(DispatchErrorWithPostInfo { post_info, error }),1242 }1243}12441245impl<T: Config> From<PropertiesError> for Error<T> {1246 fn from(error: PropertiesError) -> Self {1247 match error {1248 PropertiesError::NoSpaceForProperty => Self::NoSpaceForProperty,1249 PropertiesError::PropertyLimitReached => Self::PropertyLimitReached,1250 PropertiesError::InvalidCharacterInPropertyKey => Self::InvalidCharacterInPropertyKey,1251 PropertiesError::PropertyKeyIsTooLong => Self::PropertyKeyIsTooLong,1252 PropertiesError::EmptyPropertyKey => Self::EmptyPropertyKey,1253 }1254 }1255}