difftreelog
feat(common) force storage version
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)]1819extern crate alloc;2021use core::ops::{Deref, DerefMut};22use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};23use sp_std::vec::Vec;24use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};25use evm_coder::ToLog;26use frame_support::{27 dispatch::{DispatchErrorWithPostInfo, DispatchResultWithPostInfo, Weight, PostDispatchInfo},28 ensure,29 traits::{Imbalance, Get, Currency, WithdrawReasons, ExistenceRequirement},30 weights::Pays,31 transactional,32};33use pallet_evm::GasWeightMapping;34use up_data_structs::{35 COLLECTION_NUMBER_LIMIT,36 Collection,37 RpcCollection,38 CollectionId,39 CreateItemData,40 MAX_TOKEN_PREFIX_LENGTH,41 COLLECTION_ADMINS_LIMIT,42 TokenId,43 TokenChild,44 CollectionStats,45 MAX_TOKEN_OWNERSHIP,46 CollectionMode,47 NFT_SPONSOR_TRANSFER_TIMEOUT,48 FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,49 REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,50 MAX_SPONSOR_TIMEOUT,51 CUSTOM_DATA_LIMIT,52 CollectionLimits,53 CreateCollectionData,54 SponsorshipState,55 CreateItemExData,56 SponsoringRateLimit,57 budget::Budget,58 PhantomType,59 Property,60 Properties,61 PropertiesPermissionMap,62 PropertyKey,63 PropertyValue,64 PropertyPermission,65 PropertiesError,66 PropertyKeyPermission,67 TokenData,68 TrySetProperty,69 PropertyScope,70 // RMRK71 RmrkCollectionInfo,72 RmrkInstanceInfo,73 RmrkResourceInfo,74 RmrkPropertyInfo,75 RmrkBaseInfo,76 RmrkPartType,77 RmrkBoundedTheme,78 RmrkNftChild,79 CollectionPermissions,80 SchemaVersion,81};8283pub use pallet::*;84use sp_core::H160;85use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};86#[cfg(feature = "runtime-benchmarks")]87pub mod benchmarking;88pub mod dispatch;89pub mod erc;90pub mod eth;91pub mod weights;9293pub type SelfWeightOf<T> = <T as Config>::WeightInfo;9495#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]96pub struct CollectionHandle<T: Config> {97 pub id: CollectionId,98 collection: Collection<T::AccountId>,99 pub recorder: SubstrateRecorder<T>,100}101impl<T: Config> WithRecorder<T> for CollectionHandle<T> {102 fn recorder(&self) -> &SubstrateRecorder<T> {103 &self.recorder104 }105 fn into_recorder(self) -> SubstrateRecorder<T> {106 self.recorder107 }108}109impl<T: Config> CollectionHandle<T> {110 pub fn new_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {111 <CollectionById<T>>::get(id).map(|collection| Self {112 id,113 collection,114 recorder: SubstrateRecorder::new(gas_limit),115 })116 }117118 pub fn new_with_recorder(id: CollectionId, recorder: SubstrateRecorder<T>) -> Option<Self> {119 <CollectionById<T>>::get(id).map(|collection| Self {120 id,121 collection,122 recorder,123 })124 }125126 pub fn new(id: CollectionId) -> Option<Self> {127 Self::new_with_gas_limit(id, u64::MAX)128 }129130 pub fn try_get(id: CollectionId) -> Result<Self, DispatchError> {131 Ok(Self::new(id).ok_or(<Error<T>>::CollectionNotFound)?)132 }133134 pub fn consume_store_reads(&self, reads: u64) -> evm_coder::execution::Result<()> {135 self.recorder136 .consume_gas(T::GasWeightMapping::weight_to_gas(137 <T as frame_system::Config>::DbWeight::get()138 .read139 .saturating_mul(reads),140 ))141 }142143 pub fn consume_store_writes(&self, writes: u64) -> evm_coder::execution::Result<()> {144 self.recorder145 .consume_gas(T::GasWeightMapping::weight_to_gas(146 <T as frame_system::Config>::DbWeight::get()147 .write148 .saturating_mul(writes),149 ))150 }151 pub fn save(self) -> DispatchResult {152 <CollectionById<T>>::insert(self.id, self.collection);153 Ok(())154 }155156 pub fn set_sponsor(&mut self, sponsor: T::AccountId) -> DispatchResult {157 self.collection.sponsorship = SponsorshipState::Unconfirmed(sponsor);158 Ok(())159 }160161 pub fn confirm_sponsorship(&mut self, sender: &T::AccountId) -> Result<bool, DispatchError> {162 if self.collection.sponsorship.pending_sponsor() != Some(sender) {163 return Ok(false);164 }165166 self.collection.sponsorship = SponsorshipState::Confirmed(sender.clone());167 Ok(true)168 }169170 /// Checks that the collection was created with, and must be operated upon through **Unique API**.171 /// Now check only the `external_collection` flag and if it's **true**, then return `CollectionIsExternal` error.172 pub fn check_is_internal(&self) -> DispatchResult {173 if self.external_collection {174 return Err(<Error<T>>::CollectionIsExternal)?;175 }176177 Ok(())178 }179180 /// Checks that the collection was created with, and must be operated upon through an **assimilated API**.181 /// Now check only the `external_collection` flag and if it's **false**, then return `CollectionIsInternal` error.182 pub fn check_is_external(&self) -> DispatchResult {183 if !self.external_collection {184 return Err(<Error<T>>::CollectionIsInternal)?;185 }186187 Ok(())188 }189}190191impl<T: Config> Deref for CollectionHandle<T> {192 type Target = Collection<T::AccountId>;193194 fn deref(&self) -> &Self::Target {195 &self.collection196 }197}198199impl<T: Config> DerefMut for CollectionHandle<T> {200 fn deref_mut(&mut self) -> &mut Self::Target {201 &mut self.collection202 }203}204205impl<T: Config> CollectionHandle<T> {206 pub fn check_is_owner(&self, subject: &T::CrossAccountId) -> DispatchResult {207 ensure!(*subject.as_sub() == self.owner, <Error<T>>::NoPermission);208 Ok(())209 }210 pub fn is_owner_or_admin(&self, subject: &T::CrossAccountId) -> bool {211 *subject.as_sub() == self.owner || <IsAdmin<T>>::get((self.id, subject))212 }213 pub fn check_is_owner_or_admin(&self, subject: &T::CrossAccountId) -> DispatchResult {214 ensure!(self.is_owner_or_admin(subject), <Error<T>>::NoPermission);215 Ok(())216 }217 pub fn ignores_allowance(&self, user: &T::CrossAccountId) -> bool {218 self.limits.owner_can_transfer() && self.is_owner_or_admin(user)219 }220 pub fn ignores_owned_amount(&self, user: &T::CrossAccountId) -> bool {221 self.limits.owner_can_transfer() && self.is_owner_or_admin(user)222 }223 pub fn check_allowlist(&self, user: &T::CrossAccountId) -> DispatchResult {224 ensure!(225 <Allowlist<T>>::get((self.id, user)),226 <Error<T>>::AddressNotInAllowlist227 );228 Ok(())229 }230}231232#[frame_support::pallet]233pub mod pallet {234 use super::*;235 use pallet_evm::account;236 use dispatch::CollectionDispatch;237 use frame_support::{Blake2_128Concat, pallet_prelude::*, storage::Key, traits::StorageVersion};238 use frame_system::pallet_prelude::*;239 use frame_support::traits::Currency;240 use up_data_structs::{TokenId, mapping::TokenAddressMapping};241 use scale_info::TypeInfo;242 use weights::WeightInfo;243244 #[pallet::config]245 pub trait Config:246 frame_system::Config247 + pallet_evm_coder_substrate::Config248 + pallet_evm::Config249 + TypeInfo250 + account::Config251 {252 type WeightInfo: WeightInfo;253 type Event: IsType<<Self as frame_system::Config>::Event> + From<Event<Self>>;254255 type Currency: Currency<Self::AccountId>;256257 #[pallet::constant]258 type CollectionCreationPrice: Get<259 <<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,260 >;261 type CollectionDispatch: CollectionDispatch<Self>;262263 type TreasuryAccountId: Get<Self::AccountId>;264 type ContractAddress: Get<H160>;265266 type EvmTokenAddressMapping: TokenAddressMapping<H160>;267 type CrossTokenAddressMapping: TokenAddressMapping<Self::CrossAccountId>;268 }269270 const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);271272 #[pallet::pallet]273 #[pallet::storage_version(STORAGE_VERSION)]274 #[pallet::generate_store(pub(super) trait Store)]275 pub struct Pallet<T>(_);276277 #[pallet::extra_constants]278 impl<T: Config> Pallet<T> {279 pub fn collection_admins_limit() -> u32 {280 COLLECTION_ADMINS_LIMIT281 }282 }283284 #[pallet::event]285 #[pallet::generate_deposit(pub fn deposit_event)]286 pub enum Event<T: Config> {287 /// New collection was created288 ///289 /// # Arguments290 ///291 /// * collection_id: Globally unique identifier of newly created collection.292 ///293 /// * mode: [CollectionMode] converted into u8.294 ///295 /// * account_id: Collection owner.296 CollectionCreated(CollectionId, u8, T::AccountId),297298 /// New collection was destroyed299 ///300 /// # Arguments301 ///302 /// * collection_id: Globally unique identifier of collection.303 CollectionDestroyed(CollectionId),304305 /// New item was created.306 ///307 /// # Arguments308 ///309 /// * collection_id: Id of the collection where item was created.310 ///311 /// * item_id: Id of an item. Unique within the collection.312 ///313 /// * recipient: Owner of newly created item314 ///315 /// * amount: Always 1 for NFT316 ItemCreated(CollectionId, TokenId, T::CrossAccountId, u128),317318 /// Collection item was burned.319 ///320 /// # Arguments321 ///322 /// * collection_id.323 ///324 /// * item_id: Identifier of burned NFT.325 ///326 /// * owner: which user has destroyed its tokens327 ///328 /// * amount: Always 1 for NFT329 ItemDestroyed(CollectionId, TokenId, T::CrossAccountId, u128),330331 /// Item was transferred332 ///333 /// * collection_id: Id of collection to which item is belong334 ///335 /// * item_id: Id of an item336 ///337 /// * sender: Original owner of item338 ///339 /// * recipient: New owner of item340 ///341 /// * amount: Always 1 for NFT342 Transfer(343 CollectionId,344 TokenId,345 T::CrossAccountId,346 T::CrossAccountId,347 u128,348 ),349350 /// * collection_id351 ///352 /// * item_id353 ///354 /// * sender355 ///356 /// * spender357 ///358 /// * amount359 Approved(360 CollectionId,361 TokenId,362 T::CrossAccountId,363 T::CrossAccountId,364 u128,365 ),366367 CollectionPropertySet(CollectionId, PropertyKey),368369 CollectionPropertyDeleted(CollectionId, PropertyKey),370371 TokenPropertySet(CollectionId, TokenId, PropertyKey),372373 TokenPropertyDeleted(CollectionId, TokenId, PropertyKey),374375 PropertyPermissionSet(CollectionId, PropertyKey),376 }377378 #[pallet::error]379 pub enum Error<T> {380 /// This collection does not exist.381 CollectionNotFound,382 /// Sender parameter and item owner must be equal.383 MustBeTokenOwner,384 /// No permission to perform action385 NoPermission,386 /// Destroying only empty collections is allowed387 CantDestroyNotEmptyCollection,388 /// Collection is not in mint mode.389 PublicMintingNotAllowed,390 /// Address is not in allow list.391 AddressNotInAllowlist,392393 /// Collection name can not be longer than 63 char.394 CollectionNameLimitExceeded,395 /// Collection description can not be longer than 255 char.396 CollectionDescriptionLimitExceeded,397 /// Token prefix can not be longer than 15 char.398 CollectionTokenPrefixLimitExceeded,399 /// Total collections bound exceeded.400 TotalCollectionsLimitExceeded,401 /// Exceeded max admin count402 CollectionAdminCountExceeded,403 /// Collection limit bounds per collection exceeded404 CollectionLimitBoundsExceeded,405 /// Tried to enable permissions which are only permitted to be disabled406 OwnerPermissionsCantBeReverted,407 /// Collection settings not allowing items transferring408 TransferNotAllowed,409 /// Account token limit exceeded per collection410 AccountTokenLimitExceeded,411 /// Collection token limit exceeded412 CollectionTokenLimitExceeded,413 /// Metadata flag frozen414 MetadataFlagFrozen,415416 /// Item not exists.417 TokenNotFound,418 /// Item balance not enough.419 TokenValueTooLow,420 /// Requested value more than approved.421 ApprovedValueTooLow,422 /// Tried to approve more than owned423 CantApproveMoreThanOwned,424425 /// Can't transfer tokens to ethereum zero address426 AddressIsZero,427 /// Target collection doesn't supports this operation428 UnsupportedOperation,429430 /// Not sufficient funds to perform action431 NotSufficientFounds,432433 /// User not passed nesting rule434 UserIsNotAllowedToNest,435 /// Only tokens from specific collections may nest tokens under this436 SourceCollectionIsNotAllowedToNest,437438 /// Tried to store more data than allowed in collection field439 CollectionFieldSizeExceeded,440441 /// Tried to store more property data than allowed442 NoSpaceForProperty,443444 /// Tried to store more property keys than allowed445 PropertyLimitReached,446447 /// Property key is too long448 PropertyKeyIsTooLong,449450 /// Only ASCII letters, digits, and '_', '-' are allowed451 InvalidCharacterInPropertyKey,452453 /// Empty property keys are forbidden454 EmptyPropertyKey,455456 /// Tried to access an external collection with an internal API457 CollectionIsExternal,458459 /// Tried to access an internal collection with an external API460 CollectionIsInternal,461 }462463 #[pallet::storage]464 pub type CreatedCollectionCount<T> = StorageValue<Value = CollectionId, QueryKind = ValueQuery>;465 #[pallet::storage]466 pub type DestroyedCollectionCount<T> =467 StorageValue<Value = CollectionId, QueryKind = ValueQuery>;468469 /// Collection info470 #[pallet::storage]471 pub type CollectionById<T> = StorageMap<472 Hasher = Blake2_128Concat,473 Key = CollectionId,474 Value = Collection<<T as frame_system::Config>::AccountId>,475 QueryKind = OptionQuery,476 >;477478 /// Collection properties479 #[pallet::storage]480 #[pallet::getter(fn collection_properties)]481 pub type CollectionProperties<T> = StorageMap<482 Hasher = Blake2_128Concat,483 Key = CollectionId,484 Value = Properties,485 QueryKind = ValueQuery,486 OnEmpty = up_data_structs::CollectionProperties,487 >;488489 #[pallet::storage]490 #[pallet::getter(fn property_permissions)]491 pub type CollectionPropertyPermissions<T> = StorageMap<492 Hasher = Blake2_128Concat,493 Key = CollectionId,494 Value = PropertiesPermissionMap,495 QueryKind = ValueQuery,496 >;497498 #[pallet::storage]499 pub type AdminAmount<T> = StorageMap<500 Hasher = Blake2_128Concat,501 Key = CollectionId,502 Value = u32,503 QueryKind = ValueQuery,504 >;505506 /// List of collection admins507 #[pallet::storage]508 pub type IsAdmin<T: Config> = StorageNMap<509 Key = (510 Key<Blake2_128Concat, CollectionId>,511 Key<Blake2_128Concat, T::CrossAccountId>,512 ),513 Value = bool,514 QueryKind = ValueQuery,515 >;516517 /// Allowlisted collection users518 #[pallet::storage]519 pub type Allowlist<T: Config> = StorageNMap<520 Key = (521 Key<Blake2_128Concat, CollectionId>,522 Key<Blake2_128Concat, T::CrossAccountId>,523 ),524 Value = bool,525 QueryKind = ValueQuery,526 >;527528 /// Not used by code, exists only to provide some types to metadata529 #[pallet::storage]530 pub type DummyStorageValue<T: Config> = StorageValue<531 Value = (532 CollectionStats,533 CollectionId,534 TokenId,535 TokenChild,536 PhantomType<(537 TokenData<T::CrossAccountId>,538 RpcCollection<T::AccountId>,539 // RMRK540 RmrkCollectionInfo<T::AccountId>,541 RmrkInstanceInfo<T::AccountId>,542 RmrkResourceInfo,543 RmrkPropertyInfo,544 RmrkBaseInfo<T::AccountId>,545 RmrkPartType,546 RmrkBoundedTheme,547 RmrkNftChild,548 )>,549 ),550 QueryKind = OptionQuery,551 >;552553 #[pallet::hooks]554 impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {555 fn on_runtime_upgrade() -> Weight {556 StorageVersion::new(1).put::<Pallet<T>>();557558 0559 }560 }561}562563impl<T: Config> Pallet<T> {564 /// Ethereum receiver 0x0000000000000000000000000000000000000000 is reserved, and shouldn't own tokens565 pub fn ensure_correct_receiver(receiver: &T::CrossAccountId) -> DispatchResult {566 ensure!(567 &T::CrossAccountId::from_eth(H160([0; 20])) != receiver,568 <Error<T>>::AddressIsZero569 );570 Ok(())571 }572 pub fn adminlist(collection: CollectionId) -> Vec<T::CrossAccountId> {573 <IsAdmin<T>>::iter_prefix((collection,))574 .map(|(a, _)| a)575 .collect()576 }577 pub fn allowlist(collection: CollectionId) -> Vec<T::CrossAccountId> {578 <Allowlist<T>>::iter_prefix((collection,))579 .map(|(a, _)| a)580 .collect()581 }582 pub fn allowed(collection: CollectionId, user: T::CrossAccountId) -> bool {583 <Allowlist<T>>::get((collection, user))584 }585 pub fn collection_stats() -> CollectionStats {586 let created = <CreatedCollectionCount<T>>::get();587 let destroyed = <DestroyedCollectionCount<T>>::get();588 CollectionStats {589 created: created.0,590 destroyed: destroyed.0,591 alive: created.0 - destroyed.0,592 }593 }594595 pub fn effective_collection_limits(collection: CollectionId) -> Option<CollectionLimits> {596 let collection = <CollectionById<T>>::get(collection);597 if collection.is_none() {598 return None;599 }600601 let collection = collection.unwrap();602 let limits = collection.limits;603 let effective_limits = CollectionLimits {604 account_token_ownership_limit: Some(limits.account_token_ownership_limit()),605 sponsored_data_size: Some(limits.sponsored_data_size()),606 sponsored_data_rate_limit: Some(607 limits608 .sponsored_data_rate_limit609 .unwrap_or(SponsoringRateLimit::SponsoringDisabled),610 ),611 token_limit: Some(limits.token_limit()),612 sponsor_transfer_timeout: Some(limits.sponsor_transfer_timeout(613 match collection.mode {614 CollectionMode::NFT => NFT_SPONSOR_TRANSFER_TIMEOUT,615 CollectionMode::Fungible(_) => FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,616 CollectionMode::ReFungible => REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,617 },618 )),619 sponsor_approve_timeout: Some(limits.sponsor_approve_timeout()),620 owner_can_transfer: Some(limits.owner_can_transfer()),621 owner_can_destroy: Some(limits.owner_can_destroy()),622 transfers_enabled: Some(limits.transfers_enabled()),623 };624625 Some(effective_limits)626 }627628 pub fn rpc_collection(collection: CollectionId) -> Option<RpcCollection<T::AccountId>> {629 let Collection {630 name,631 description,632 owner,633 mode,634 token_prefix,635 sponsorship,636 limits,637 permissions,638 external_collection,639 } = <CollectionById<T>>::get(collection)?;640641 let token_property_permissions = <CollectionPropertyPermissions<T>>::get(collection)642 .into_iter()643 .map(|(key, permission)| PropertyKeyPermission { key, permission })644 .collect();645646 let properties = <CollectionProperties<T>>::get(collection)647 .into_iter()648 .map(|(key, value)| Property { key, value })649 .collect();650651 let permissions = CollectionPermissions {652 access: Some(permissions.access()),653 mint_mode: Some(permissions.mint_mode()),654 nesting: Some(permissions.nesting().clone()),655 };656657 Some(RpcCollection {658 name: name.into_inner(),659 description: description.into_inner(),660 owner,661 mode,662 token_prefix: token_prefix.into_inner(),663 sponsorship,664 limits,665 permissions,666 token_property_permissions,667 properties,668 read_only: external_collection,669 })670 }671}672673macro_rules! limit_default {674 ($old:ident, $new:ident, $($field:ident $(($arg:expr))? => $check:expr),* $(,)?) => {{675 $(676 if let Some($new) = $new.$field {677 let $old = $old.$field($($arg)?);678 let _ = $new;679 let _ = $old;680 $check681 } else {682 $new.$field = $old.$field683 }684 )*685 }};686}687macro_rules! limit_default_clone {688 ($old:ident, $new:ident, $($field:ident $(($arg:expr))? => $check:expr),* $(,)?) => {{689 $(690 if let Some($new) = $new.$field.clone() {691 let $old = $old.$field($($arg)?);692 let _ = $new;693 let _ = $old;694 $check695 } else {696 $new.$field = $old.$field.clone()697 }698 )*699 }};700}701702impl<T: Config> Pallet<T> {703 pub fn init_collection(704 owner: T::CrossAccountId,705 data: CreateCollectionData<T::AccountId>,706 is_external: bool,707 ) -> Result<CollectionId, DispatchError> {708 {709 ensure!(710 data.token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH as usize,711 Error::<T>::CollectionTokenPrefixLimitExceeded712 );713 }714715 let created_count = <CreatedCollectionCount<T>>::get()716 .0717 .checked_add(1)718 .ok_or(ArithmeticError::Overflow)?;719 let destroyed_count = <DestroyedCollectionCount<T>>::get().0;720 let id = CollectionId(created_count);721722 // bound Total number of collections723 ensure!(724 created_count - destroyed_count <= COLLECTION_NUMBER_LIMIT,725 <Error<T>>::TotalCollectionsLimitExceeded726 );727728 // =========729730 let collection = Collection {731 owner: owner.as_sub().clone(),732 name: data.name,733 mode: data.mode.clone(),734 description: data.description,735 token_prefix: data.token_prefix,736 sponsorship: data737 .pending_sponsor738 .map(SponsorshipState::Unconfirmed)739 .unwrap_or_default(),740 limits: data741 .limits742 .map(|limits| Self::clamp_limits(data.mode.clone(), &Default::default(), limits))743 .unwrap_or_else(|| Ok(CollectionLimits::default()))?,744 permissions: data745 .permissions746 .map(|permissions| {747 Self::clamp_permissions(data.mode.clone(), &Default::default(), permissions)748 })749 .unwrap_or_else(|| Ok(CollectionPermissions::default()))?,750 external_collection: is_external,751 };752753 let mut collection_properties = up_data_structs::CollectionProperties::get();754 collection_properties755 .try_set_from_iter(data.properties.into_iter())756 .map_err(<Error<T>>::from)?;757758 CollectionProperties::<T>::insert(id, collection_properties);759760 let mut token_props_permissions = PropertiesPermissionMap::new();761 token_props_permissions762 .try_set_from_iter(data.token_property_permissions.into_iter())763 .map_err(<Error<T>>::from)?;764765 CollectionPropertyPermissions::<T>::insert(id, token_props_permissions);766767 // Take a (non-refundable) deposit of collection creation768 {769 let mut imbalance =770 <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();771 imbalance.subsume(772 <<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(773 &T::TreasuryAccountId::get(),774 T::CollectionCreationPrice::get(),775 ),776 );777 <T as Config>::Currency::settle(778 &owner.as_sub(),779 imbalance,780 WithdrawReasons::TRANSFER,781 ExistenceRequirement::KeepAlive,782 )783 .map_err(|_| Error::<T>::NotSufficientFounds)?;784 }785786 <CreatedCollectionCount<T>>::put(created_count);787 <Pallet<T>>::deposit_event(Event::CollectionCreated(788 id,789 data.mode.id(),790 owner.as_sub().clone(),791 ));792 <PalletEvm<T>>::deposit_log(793 erc::CollectionHelpersEvents::CollectionCreated {794 owner: *owner.as_eth(),795 collection_id: eth::collection_id_to_address(id),796 }797 .to_log(T::ContractAddress::get()),798 );799 <CollectionById<T>>::insert(id, collection);800 Ok(id)801 }802803 pub fn destroy_collection(804 collection: CollectionHandle<T>,805 sender: &T::CrossAccountId,806 ) -> DispatchResult {807 ensure!(808 collection.limits.owner_can_destroy(),809 <Error<T>>::NoPermission,810 );811 collection.check_is_owner(sender)?;812813 let destroyed_collections = <DestroyedCollectionCount<T>>::get()814 .0815 .checked_add(1)816 .ok_or(ArithmeticError::Overflow)?;817818 // =========819820 <DestroyedCollectionCount<T>>::put(destroyed_collections);821 <CollectionById<T>>::remove(collection.id);822 <AdminAmount<T>>::remove(collection.id);823 <IsAdmin<T>>::remove_prefix((collection.id,), None);824 <Allowlist<T>>::remove_prefix((collection.id,), None);825 <CollectionProperties<T>>::remove(collection.id);826827 <Pallet<T>>::deposit_event(Event::CollectionDestroyed(collection.id));828 Ok(())829 }830831 pub fn set_collection_property(832 collection: &CollectionHandle<T>,833 sender: &T::CrossAccountId,834 property: Property,835 ) -> DispatchResult {836 collection.check_is_owner_or_admin(sender)?;837838 CollectionProperties::<T>::try_mutate(collection.id, |properties| {839 let property = property.clone();840 properties.try_set(property.key, property.value)841 })842 .map_err(<Error<T>>::from)?;843844 Self::deposit_event(Event::CollectionPropertySet(collection.id, property.key));845846 Ok(())847 }848849 pub fn set_scoped_collection_property(850 collection_id: CollectionId,851 scope: PropertyScope,852 property: Property,853 ) -> DispatchResult {854 CollectionProperties::<T>::try_mutate(collection_id, |properties| {855 properties.try_scoped_set(scope, property.key, property.value)856 })857 .map_err(<Error<T>>::from)?;858859 Ok(())860 }861862 pub fn set_scoped_collection_properties(863 collection_id: CollectionId,864 scope: PropertyScope,865 properties: impl Iterator<Item = Property>,866 ) -> DispatchResult {867 CollectionProperties::<T>::try_mutate(collection_id, |stored_properties| {868 stored_properties.try_scoped_set_from_iter(scope, properties)869 })870 .map_err(<Error<T>>::from)?;871872 Ok(())873 }874875 #[transactional]876 pub fn set_collection_properties(877 collection: &CollectionHandle<T>,878 sender: &T::CrossAccountId,879 properties: Vec<Property>,880 ) -> DispatchResult {881 for property in properties {882 Self::set_collection_property(collection, sender, property)?;883 }884885 Ok(())886 }887888 pub fn delete_collection_property(889 collection: &CollectionHandle<T>,890 sender: &T::CrossAccountId,891 property_key: PropertyKey,892 ) -> DispatchResult {893 collection.check_is_owner_or_admin(sender)?;894895 CollectionProperties::<T>::try_mutate(collection.id, |properties| {896 properties.remove(&property_key)897 })898 .map_err(<Error<T>>::from)?;899900 Self::deposit_event(Event::CollectionPropertyDeleted(901 collection.id,902 property_key,903 ));904905 Ok(())906 }907908 #[transactional]909 pub fn delete_collection_properties(910 collection: &CollectionHandle<T>,911 sender: &T::CrossAccountId,912 property_keys: Vec<PropertyKey>,913 ) -> DispatchResult {914 for key in property_keys {915 Self::delete_collection_property(collection, sender, key)?;916 }917918 Ok(())919 }920921 // For migrations922 pub fn set_property_permission_unchecked(923 collection: CollectionId,924 property_permission: PropertyKeyPermission,925 ) -> DispatchResult {926 <CollectionPropertyPermissions<T>>::try_mutate(collection, |permissions| {927 permissions.try_set(property_permission.key, property_permission.permission)928 })929 .map_err(<Error<T>>::from)?;930 Ok(())931 }932933 pub fn set_property_permission(934 collection: &CollectionHandle<T>,935 sender: &T::CrossAccountId,936 property_permission: PropertyKeyPermission,937 ) -> DispatchResult {938 collection.check_is_owner_or_admin(sender)?;939940 let all_permissions = CollectionPropertyPermissions::<T>::get(collection.id);941 let current_permission = all_permissions.get(&property_permission.key);942 if matches![943 current_permission,944 Some(PropertyPermission { mutable: false, .. })945 ] {946 return Err(<Error<T>>::NoPermission.into());947 }948949 CollectionPropertyPermissions::<T>::try_mutate(collection.id, |permissions| {950 let property_permission = property_permission.clone();951 permissions.try_set(property_permission.key, property_permission.permission)952 })953 .map_err(<Error<T>>::from)?;954955 Self::deposit_event(Event::PropertyPermissionSet(956 collection.id,957 property_permission.key,958 ));959960 Ok(())961 }962963 #[transactional]964 pub fn set_token_property_permissions(965 collection: &CollectionHandle<T>,966 sender: &T::CrossAccountId,967 property_permissions: Vec<PropertyKeyPermission>,968 ) -> DispatchResult {969 for prop_pemission in property_permissions {970 Self::set_property_permission(collection, sender, prop_pemission)?;971 }972973 Ok(())974 }975976 pub fn get_collection_property(977 collection_id: CollectionId,978 key: &PropertyKey,979 ) -> Option<PropertyValue> {980 Self::collection_properties(collection_id).get(key).cloned()981 }982983 pub fn bytes_keys_to_property_keys(984 keys: Vec<Vec<u8>>,985 ) -> Result<Vec<PropertyKey>, DispatchError> {986 keys.into_iter()987 .map(|key| -> Result<PropertyKey, DispatchError> {988 key.try_into()989 .map_err(|_| <Error<T>>::PropertyKeyIsTooLong.into())990 })991 .collect::<Result<Vec<PropertyKey>, DispatchError>>()992 }993994 pub fn filter_collection_properties(995 collection_id: CollectionId,996 keys: Option<Vec<PropertyKey>>,997 ) -> Result<Vec<Property>, DispatchError> {998 let properties = Self::collection_properties(collection_id);9991000 let properties = keys1001 .map(|keys| {1002 keys.into_iter()1003 .filter_map(|key| {1004 properties.get(&key).map(|value| Property {1005 key,1006 value: value.clone(),1007 })1008 })1009 .collect()1010 })1011 .unwrap_or_else(|| {1012 properties1013 .into_iter()1014 .map(|(key, value)| Property { key, value })1015 .collect()1016 });10171018 Ok(properties)1019 }10201021 pub fn filter_property_permissions(1022 collection_id: CollectionId,1023 keys: Option<Vec<PropertyKey>>,1024 ) -> Result<Vec<PropertyKeyPermission>, DispatchError> {1025 let permissions = Self::property_permissions(collection_id);10261027 let key_permissions = keys1028 .map(|keys| {1029 keys.into_iter()1030 .filter_map(|key| {1031 permissions1032 .get(&key)1033 .map(|permission| PropertyKeyPermission {1034 key,1035 permission: permission.clone(),1036 })1037 })1038 .collect()1039 })1040 .unwrap_or_else(|| {1041 permissions1042 .into_iter()1043 .map(|(key, permission)| PropertyKeyPermission { key, permission })1044 .collect()1045 });10461047 Ok(key_permissions)1048 }10491050 pub fn toggle_allowlist(1051 collection: &CollectionHandle<T>,1052 sender: &T::CrossAccountId,1053 user: &T::CrossAccountId,1054 allowed: bool,1055 ) -> DispatchResult {1056 collection.check_is_owner_or_admin(sender)?;10571058 // =========10591060 if allowed {1061 <Allowlist<T>>::insert((collection.id, user), true);1062 } else {1063 <Allowlist<T>>::remove((collection.id, user));1064 }10651066 Ok(())1067 }10681069 pub fn toggle_admin(1070 collection: &CollectionHandle<T>,1071 sender: &T::CrossAccountId,1072 user: &T::CrossAccountId,1073 admin: bool,1074 ) -> DispatchResult {1075 collection.check_is_owner(sender)?;10761077 let was_admin = <IsAdmin<T>>::get((collection.id, user));1078 if was_admin == admin {1079 return Ok(());1080 }1081 let amount = <AdminAmount<T>>::get(collection.id);10821083 if admin {1084 let amount = amount1085 .checked_add(1)1086 .ok_or(<Error<T>>::CollectionAdminCountExceeded)?;1087 ensure!(1088 amount <= Self::collection_admins_limit(),1089 <Error<T>>::CollectionAdminCountExceeded,1090 );10911092 // =========10931094 <AdminAmount<T>>::insert(collection.id, amount);1095 <IsAdmin<T>>::insert((collection.id, user), true);1096 } else {1097 <AdminAmount<T>>::insert(collection.id, amount.saturating_sub(1));1098 <IsAdmin<T>>::remove((collection.id, user));1099 }11001101 Ok(())1102 }11031104 pub fn clamp_limits(1105 mode: CollectionMode,1106 old_limit: &CollectionLimits,1107 mut new_limit: CollectionLimits,1108 ) -> Result<CollectionLimits, DispatchError> {1109 let limits = old_limit;1110 limit_default!(old_limit, new_limit,1111 account_token_ownership_limit => ensure!(1112 new_limit <= MAX_TOKEN_OWNERSHIP,1113 <Error<T>>::CollectionLimitBoundsExceeded,1114 ),1115 sponsored_data_size => ensure!(1116 new_limit <= CUSTOM_DATA_LIMIT,1117 <Error<T>>::CollectionLimitBoundsExceeded,1118 ),11191120 sponsored_data_rate_limit => {},1121 token_limit => ensure!(1122 old_limit >= new_limit && new_limit > 0,1123 <Error<T>>::CollectionTokenLimitExceeded1124 ),11251126 sponsor_transfer_timeout(match mode {1127 CollectionMode::NFT => NFT_SPONSOR_TRANSFER_TIMEOUT,1128 CollectionMode::Fungible(_) => FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,1129 CollectionMode::ReFungible => REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,1130 }) => ensure!(1131 new_limit <= MAX_SPONSOR_TIMEOUT,1132 <Error<T>>::CollectionLimitBoundsExceeded,1133 ),1134 sponsor_approve_timeout => {},1135 owner_can_transfer => ensure!(1136 !limits.owner_can_transfer_instaled() ||1137 old_limit || !new_limit,1138 <Error<T>>::OwnerPermissionsCantBeReverted,1139 ),1140 owner_can_destroy => ensure!(1141 old_limit || !new_limit,1142 <Error<T>>::OwnerPermissionsCantBeReverted,1143 ),1144 transfers_enabled => {},1145 );1146 Ok(new_limit)1147 }11481149 pub fn clamp_permissions(1150 _mode: CollectionMode,1151 old_limit: &CollectionPermissions,1152 mut new_limit: CollectionPermissions,1153 ) -> Result<CollectionPermissions, DispatchError> {1154 limit_default_clone!(old_limit, new_limit,1155 access => {},1156 mint_mode => {},1157 nesting => { /* todo check for permissive, if only it gets out of benchmarks */ },1158 );1159 Ok(new_limit)1160 }1161}11621163#[macro_export]1164macro_rules! unsupported {1165 () => {1166 Err(<Error<T>>::UnsupportedOperation.into())1167 };1168}11691170/// Worst cases1171pub trait CommonWeightInfo<CrossAccountId> {1172 fn create_item() -> Weight;1173 fn create_multiple_items(amount: &[CreateItemData]) -> Weight;1174 fn create_multiple_items_ex(cost: &CreateItemExData<CrossAccountId>) -> Weight;1175 fn burn_item() -> Weight;1176 fn set_collection_properties(amount: u32) -> Weight;1177 fn delete_collection_properties(amount: u32) -> Weight;1178 fn set_token_properties(amount: u32) -> Weight;1179 fn delete_token_properties(amount: u32) -> Weight;1180 fn set_token_property_permissions(amount: u32) -> Weight;1181 fn transfer() -> Weight;1182 fn approve() -> Weight;1183 fn transfer_from() -> Weight;1184 fn burn_from() -> Weight;11851186 /// Differs from burn_item in case of Fungible and Refungible, as it should burn1187 /// whole users's balance1188 ///1189 /// This method shouldn't be used directly, as it doesn't count breadth price, use `burn_recursively` instead1190 fn burn_recursively_self_raw() -> Weight;1191 /// Cost of iterating over `amount` children while burning, without counting child burning itself1192 ///1193 /// This method shouldn't be used directly, as it doesn't count depth price, use `burn_recursively` instead1194 fn burn_recursively_breadth_raw(amount: u32) -> Weight;11951196 fn burn_recursively(max_selfs: u32, max_breadth: u32) -> Weight {1197 Self::burn_recursively_self_raw()1198 .saturating_mul(max_selfs.max(1) as u64)1199 .saturating_add(Self::burn_recursively_breadth_raw(max_breadth))1200 }1201}12021203pub trait RefungibleExtensionsWeightInfo {1204 fn repartition() -> Weight;1205}12061207pub trait CommonCollectionOperations<T: Config> {1208 fn create_item(1209 &self,1210 sender: T::CrossAccountId,1211 to: T::CrossAccountId,1212 data: CreateItemData,1213 nesting_budget: &dyn Budget,1214 ) -> DispatchResultWithPostInfo;1215 fn create_multiple_items(1216 &self,1217 sender: T::CrossAccountId,1218 to: T::CrossAccountId,1219 data: Vec<CreateItemData>,1220 nesting_budget: &dyn Budget,1221 ) -> DispatchResultWithPostInfo;1222 fn create_multiple_items_ex(1223 &self,1224 sender: T::CrossAccountId,1225 data: CreateItemExData<T::CrossAccountId>,1226 nesting_budget: &dyn Budget,1227 ) -> DispatchResultWithPostInfo;1228 fn burn_item(1229 &self,1230 sender: T::CrossAccountId,1231 token: TokenId,1232 amount: u128,1233 ) -> DispatchResultWithPostInfo;1234 fn burn_item_recursively(1235 &self,1236 sender: T::CrossAccountId,1237 token: TokenId,1238 self_budget: &dyn Budget,1239 breadth_budget: &dyn Budget,1240 ) -> DispatchResultWithPostInfo;1241 fn set_collection_properties(1242 &self,1243 sender: T::CrossAccountId,1244 properties: Vec<Property>,1245 ) -> DispatchResultWithPostInfo;1246 fn delete_collection_properties(1247 &self,1248 sender: &T::CrossAccountId,1249 property_keys: Vec<PropertyKey>,1250 ) -> DispatchResultWithPostInfo;1251 fn set_token_properties(1252 &self,1253 sender: T::CrossAccountId,1254 token_id: TokenId,1255 property: Vec<Property>,1256 nesting_budget: &dyn Budget,1257 ) -> DispatchResultWithPostInfo;1258 fn delete_token_properties(1259 &self,1260 sender: T::CrossAccountId,1261 token_id: TokenId,1262 property_keys: Vec<PropertyKey>,1263 nesting_budget: &dyn Budget,1264 ) -> DispatchResultWithPostInfo;1265 fn set_token_property_permissions(1266 &self,1267 sender: &T::CrossAccountId,1268 property_permissions: Vec<PropertyKeyPermission>,1269 ) -> DispatchResultWithPostInfo;1270 fn transfer(1271 &self,1272 sender: T::CrossAccountId,1273 to: T::CrossAccountId,1274 token: TokenId,1275 amount: u128,1276 nesting_budget: &dyn Budget,1277 ) -> DispatchResultWithPostInfo;1278 fn approve(1279 &self,1280 sender: T::CrossAccountId,1281 spender: T::CrossAccountId,1282 token: TokenId,1283 amount: u128,1284 ) -> DispatchResultWithPostInfo;1285 fn transfer_from(1286 &self,1287 sender: T::CrossAccountId,1288 from: T::CrossAccountId,1289 to: T::CrossAccountId,1290 token: TokenId,1291 amount: u128,1292 nesting_budget: &dyn Budget,1293 ) -> DispatchResultWithPostInfo;1294 fn burn_from(1295 &self,1296 sender: T::CrossAccountId,1297 from: T::CrossAccountId,1298 token: TokenId,1299 amount: u128,1300 nesting_budget: &dyn Budget,1301 ) -> DispatchResultWithPostInfo;13021303 fn check_nesting(1304 &self,1305 sender: T::CrossAccountId,1306 from: (CollectionId, TokenId),1307 under: TokenId,1308 nesting_budget: &dyn Budget,1309 ) -> DispatchResult;13101311 fn nest(&self, under: TokenId, to_nest: (CollectionId, TokenId));13121313 fn unnest(&self, under: TokenId, to_nest: (CollectionId, TokenId));13141315 fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId>;1316 fn collection_tokens(&self) -> Vec<TokenId>;1317 fn token_exists(&self, token: TokenId) -> bool;1318 fn last_token_id(&self) -> TokenId;13191320 fn token_owner(&self, token: TokenId) -> Option<T::CrossAccountId>;1321 fn token_property(&self, token_id: TokenId, key: &PropertyKey) -> Option<PropertyValue>;1322 fn token_properties(&self, token_id: TokenId, keys: Option<Vec<PropertyKey>>) -> Vec<Property>;1323 /// Amount of unique collection tokens1324 fn total_supply(&self) -> u32;1325 /// Amount of different tokens account has (Applicable to nonfungible/refungible)1326 fn account_balance(&self, account: T::CrossAccountId) -> u32;1327 /// Amount of specific token account have (Applicable to fungible/refungible)1328 fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128;1329 fn allowance(1330 &self,1331 sender: T::CrossAccountId,1332 spender: T::CrossAccountId,1333 token: TokenId,1334 ) -> u128;1335 fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>>;1336}13371338pub trait RefungibleExtensions<T>1339where1340 T: Config,1341{1342 fn repartition(1343 &self,1344 owner: &T::CrossAccountId,1345 token: TokenId,1346 amount: u128,1347 ) -> DispatchResultWithPostInfo;1348}13491350// Flexible enough for implementing CommonCollectionOperations1351pub fn with_weight(res: DispatchResult, weight: Weight) -> DispatchResultWithPostInfo {1352 let post_info = PostDispatchInfo {1353 actual_weight: Some(weight),1354 pays_fee: Pays::Yes,1355 };1356 match res {1357 Ok(()) => Ok(post_info),1358 Err(error) => Err(DispatchErrorWithPostInfo { post_info, error }),1359 }1360}13611362impl<T: Config> From<PropertiesError> for Error<T> {1363 fn from(error: PropertiesError) -> Self {1364 match error {1365 PropertiesError::NoSpaceForProperty => Self::NoSpaceForProperty,1366 PropertiesError::PropertyLimitReached => Self::PropertyLimitReached,1367 PropertiesError::InvalidCharacterInPropertyKey => Self::InvalidCharacterInPropertyKey,1368 PropertiesError::PropertyKeyIsTooLong => Self::PropertyKeyIsTooLong,1369 PropertiesError::EmptyPropertyKey => Self::EmptyPropertyKey,1370 }1371 }1372}