difftreelog
cargo fmt
in: master
1 file changed
pallets/nonfungible/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 erc::ERC721Events;20use evm_coder::ToLog;21use frame_support::{22 BoundedVec, ensure, fail, transactional,23 storage::with_transaction,24 pallet_prelude::DispatchResultWithPostInfo,25 pallet_prelude::Weight,26 weights::{PostDispatchInfo, Pays},27};28use up_data_structs::{29 AccessMode, CollectionId, CustomDataLimit, TokenId, CreateCollectionData, CreateNftExData,30 mapping::TokenAddressMapping, budget::Budget, Property, PropertyPermission, PropertyKey,31 PropertyKeyPermission, Properties, PropertyScope, TrySetProperty, TokenChild, AuxPropertyValue,32};33use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};34use pallet_common::{35 Error as CommonError, Pallet as PalletCommon, Event as CommonEvent, CollectionHandle,36 eth::collection_id_to_address,37};38use pallet_structure::{Pallet as PalletStructure, Error as StructureError};39use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};40use sp_core::H160;41use sp_runtime::{ArithmeticError, DispatchError, DispatchResult, TransactionOutcome};42use sp_std::{vec::Vec, vec, collections::btree_map::BTreeMap, collections::btree_set::BTreeSet};43use core::ops::Deref;44use codec::{Encode, Decode, MaxEncodedLen};45use scale_info::TypeInfo;4647pub use pallet::*;48use weights::WeightInfo;49#[cfg(feature = "runtime-benchmarks")]50pub mod benchmarking;51pub mod common;52pub mod erc;53pub mod weights;5455pub type CreateItemData<T> = CreateNftExData<<T as pallet_evm::account::Config>::CrossAccountId>;56pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;5758#[struct_versioning::versioned(version = 2, upper)]59#[derive(Encode, Decode, TypeInfo, MaxEncodedLen)]60pub struct ItemData<CrossAccountId> {61 #[version(..2)]62 pub const_data: BoundedVec<u8, CustomDataLimit>,6364 #[version(..2)]65 pub variable_data: BoundedVec<u8, CustomDataLimit>,6667 pub owner: CrossAccountId,68}6970#[frame_support::pallet]71pub mod pallet {72 use super::*;73 use frame_support::{74 Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key, traits::StorageVersion,75 };76 use frame_system::pallet_prelude::*;77 use up_data_structs::{CollectionId, TokenId};78 use super::weights::WeightInfo;7980 #[pallet::error]81 pub enum Error<T> {82 /// Not Nonfungible item data used to mint in Nonfungible collection.83 NotNonfungibleDataUsedToMintFungibleCollectionToken,84 /// Used amount > 1 with NFT85 NonfungibleItemsHaveNoAmount,86 /// Unable to burn NFT with children87 CantBurnNftWithChildren,88 }8990 #[pallet::config]91 pub trait Config:92 frame_system::Config + pallet_common::Config + pallet_structure::Config + pallet_evm::Config93 {94 type WeightInfo: WeightInfo;95 }9697 const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);9899 #[pallet::pallet]100 #[pallet::storage_version(STORAGE_VERSION)]101 #[pallet::generate_store(pub(super) trait Store)]102 pub struct Pallet<T>(_);103104 #[pallet::storage]105 pub type TokensMinted<T: Config> =106 StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;107 #[pallet::storage]108 pub type TokensBurnt<T: Config> =109 StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;110111 #[pallet::storage]112 pub type TokenData<T: Config> = StorageNMap<113 Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),114 Value = ItemData<T::CrossAccountId>,115 QueryKind = OptionQuery,116 >;117118 #[pallet::storage]119 #[pallet::getter(fn token_properties)]120 pub type TokenProperties<T: Config> = StorageNMap<121 Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),122 Value = Properties,123 QueryKind = ValueQuery,124 OnEmpty = up_data_structs::TokenProperties,125 >;126127 #[pallet::storage]128 #[pallet::getter(fn token_aux_property)]129 pub type TokenAuxProperties<T: Config> = StorageNMap<130 Key = (131 Key<Twox64Concat, CollectionId>,132 Key<Twox64Concat, TokenId>,133 Key<Twox64Concat, PropertyScope>,134 Key<Twox64Concat, PropertyKey>,135 ),136 Value = AuxPropertyValue,137 QueryKind = OptionQuery,138 >;139140 /// Used to enumerate tokens owned by account141 #[pallet::storage]142 pub type Owned<T: Config> = StorageNMap<143 Key = (144 Key<Twox64Concat, CollectionId>,145 Key<Blake2_128Concat, T::CrossAccountId>,146 Key<Twox64Concat, TokenId>,147 ),148 Value = bool,149 QueryKind = ValueQuery,150 >;151152 /// Used to enumerate token's children153 #[pallet::storage]154 #[pallet::getter(fn token_children)]155 pub type TokenChildren<T: Config> = StorageNMap<156 Key = (157 Key<Twox64Concat, CollectionId>,158 Key<Twox64Concat, TokenId>,159 Key<Twox64Concat, (CollectionId, TokenId)>,160 ),161 Value = bool,162 QueryKind = ValueQuery,163 >;164165 #[pallet::storage]166 pub type AccountBalance<T: Config> = StorageNMap<167 Key = (168 Key<Twox64Concat, CollectionId>,169 Key<Blake2_128Concat, T::CrossAccountId>,170 ),171 Value = u32,172 QueryKind = ValueQuery,173 >;174175 #[pallet::storage]176 pub type Allowance<T: Config> = StorageNMap<177 Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),178 Value = T::CrossAccountId,179 QueryKind = OptionQuery,180 >;181182 #[pallet::hooks]183 impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {184 fn on_runtime_upgrade() -> Weight {185 if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {186 let mut had_consts = BTreeSet::new();187 <TokenData<T>>::translate::<ItemDataVersion1<T::CrossAccountId>, _>(188 |(collection, token), v| {189 let mut props = vec![];190 if !v.const_data.is_empty() {191 props.push(Property {192 key: b"_old_constData".to_vec().try_into().unwrap(),193 value: v194 .const_data195 .clone()196 .into_inner()197 .try_into()198 .expect("const too long"),199 });200 had_consts.insert(collection);201 }202 if !v.variable_data.is_empty() {203 props.push(Property {204 key: b"_old_variableData".to_vec().try_into().unwrap(),205 value: v206 .variable_data207 .clone()208 .into_inner()209 .try_into()210 .expect("variable too long"),211 })212 }213 if !props.is_empty() {214 Self::set_scoped_token_properties(215 collection,216 token,217 PropertyScope::None,218 props.into_iter(),219 )220 .expect("existing token data exceeds property storage");221 }222 Some(<ItemDataVersion2<T::CrossAccountId>>::from(v))223 },224 );225 for collection in had_consts {226 <PalletCommon<T>>::set_property_permission_unchecked(227 collection,228 PropertyKeyPermission {229 key: b"_old_constData".to_vec().try_into().unwrap(),230 permission: PropertyPermission {231 mutable: false,232 collection_admin: true,233 token_owner: false,234 },235 },236 )237 .expect("failed to configure permission");238 }239 }240241 0242 }243 }244}245246pub struct NonfungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);247impl<T: Config> NonfungibleHandle<T> {248 pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {249 Self(inner)250 }251 pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {252 self.0253 }254 pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {255 &mut self.0256 }257}258impl<T: Config> WithRecorder<T> for NonfungibleHandle<T> {259 fn recorder(&self) -> &SubstrateRecorder<T> {260 self.0.recorder()261 }262 fn into_recorder(self) -> SubstrateRecorder<T> {263 self.0.into_recorder()264 }265}266impl<T: Config> Deref for NonfungibleHandle<T> {267 type Target = pallet_common::CollectionHandle<T>;268269 fn deref(&self) -> &Self::Target {270 &self.0271 }272}273274impl<T: Config> Pallet<T> {275 pub fn total_supply(collection: &NonfungibleHandle<T>) -> u32 {276 <TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)277 }278 pub fn token_exists(collection: &NonfungibleHandle<T>, token: TokenId) -> bool {279 <TokenData<T>>::contains_key((collection.id, token))280 }281282 pub fn set_scoped_token_property(283 collection_id: CollectionId,284 token_id: TokenId,285 scope: PropertyScope,286 property: Property,287 ) -> DispatchResult {288 TokenProperties::<T>::try_mutate((collection_id, token_id), |properties| {289 properties.try_scoped_set(scope, property.key, property.value)290 })291 .map_err(<CommonError<T>>::from)?;292293 Ok(())294 }295296 pub fn set_scoped_token_properties(297 collection_id: CollectionId,298 token_id: TokenId,299 scope: PropertyScope,300 properties: impl Iterator<Item = Property>,301 ) -> DispatchResult {302 TokenProperties::<T>::try_mutate((collection_id, token_id), |stored_properties| {303 stored_properties.try_scoped_set_from_iter(scope, properties)304 })305 .map_err(<CommonError<T>>::from)?;306307 Ok(())308 }309310 pub fn try_mutate_token_aux_property<R, E>(311 collection_id: CollectionId,312 token_id: TokenId,313 scope: PropertyScope,314 key: PropertyKey,315 f: impl FnOnce(&mut Option<AuxPropertyValue>) -> Result<R, E>,316 ) -> Result<R, E> {317 <TokenAuxProperties<T>>::try_mutate((collection_id, token_id, scope, key), f)318 }319320 pub fn remove_token_aux_property(321 collection_id: CollectionId,322 token_id: TokenId,323 scope: PropertyScope,324 key: PropertyKey,325 ) {326 <TokenAuxProperties<T>>::remove((collection_id, token_id, scope, key));327 }328329 pub fn iterate_token_aux_properties(330 collection_id: CollectionId,331 token_id: TokenId,332 scope: PropertyScope,333 ) -> impl Iterator<Item = (PropertyKey, AuxPropertyValue)> {334 <TokenAuxProperties<T>>::iter_prefix((collection_id, token_id, scope))335 }336337 pub fn current_token_id(collection_id: CollectionId) -> TokenId {338 TokenId(<TokensMinted<T>>::get(collection_id))339 }340}341342// unchecked calls skips any permission checks343impl<T: Config> Pallet<T> {344 pub fn init_collection(345 owner: T::CrossAccountId,346 data: CreateCollectionData<T::AccountId>,347 is_external: bool,348 ) -> Result<CollectionId, DispatchError> {349 <PalletCommon<T>>::init_collection(owner, data, is_external)350 }351 pub fn destroy_collection(352 collection: NonfungibleHandle<T>,353 sender: &T::CrossAccountId,354 ) -> DispatchResult {355 let id = collection.id;356357 if Self::collection_has_tokens(id) {358 return Err(<CommonError<T>>::CantDestroyNotEmptyCollection.into());359 }360361 // =========362363 PalletCommon::destroy_collection(collection.0, sender)?;364365 <TokenData<T>>::remove_prefix((id,), None);366 <TokenChildren<T>>::remove_prefix((id,), None);367 <Owned<T>>::remove_prefix((id,), None);368 <TokensMinted<T>>::remove(id);369 <TokensBurnt<T>>::remove(id);370 <Allowance<T>>::remove_prefix((id,), None);371 <AccountBalance<T>>::remove_prefix((id,), None);372 Ok(())373 }374375 pub fn burn(376 collection: &NonfungibleHandle<T>,377 sender: &T::CrossAccountId,378 token: TokenId,379 ) -> DispatchResult {380 let token_data =381 <TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;382 ensure!(383 &token_data.owner == sender,384 <CommonError<T>>::NoPermission385 );386387 if collection.permissions.access() == AccessMode::AllowList {388 collection.check_allowlist(sender)?;389 }390391 if Self::token_has_children(collection.id, token) {392 return Err(<Error<T>>::CantBurnNftWithChildren.into());393 }394395 let burnt = <TokensBurnt<T>>::get(collection.id)396 .checked_add(1)397 .ok_or(ArithmeticError::Overflow)?;398399 let balance = <AccountBalance<T>>::get((collection.id, token_data.owner.clone()))400 .checked_sub(1)401 .ok_or(ArithmeticError::Overflow)?;402403 // =========404405 if balance == 0 {406 <AccountBalance<T>>::remove((collection.id, token_data.owner.clone()));407 } else {408 <AccountBalance<T>>::insert((collection.id, token_data.owner.clone()), balance);409 }410411 <PalletStructure<T>>::unnest_if_nested(&token_data.owner, collection.id, token);412413 <Owned<T>>::remove((collection.id, &token_data.owner, token));414 <TokensBurnt<T>>::insert(collection.id, burnt);415 <TokenData<T>>::remove((collection.id, token));416 <TokenProperties<T>>::remove((collection.id, token));417 <TokenAuxProperties<T>>::remove_prefix((collection.id, token), None);418 let old_spender = <Allowance<T>>::take((collection.id, token));419420 if let Some(old_spender) = old_spender {421 <PalletCommon<T>>::deposit_event(CommonEvent::Approved(422 collection.id,423 token,424 token_data.owner.clone(),425 old_spender,426 0,427 ));428 }429430 <PalletEvm<T>>::deposit_log(431 ERC721Events::Transfer {432 from: *token_data.owner.as_eth(),433 to: H160::default(),434 token_id: token.into(),435 }436 .to_log(collection_id_to_address(collection.id)),437 );438 <PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(439 collection.id,440 token,441 token_data.owner,442 1,443 ));444 Ok(())445 }446447 #[transactional]448 pub fn burn_recursively(449 collection: &NonfungibleHandle<T>,450 sender: &T::CrossAccountId,451 token: TokenId,452 self_budget: &dyn Budget,453 breadth_budget: &dyn Budget,454 ) -> DispatchResultWithPostInfo {455 ensure!(self_budget.consume(), <StructureError<T>>::DepthLimit,);456457 let current_token_account =458 T::CrossTokenAddressMapping::token_to_address(collection.id, token);459460 let mut weight = 0 as Weight;461462 // This method is transactional, if user in fact doesn't have permissions to remove token -463 // tokens removed here will be restored after rejected transaction464 for ((collection, token), _) in <TokenChildren<T>>::iter_prefix((collection.id, token)) {465 ensure!(breadth_budget.consume(), <StructureError<T>>::BreadthLimit,);466 let PostDispatchInfo { actual_weight, .. } =467 <PalletStructure<T>>::burn_item_recursively(468 current_token_account.clone(),469 collection,470 token,471 self_budget,472 breadth_budget,473 )?;474 if let Some(actual_weight) = actual_weight {475 weight = weight.saturating_add(actual_weight);476 }477 }478479 Self::burn(collection, sender, token)?;480 DispatchResultWithPostInfo::Ok(PostDispatchInfo {481 actual_weight: Some(weight + <SelfWeightOf<T>>::burn_item()),482 pays_fee: Pays::Yes,483 })484 }485486 pub fn set_token_property(487 collection: &NonfungibleHandle<T>,488 sender: &T::CrossAccountId,489 token_id: TokenId,490 property: Property,491 is_token_create: bool,492 ) -> DispatchResult {493 Self::check_token_change_permission(494 collection,495 sender,496 token_id,497 &property.key,498 is_token_create,499 )?;500501 <TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {502 let property = property.clone();503 properties.try_set(property.key, property.value)504 })505 .map_err(<CommonError<T>>::from)?;506507 <PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertySet(508 collection.id,509 token_id,510 property.key,511 ));512513 Ok(())514 }515516 #[transactional]517 pub fn set_token_properties(518 collection: &NonfungibleHandle<T>,519 sender: &T::CrossAccountId,520 token_id: TokenId,521 properties: Vec<Property>,522 is_token_create: bool,523 ) -> DispatchResult {524 for property in properties {525 Self::set_token_property(collection, sender, token_id, property, is_token_create)?;526 }527528 Ok(())529 }530531 pub fn delete_token_property(532 collection: &NonfungibleHandle<T>,533 sender: &T::CrossAccountId,534 token_id: TokenId,535 property_key: PropertyKey,536 ) -> DispatchResult {537 Self::check_token_change_permission(collection, sender, token_id, &property_key, false)?;538539 <TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {540 properties.remove(&property_key)541 })542 .map_err(<CommonError<T>>::from)?;543544 <PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(545 collection.id,546 token_id,547 property_key,548 ));549550 Ok(())551 }552553 fn check_token_change_permission(554 collection: &NonfungibleHandle<T>,555 sender: &T::CrossAccountId,556 token_id: TokenId,557 property_key: &PropertyKey,558 is_token_create: bool,559 ) -> DispatchResult {560 let permission = <PalletCommon<T>>::property_permissions(collection.id)561 .get(property_key)562 .cloned()563 .unwrap_or_else(PropertyPermission::none);564565 let token_data = <TokenData<T>>::get((collection.id, token_id))566 .ok_or(<CommonError<T>>::TokenNotFound)?;567568 let check_token_owner = || -> DispatchResult {569 ensure!(&token_data.owner == sender, <CommonError<T>>::NoPermission);570 Ok(())571 };572573 let is_property_exists = TokenProperties::<T>::get((collection.id, token_id))574 .get(property_key)575 .is_some();576577 match permission {578 PropertyPermission { mutable: false, .. } if is_property_exists => {579 Err(<CommonError<T>>::NoPermission.into())580 }581582 PropertyPermission {583 collection_admin,584 token_owner,585 ..586 } => {587 //TODO: investigate threats during public minting.588 if is_token_create && (collection_admin || token_owner) {589 return Ok(());590 }591592 let mut check_result = Err(<CommonError<T>>::NoPermission.into());593594 if collection_admin {595 check_result = collection.check_is_owner_or_admin(sender);596 }597598 if token_owner {599 check_result.or_else(|_| check_token_owner())600 } else {601 check_result602 }603 }604 }605 }606607 #[transactional]608 pub fn delete_token_properties(609 collection: &NonfungibleHandle<T>,610 sender: &T::CrossAccountId,611 token_id: TokenId,612 property_keys: Vec<PropertyKey>,613 ) -> DispatchResult {614 for key in property_keys {615 Self::delete_token_property(collection, sender, token_id, key)?;616 }617618 Ok(())619 }620621 pub fn set_collection_properties(622 collection: &NonfungibleHandle<T>,623 sender: &T::CrossAccountId,624 properties: Vec<Property>,625 ) -> DispatchResult {626 <PalletCommon<T>>::set_collection_properties(collection, sender, properties)627 }628629 pub fn delete_collection_properties(630 collection: &CollectionHandle<T>,631 sender: &T::CrossAccountId,632 property_keys: Vec<PropertyKey>,633 ) -> DispatchResult {634 <PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)635 }636637 pub fn set_token_property_permissions(638 collection: &CollectionHandle<T>,639 sender: &T::CrossAccountId,640 property_permissions: Vec<PropertyKeyPermission>,641 ) -> DispatchResult {642 <PalletCommon<T>>::set_token_property_permissions(collection, sender, property_permissions)643 }644645 pub fn set_property_permission(646 collection: &CollectionHandle<T>,647 sender: &T::CrossAccountId,648 permission: PropertyKeyPermission,649 ) -> DispatchResult {650 <PalletCommon<T>>::set_property_permission(collection, sender, permission)651 }652653 pub fn transfer(654 collection: &NonfungibleHandle<T>,655 from: &T::CrossAccountId,656 to: &T::CrossAccountId,657 token: TokenId,658 nesting_budget: &dyn Budget,659 ) -> DispatchResult {660 ensure!(661 collection.limits.transfers_enabled(),662 <CommonError<T>>::TransferNotAllowed663 );664665 let token_data =666 <TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;667 ensure!(668 &token_data.owner == from,669 <CommonError<T>>::NoPermission670 );671672 if collection.permissions.access() == AccessMode::AllowList {673 collection.check_allowlist(from)?;674 collection.check_allowlist(to)?;675 }676 <PalletCommon<T>>::ensure_correct_receiver(to)?;677678 let balance_from = <AccountBalance<T>>::get((collection.id, from))679 .checked_sub(1)680 .ok_or(<CommonError<T>>::TokenValueTooLow)?;681 let balance_to = if from != to {682 let balance_to = <AccountBalance<T>>::get((collection.id, to))683 .checked_add(1)684 .ok_or(ArithmeticError::Overflow)?;685686 ensure!(687 balance_to < collection.limits.account_token_ownership_limit(),688 <CommonError<T>>::AccountTokenLimitExceeded,689 );690691 Some(balance_to)692 } else {693 None694 };695696 <PalletStructure<T>>::nest_if_sent_to_token(697 from.clone(),698 to,699 collection.id,700 token,701 nesting_budget,702 )?;703704 // =========705706 <PalletStructure<T>>::unnest_if_nested(&token_data.owner, collection.id, token);707708 <TokenData<T>>::insert(709 (collection.id, token),710 ItemData {711 owner: to.clone(),712 ..token_data713 },714 );715716 if let Some(balance_to) = balance_to {717 // from != to718 if balance_from == 0 {719 <AccountBalance<T>>::remove((collection.id, from));720 } else {721 <AccountBalance<T>>::insert((collection.id, from), balance_from);722 }723 <AccountBalance<T>>::insert((collection.id, to), balance_to);724 <Owned<T>>::remove((collection.id, from, token));725 <Owned<T>>::insert((collection.id, to, token), true);726 }727 Self::set_allowance_unchecked(collection, from, token, None, true);728729 <PalletEvm<T>>::deposit_log(730 ERC721Events::Transfer {731 from: *from.as_eth(),732 to: *to.as_eth(),733 token_id: token.into(),734 }735 .to_log(collection_id_to_address(collection.id)),736 );737 <PalletCommon<T>>::deposit_event(CommonEvent::Transfer(738 collection.id,739 token,740 from.clone(),741 to.clone(),742 1,743 ));744 Ok(())745 }746747 pub fn create_multiple_items(748 collection: &NonfungibleHandle<T>,749 sender: &T::CrossAccountId,750 data: Vec<CreateItemData<T>>,751 nesting_budget: &dyn Budget,752 ) -> DispatchResult {753 if !collection.is_owner_or_admin(sender) {754 ensure!(755 collection.permissions.mint_mode(),756 <CommonError<T>>::PublicMintingNotAllowed757 );758 collection.check_allowlist(sender)?;759760 for item in data.iter() {761 collection.check_allowlist(&item.owner)?;762 }763 }764765 for data in data.iter() {766 <PalletCommon<T>>::ensure_correct_receiver(&data.owner)?;767 }768769 let first_token = <TokensMinted<T>>::get(collection.id);770 let tokens_minted = first_token771 .checked_add(data.len() as u32)772 .ok_or(ArithmeticError::Overflow)?;773 ensure!(774 tokens_minted <= collection.limits.token_limit(),775 <CommonError<T>>::CollectionTokenLimitExceeded776 );777778 let mut balances = BTreeMap::new();779 for data in &data {780 let balance = balances781 .entry(&data.owner)782 .or_insert_with(|| <AccountBalance<T>>::get((collection.id, &data.owner)));783 *balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;784785 ensure!(786 *balance <= collection.limits.account_token_ownership_limit(),787 <CommonError<T>>::AccountTokenLimitExceeded,788 );789 }790791 for (i, data) in data.iter().enumerate() {792 let token = TokenId(first_token + i as u32 + 1);793794 <PalletStructure<T>>::check_nesting(795 sender.clone(),796 &data.owner,797 collection.id,798 token,799 nesting_budget,800 )?;801 }802803 // =========804805 with_transaction(|| {806 for (i, data) in data.iter().enumerate() {807 let token = first_token + i as u32 + 1;808809 <TokenData<T>>::insert(810 (collection.id, token),811 ItemData {812 // const_data: data.const_data.clone(),813 owner: data.owner.clone(),814 },815 );816817 <PalletStructure<T>>::nest_if_sent_to_token_unchecked(818 &data.owner,819 collection.id,820 TokenId(token),821 );822823 if let Err(e) = Self::set_token_properties(824 collection,825 sender,826 TokenId(token),827 data.properties.clone().into_inner(),828 true,829 ) {830 return TransactionOutcome::Rollback(Err(e));831 }832 }833 TransactionOutcome::Commit(Ok(()))834 })?;835836 <TokensMinted<T>>::insert(collection.id, tokens_minted);837 for (account, balance) in balances {838 <AccountBalance<T>>::insert((collection.id, account), balance);839 }840 for (i, data) in data.into_iter().enumerate() {841 let token = first_token + i as u32 + 1;842 <Owned<T>>::insert((collection.id, &data.owner, token), true);843844 <PalletEvm<T>>::deposit_log(845 ERC721Events::Transfer {846 from: H160::default(),847 to: *data.owner.as_eth(),848 token_id: token.into(),849 }850 .to_log(collection_id_to_address(collection.id)),851 );852 <PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(853 collection.id,854 TokenId(token),855 data.owner.clone(),856 1,857 ));858 }859 Ok(())860 }861862 pub fn set_allowance_unchecked(863 collection: &NonfungibleHandle<T>,864 sender: &T::CrossAccountId,865 token: TokenId,866 spender: Option<&T::CrossAccountId>,867 assume_implicit_eth: bool,868 ) {869 if let Some(spender) = spender {870 let old_spender = <Allowance<T>>::get((collection.id, token));871 <Allowance<T>>::insert((collection.id, token), spender);872 // In ERC721 there is only one possible approved user of token, so we set873 // approved user to spender874 <PalletEvm<T>>::deposit_log(875 ERC721Events::Approval {876 owner: *sender.as_eth(),877 approved: *spender.as_eth(),878 token_id: token.into(),879 }880 .to_log(collection_id_to_address(collection.id)),881 );882 // In Unique chain, any token can have any amount of approved users, so we need to883 // set allowance of old owner to 0, and allowance of new owner to 1884 if old_spender.as_ref() != Some(spender) {885 if let Some(old_owner) = old_spender {886 <PalletCommon<T>>::deposit_event(CommonEvent::Approved(887 collection.id,888 token,889 sender.clone(),890 old_owner,891 0,892 ));893 }894 <PalletCommon<T>>::deposit_event(CommonEvent::Approved(895 collection.id,896 token,897 sender.clone(),898 spender.clone(),899 1,900 ));901 }902 } else {903 let old_spender = <Allowance<T>>::take((collection.id, token));904 if !assume_implicit_eth {905 // In ERC721 there is only one possible approved user of token, so we set906 // approved user to zero address907 <PalletEvm<T>>::deposit_log(908 ERC721Events::Approval {909 owner: *sender.as_eth(),910 approved: H160::default(),911 token_id: token.into(),912 }913 .to_log(collection_id_to_address(collection.id)),914 );915 }916 // In Unique chain, any token can have any amount of approved users, so we need to917 // set allowance of old owner to 0918 if let Some(old_spender) = old_spender {919 <PalletCommon<T>>::deposit_event(CommonEvent::Approved(920 collection.id,921 token,922 sender.clone(),923 old_spender,924 0,925 ));926 }927 }928 }929930 pub fn set_allowance(931 collection: &NonfungibleHandle<T>,932 sender: &T::CrossAccountId,933 token: TokenId,934 spender: Option<&T::CrossAccountId>,935 ) -> DispatchResult {936 if collection.permissions.access() == AccessMode::AllowList {937 collection.check_allowlist(sender)?;938 if let Some(spender) = spender {939 collection.check_allowlist(spender)?;940 }941 }942943 if let Some(spender) = spender {944 <PalletCommon<T>>::ensure_correct_receiver(spender)?;945 }946947 let token_data =948 <TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;949 if &token_data.owner != sender {950 ensure!(951 collection.ignores_owned_amount(sender),952 <CommonError<T>>::CantApproveMoreThanOwned953 );954 }955956 // =========957958 Self::set_allowance_unchecked(collection, sender, token, spender, false);959 Ok(())960 }961962 fn check_allowed(963 collection: &NonfungibleHandle<T>,964 spender: &T::CrossAccountId,965 from: &T::CrossAccountId,966 token: TokenId,967 nesting_budget: &dyn Budget,968 ) -> DispatchResult {969 if spender.conv_eq(from) {970 return Ok(());971 }972 if collection.permissions.access() == AccessMode::AllowList {973 // `from`, `to` checked in [`transfer`]974 collection.check_allowlist(spender)?;975 }976977 if collection.limits.owner_can_transfer() && collection.is_owner_or_admin(spender) {978 return Ok(());979 }980981 if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {982 ensure!(983 <PalletStructure<T>>::check_indirectly_owned(984 spender.clone(),985 source.0,986 source.1,987 None,988 nesting_budget989 )?,990 <CommonError<T>>::ApprovedValueTooLow,991 );992 return Ok(());993 }994 if <Allowance<T>>::get((collection.id, token)).as_ref() == Some(spender) {995 return Ok(());996 }997 ensure!(998 collection.ignores_allowance(spender),999 <CommonError<T>>::ApprovedValueTooLow1000 );1001 Ok(())1002 }10031004 pub fn transfer_from(1005 collection: &NonfungibleHandle<T>,1006 spender: &T::CrossAccountId,1007 from: &T::CrossAccountId,1008 to: &T::CrossAccountId,1009 token: TokenId,1010 nesting_budget: &dyn Budget,1011 ) -> DispatchResult {1012 Self::check_allowed(collection, spender, from, token, nesting_budget)?;10131014 // =========10151016 // Allowance is reset in [`transfer`]1017 Self::transfer(collection, from, to, token, nesting_budget)1018 }10191020 pub fn burn_from(1021 collection: &NonfungibleHandle<T>,1022 spender: &T::CrossAccountId,1023 from: &T::CrossAccountId,1024 token: TokenId,1025 nesting_budget: &dyn Budget,1026 ) -> DispatchResult {1027 Self::check_allowed(collection, spender, from, token, nesting_budget)?;10281029 // =========10301031 Self::burn(collection, from, token)1032 }10331034 pub fn check_nesting(1035 handle: &NonfungibleHandle<T>,1036 sender: T::CrossAccountId,1037 from: (CollectionId, TokenId),1038 under: TokenId,1039 nesting_budget: &dyn Budget,1040 ) -> DispatchResult {1041 let nesting = handle.permissions.nesting();10421043 #[cfg(not(feature = "runtime-benchmarks"))]1044 let permissive = false;1045 #[cfg(feature = "runtime-benchmarks")]1046 let permissive = nesting.permissive;10471048 if permissive {1049 // Pass1050 } else if nesting.token_owner1051 && <PalletStructure<T>>::check_indirectly_owned(1052 sender.clone(),1053 handle.id,1054 under,1055 Some(from),1056 nesting_budget,1057 )? {1058 // Pass1059 } else if nesting.collection_admin && handle.is_owner_or_admin(&sender) {1060 // Pass1061 } else {1062 fail!(<CommonError<T>>::UserIsNotAllowedToNest);1063 }10641065 if let Some(whitelist) = &nesting.restricted {1066 ensure!(1067 whitelist.contains(&from.0),1068 <CommonError<T>>::SourceCollectionIsNotAllowedToNest1069 );1070 }1071 Ok(())1072 }10731074 fn nest(under: (CollectionId, TokenId), to_nest: (CollectionId, TokenId)) {1075 <TokenChildren<T>>::insert((under.0, under.1, (to_nest.0, to_nest.1)), true);1076 }10771078 fn unnest(under: (CollectionId, TokenId), to_unnest: (CollectionId, TokenId)) {1079 <TokenChildren<T>>::remove((under.0, under.1, to_unnest));1080 }10811082 fn collection_has_tokens(collection_id: CollectionId) -> bool {1083 <TokenData<T>>::iter_prefix((collection_id,))1084 .next()1085 .is_some()1086 }10871088 fn token_has_children(collection_id: CollectionId, token_id: TokenId) -> bool {1089 <TokenChildren<T>>::iter_prefix((collection_id, token_id))1090 .next()1091 .is_some()1092 }10931094 pub fn token_children_ids(collection_id: CollectionId, token_id: TokenId) -> Vec<TokenChild> {1095 <TokenChildren<T>>::iter_prefix((collection_id, token_id))1096 .map(|((child_collection_id, child_id), _)| TokenChild {1097 collection: child_collection_id,1098 token: child_id,1099 })1100 .collect()1101 }11021103 /// Delegated to `create_multiple_items`1104 pub fn create_item(1105 collection: &NonfungibleHandle<T>,1106 sender: &T::CrossAccountId,1107 data: CreateItemData<T>,1108 nesting_budget: &dyn Budget,1109 ) -> DispatchResult {1110 Self::create_multiple_items(collection, sender, vec![data], nesting_budget)1111 }1112}