difftreelog
CORE-386 Fix lang
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, NestingRule, budget::Budget, Property, PropertyPermission,31 PropertyKey, PropertyKeyPermission, Properties, PropertyScope, TrySetProperty, TokenChild,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 /// Used to enumerate tokens owned by account128 #[pallet::storage]129 pub type Owned<T: Config> = StorageNMap<130 Key = (131 Key<Twox64Concat, CollectionId>,132 Key<Blake2_128Concat, T::CrossAccountId>,133 Key<Twox64Concat, TokenId>,134 ),135 Value = bool,136 QueryKind = ValueQuery,137 >;138139 /// Used to enumerate token's children140 #[pallet::storage]141 #[pallet::getter(fn token_children)]142 pub type TokenChildren<T: Config> = StorageNMap<143 Key = (144 Key<Twox64Concat, CollectionId>,145 Key<Twox64Concat, TokenId>,146 Key<Twox64Concat, (CollectionId, TokenId)>,147 ),148 Value = bool,149 QueryKind = ValueQuery,150 >;151152 #[pallet::storage]153 pub type AccountBalance<T: Config> = StorageNMap<154 Key = (155 Key<Twox64Concat, CollectionId>,156 Key<Blake2_128Concat, T::CrossAccountId>,157 ),158 Value = u32,159 QueryKind = ValueQuery,160 >;161162 #[pallet::storage]163 pub type Allowance<T: Config> = StorageNMap<164 Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),165 Value = T::CrossAccountId,166 QueryKind = OptionQuery,167 >;168169 #[pallet::hooks]170 impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {171 fn on_runtime_upgrade() -> Weight {172 if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {173 let mut had_consts = BTreeSet::new();174 <TokenData<T>>::translate::<ItemDataVersion1<T::CrossAccountId>, _>(175 |(collection, token), v| {176 let mut props = vec![];177 if !v.const_data.is_empty() {178 props.push(Property {179 key: b"_old_constData".to_vec().try_into().unwrap(),180 value: v181 .const_data182 .clone()183 .into_inner()184 .try_into()185 .expect("const too long"),186 });187 had_consts.insert(collection);188 }189 if !v.variable_data.is_empty() {190 props.push(Property {191 key: b"_old_variableData".to_vec().try_into().unwrap(),192 value: v193 .variable_data194 .clone()195 .into_inner()196 .try_into()197 .expect("variable too long"),198 })199 }200 if !props.is_empty() {201 Self::set_scoped_token_properties(202 collection,203 token,204 PropertyScope::None,205 props.into_iter(),206 )207 .expect("existing token data exceeds property storage");208 }209 Some(<ItemDataVersion2<T::CrossAccountId>>::from(v))210 },211 );212 for collection in had_consts {213 <PalletCommon<T>>::set_property_permission_unchecked(214 collection,215 PropertyKeyPermission {216 key: b"_old_constData".to_vec().try_into().unwrap(),217 permission: PropertyPermission {218 mutable: false,219 collection_admin: true,220 token_owner: false,221 },222 },223 )224 .expect("failed to configure permission");225 }226 }227228 0229 }230 }231}232233pub struct NonfungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);234impl<T: Config> NonfungibleHandle<T> {235 pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {236 Self(inner)237 }238 pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {239 self.0240 }241 pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {242 &mut self.0243 }244}245impl<T: Config> WithRecorder<T> for NonfungibleHandle<T> {246 fn recorder(&self) -> &SubstrateRecorder<T> {247 self.0.recorder()248 }249 fn into_recorder(self) -> SubstrateRecorder<T> {250 self.0.into_recorder()251 }252}253impl<T: Config> Deref for NonfungibleHandle<T> {254 type Target = pallet_common::CollectionHandle<T>;255256 fn deref(&self) -> &Self::Target {257 &self.0258 }259}260261impl<T: Config> Pallet<T> {262 pub fn total_supply(collection: &NonfungibleHandle<T>) -> u32 {263 <TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)264 }265 pub fn token_exists(collection: &NonfungibleHandle<T>, token: TokenId) -> bool {266 <TokenData<T>>::contains_key((collection.id, token))267 }268269 pub fn set_scoped_token_property(270 collection_id: CollectionId,271 token_id: TokenId,272 scope: PropertyScope,273 property: Property,274 ) -> DispatchResult {275 TokenProperties::<T>::try_mutate((collection_id, token_id), |properties| {276 properties.try_scoped_set(scope, property.key, property.value)277 })278 .map_err(<CommonError<T>>::from)?;279280 Ok(())281 }282283 pub fn set_scoped_token_properties(284 collection_id: CollectionId,285 token_id: TokenId,286 scope: PropertyScope,287 properties: impl Iterator<Item = Property>,288 ) -> DispatchResult {289 TokenProperties::<T>::try_mutate((collection_id, token_id), |stored_properties| {290 stored_properties.try_scoped_set_from_iter(scope, properties)291 })292 .map_err(<CommonError<T>>::from)?;293294 Ok(())295 }296297 pub fn current_token_id(collection_id: CollectionId) -> TokenId {298 TokenId(<TokensMinted<T>>::get(collection_id))299 }300}301302// unchecked calls skips any permission checks303impl<T: Config> Pallet<T> {304 pub fn init_collection(305 owner: T::CrossAccountId,306 data: CreateCollectionData<T::AccountId>,307 ) -> Result<CollectionId, DispatchError> {308 <PalletCommon<T>>::init_collection(owner, data)309 }310 pub fn destroy_collection(311 collection: NonfungibleHandle<T>,312 sender: &T::CrossAccountId,313 ) -> DispatchResult {314 let id = collection.id;315316 if Self::collection_has_tokens(id) {317 return Err(<CommonError<T>>::CantDestroyNotEmptyCollection.into());318 }319320 // =========321322 PalletCommon::destroy_collection(collection.0, sender)?;323324 <TokenData<T>>::remove_prefix((id,), None);325 <TokenChildren<T>>::remove_prefix((id,), None);326 <Owned<T>>::remove_prefix((id,), None);327 <TokensMinted<T>>::remove(id);328 <TokensBurnt<T>>::remove(id);329 <Allowance<T>>::remove_prefix((id,), None);330 <AccountBalance<T>>::remove_prefix((id,), None);331 Ok(())332 }333334 pub fn burn(335 collection: &NonfungibleHandle<T>,336 sender: &T::CrossAccountId,337 token: TokenId,338 ) -> DispatchResult {339 let token_data =340 <TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;341 ensure!(342 &token_data.owner == sender343 || (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(sender)),344 <CommonError<T>>::NoPermission345 );346347 if collection.permissions.access() == AccessMode::AllowList {348 collection.check_allowlist(sender)?;349 }350351 if Self::token_has_children(collection.id, token) {352 return Err(<Error<T>>::CantBurnNftWithChildren.into());353 }354355 let burnt = <TokensBurnt<T>>::get(collection.id)356 .checked_add(1)357 .ok_or(ArithmeticError::Overflow)?;358359 let balance = <AccountBalance<T>>::get((collection.id, token_data.owner.clone()))360 .checked_sub(1)361 .ok_or(ArithmeticError::Overflow)?;362363 // =========364365 if balance == 0 {366 <AccountBalance<T>>::remove((collection.id, token_data.owner.clone()));367 } else {368 <AccountBalance<T>>::insert((collection.id, token_data.owner.clone()), balance);369 }370371 <PalletStructure<T>>::unnest_if_nested(&token_data.owner, collection.id, token);372373 <Owned<T>>::remove((collection.id, &token_data.owner, token));374 <TokensBurnt<T>>::insert(collection.id, burnt);375 <TokenData<T>>::remove((collection.id, token));376 <TokenProperties<T>>::remove((collection.id, token));377 let old_spender = <Allowance<T>>::take((collection.id, token));378379 if let Some(old_spender) = old_spender {380 <PalletCommon<T>>::deposit_event(CommonEvent::Approved(381 collection.id,382 token,383 token_data.owner.clone(),384 old_spender,385 0,386 ));387 }388389 <PalletEvm<T>>::deposit_log(390 ERC721Events::Transfer {391 from: *token_data.owner.as_eth(),392 to: H160::default(),393 token_id: token.into(),394 }395 .to_log(collection_id_to_address(collection.id)),396 );397 <PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(398 collection.id,399 token,400 token_data.owner,401 1,402 ));403 Ok(())404 }405406 #[transactional]407 pub fn burn_recursively(408 collection: &NonfungibleHandle<T>,409 sender: &T::CrossAccountId,410 token: TokenId,411 self_budget: &dyn Budget,412 breadth_budget: &dyn Budget,413 ) -> DispatchResultWithPostInfo {414 ensure!(self_budget.consume(), <StructureError<T>>::DepthLimit,);415416 let current_token_account =417 T::CrossTokenAddressMapping::token_to_address(collection.id, token);418419 let mut weight = 0 as Weight;420421 // This method is transactional, if user in fact doesn't have permissions to remove token -422 // tokens removed here will be restored after rejected transaction423 for ((collection, token), _) in <TokenChildren<T>>::iter_prefix((collection.id, token)) {424 ensure!(breadth_budget.consume(), <StructureError<T>>::BreadthLimit,);425 let PostDispatchInfo { actual_weight, .. } =426 <PalletStructure<T>>::burn_item_recursively(427 current_token_account.clone(),428 collection,429 token,430 self_budget,431 breadth_budget,432 )?;433 if let Some(actual_weight) = actual_weight {434 weight = weight.saturating_add(actual_weight);435 }436 }437438 Self::burn(collection, sender, token)?;439 DispatchResultWithPostInfo::Ok(PostDispatchInfo {440 actual_weight: Some(weight + <SelfWeightOf<T>>::burn_item()),441 pays_fee: Pays::Yes,442 })443 }444445 pub fn set_token_property(446 collection: &NonfungibleHandle<T>,447 sender: &T::CrossAccountId,448 token_id: TokenId,449 property: Property,450 is_token_create: bool,451 ) -> DispatchResult {452 Self::check_token_change_permission(453 collection,454 sender,455 token_id,456 &property.key,457 is_token_create,458 )?;459460 <TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {461 let property = property.clone();462 properties.try_set(property.key, property.value)463 })464 .map_err(<CommonError<T>>::from)?;465466 <PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertySet(467 collection.id,468 token_id,469 property.key,470 ));471472 Ok(())473 }474475 #[transactional]476 pub fn set_token_properties(477 collection: &NonfungibleHandle<T>,478 sender: &T::CrossAccountId,479 token_id: TokenId,480 properties: Vec<Property>,481 is_token_create: bool,482 ) -> DispatchResult {483 for property in properties {484 Self::set_token_property(collection, sender, token_id, property, is_token_create)?;485 }486487 Ok(())488 }489490 pub fn delete_token_property(491 collection: &NonfungibleHandle<T>,492 sender: &T::CrossAccountId,493 token_id: TokenId,494 property_key: PropertyKey,495 ) -> DispatchResult {496 Self::check_token_change_permission(collection, sender, token_id, &property_key, false)?;497498 <TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {499 properties.remove(&property_key)500 })501 .map_err(<CommonError<T>>::from)?;502503 <PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(504 collection.id,505 token_id,506 property_key,507 ));508509 Ok(())510 }511512 fn check_token_change_permission(513 collection: &NonfungibleHandle<T>,514 sender: &T::CrossAccountId,515 token_id: TokenId,516 property_key: &PropertyKey,517 is_token_create: bool,518 ) -> DispatchResult {519 let permission = <PalletCommon<T>>::property_permissions(collection.id)520 .get(property_key)521 .cloned()522 .unwrap_or_else(PropertyPermission::none);523524 let token_data = <TokenData<T>>::get((collection.id, token_id))525 .ok_or(<CommonError<T>>::TokenNotFound)?;526527 let check_token_owner = || -> DispatchResult {528 ensure!(&token_data.owner == sender, <CommonError<T>>::NoPermission);529 Ok(())530 };531532 let is_property_exists = TokenProperties::<T>::get((collection.id, token_id))533 .get(property_key)534 .is_some();535536 match permission {537 PropertyPermission { mutable: false, .. } if is_property_exists => {538 Err(<CommonError<T>>::NoPermission.into())539 }540541 PropertyPermission {542 collection_admin,543 token_owner,544 ..545 } => {546 //TODO: исследовать угрозы при публичном минтинге.547 if is_token_create && (collection_admin || token_owner) {548 return Ok(());549 }550551 let mut check_result = Err(<CommonError<T>>::NoPermission.into());552553 if collection_admin {554 check_result = collection.check_is_owner_or_admin(sender);555 }556557 if token_owner {558 check_result.or_else(|_| check_token_owner())559 } else {560 check_result561 }562 }563 }564 }565566 #[transactional]567 pub fn delete_token_properties(568 collection: &NonfungibleHandle<T>,569 sender: &T::CrossAccountId,570 token_id: TokenId,571 property_keys: Vec<PropertyKey>,572 ) -> DispatchResult {573 for key in property_keys {574 Self::delete_token_property(collection, sender, token_id, key)?;575 }576577 Ok(())578 }579580 pub fn set_collection_properties(581 collection: &NonfungibleHandle<T>,582 sender: &T::CrossAccountId,583 properties: Vec<Property>,584 ) -> DispatchResult {585 <PalletCommon<T>>::set_collection_properties(collection, sender, properties)586 }587588 pub fn delete_collection_properties(589 collection: &CollectionHandle<T>,590 sender: &T::CrossAccountId,591 property_keys: Vec<PropertyKey>,592 ) -> DispatchResult {593 <PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)594 }595596 pub fn set_property_permissions(597 collection: &CollectionHandle<T>,598 sender: &T::CrossAccountId,599 property_permissions: Vec<PropertyKeyPermission>,600 ) -> DispatchResult {601 <PalletCommon<T>>::set_property_permissions(collection, sender, property_permissions)602 }603604 pub fn set_property_permission(605 collection: &CollectionHandle<T>,606 sender: &T::CrossAccountId,607 permission: PropertyKeyPermission,608 ) -> DispatchResult {609 <PalletCommon<T>>::set_property_permission(collection, sender, permission)610 }611612 pub fn transfer(613 collection: &NonfungibleHandle<T>,614 from: &T::CrossAccountId,615 to: &T::CrossAccountId,616 token: TokenId,617 nesting_budget: &dyn Budget,618 ) -> DispatchResult {619 ensure!(620 collection.limits.transfers_enabled(),621 <CommonError<T>>::TransferNotAllowed622 );623624 let token_data =625 <TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;626 // TODO: require sender to be token, owner, require admins to go through transfer_from627 ensure!(628 &token_data.owner == from629 || (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(from)),630 <CommonError<T>>::NoPermission631 );632633 if collection.permissions.access() == AccessMode::AllowList {634 collection.check_allowlist(from)?;635 collection.check_allowlist(to)?;636 }637 <PalletCommon<T>>::ensure_correct_receiver(to)?;638639 let balance_from = <AccountBalance<T>>::get((collection.id, from))640 .checked_sub(1)641 .ok_or(<CommonError<T>>::TokenValueTooLow)?;642 let balance_to = if from != to {643 let balance_to = <AccountBalance<T>>::get((collection.id, to))644 .checked_add(1)645 .ok_or(ArithmeticError::Overflow)?;646647 ensure!(648 balance_to < collection.limits.account_token_ownership_limit(),649 <CommonError<T>>::AccountTokenLimitExceeded,650 );651652 Some(balance_to)653 } else {654 None655 };656657 <PalletStructure<T>>::nest_if_sent_to_token(658 from.clone(),659 to,660 collection.id,661 token,662 nesting_budget,663 )?;664665 // =========666667 <PalletStructure<T>>::unnest_if_nested(&token_data.owner, collection.id, token);668669 <TokenData<T>>::insert(670 (collection.id, token),671 ItemData {672 owner: to.clone(),673 ..token_data674 },675 );676677 if let Some(balance_to) = balance_to {678 // from != to679 if balance_from == 0 {680 <AccountBalance<T>>::remove((collection.id, from));681 } else {682 <AccountBalance<T>>::insert((collection.id, from), balance_from);683 }684 <AccountBalance<T>>::insert((collection.id, to), balance_to);685 <Owned<T>>::remove((collection.id, from, token));686 <Owned<T>>::insert((collection.id, to, token), true);687 }688 Self::set_allowance_unchecked(collection, from, token, None, true);689690 <PalletEvm<T>>::deposit_log(691 ERC721Events::Transfer {692 from: *from.as_eth(),693 to: *to.as_eth(),694 token_id: token.into(),695 }696 .to_log(collection_id_to_address(collection.id)),697 );698 <PalletCommon<T>>::deposit_event(CommonEvent::Transfer(699 collection.id,700 token,701 from.clone(),702 to.clone(),703 1,704 ));705 Ok(())706 }707708 pub fn create_multiple_items(709 collection: &NonfungibleHandle<T>,710 sender: &T::CrossAccountId,711 data: Vec<CreateItemData<T>>,712 nesting_budget: &dyn Budget,713 ) -> DispatchResult {714 if !collection.is_owner_or_admin(sender) {715 ensure!(716 collection.permissions.mint_mode(),717 <CommonError<T>>::PublicMintingNotAllowed718 );719 collection.check_allowlist(sender)?;720721 for item in data.iter() {722 collection.check_allowlist(&item.owner)?;723 }724 }725726 for data in data.iter() {727 <PalletCommon<T>>::ensure_correct_receiver(&data.owner)?;728 }729730 let first_token = <TokensMinted<T>>::get(collection.id);731 let tokens_minted = first_token732 .checked_add(data.len() as u32)733 .ok_or(ArithmeticError::Overflow)?;734 ensure!(735 tokens_minted <= collection.limits.token_limit(),736 <CommonError<T>>::CollectionTokenLimitExceeded737 );738739 let mut balances = BTreeMap::new();740 for data in &data {741 let balance = balances742 .entry(&data.owner)743 .or_insert_with(|| <AccountBalance<T>>::get((collection.id, &data.owner)));744 *balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;745746 ensure!(747 *balance <= collection.limits.account_token_ownership_limit(),748 <CommonError<T>>::AccountTokenLimitExceeded,749 );750 }751752 for (i, data) in data.iter().enumerate() {753 let token = TokenId(first_token + i as u32 + 1);754755 <PalletStructure<T>>::check_nesting(756 sender.clone(),757 &data.owner,758 collection.id,759 token,760 nesting_budget,761 )?;762 }763764 // =========765766 with_transaction(|| {767 for (i, data) in data.iter().enumerate() {768 let token = first_token + i as u32 + 1;769770 <TokenData<T>>::insert(771 (collection.id, token),772 ItemData {773 // const_data: data.const_data.clone(),774 owner: data.owner.clone(),775 },776 );777778 <PalletStructure<T>>::nest_if_sent_to_token_unchecked(779 &data.owner,780 collection.id,781 TokenId(token),782 );783784 if let Err(e) = Self::set_token_properties(785 collection,786 sender,787 TokenId(token),788 data.properties.clone().into_inner(),789 true,790 ) {791 return TransactionOutcome::Rollback(Err(e));792 }793 }794 TransactionOutcome::Commit(Ok(()))795 })?;796797 <TokensMinted<T>>::insert(collection.id, tokens_minted);798 for (account, balance) in balances {799 <AccountBalance<T>>::insert((collection.id, account), balance);800 }801 for (i, data) in data.into_iter().enumerate() {802 let token = first_token + i as u32 + 1;803 <Owned<T>>::insert((collection.id, &data.owner, token), true);804805 <PalletEvm<T>>::deposit_log(806 ERC721Events::Transfer {807 from: H160::default(),808 to: *data.owner.as_eth(),809 token_id: token.into(),810 }811 .to_log(collection_id_to_address(collection.id)),812 );813 <PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(814 collection.id,815 TokenId(token),816 data.owner.clone(),817 1,818 ));819 }820 Ok(())821 }822823 pub fn set_allowance_unchecked(824 collection: &NonfungibleHandle<T>,825 sender: &T::CrossAccountId,826 token: TokenId,827 spender: Option<&T::CrossAccountId>,828 assume_implicit_eth: bool,829 ) {830 if let Some(spender) = spender {831 let old_spender = <Allowance<T>>::get((collection.id, token));832 <Allowance<T>>::insert((collection.id, token), spender);833 // In ERC721 there is only one possible approved user of token, so we set834 // approved user to spender835 <PalletEvm<T>>::deposit_log(836 ERC721Events::Approval {837 owner: *sender.as_eth(),838 approved: *spender.as_eth(),839 token_id: token.into(),840 }841 .to_log(collection_id_to_address(collection.id)),842 );843 // In Unique chain, any token can have any amount of approved users, so we need to844 // set allowance of old owner to 0, and allowance of new owner to 1845 if old_spender.as_ref() != Some(spender) {846 if let Some(old_owner) = old_spender {847 <PalletCommon<T>>::deposit_event(CommonEvent::Approved(848 collection.id,849 token,850 sender.clone(),851 old_owner,852 0,853 ));854 }855 <PalletCommon<T>>::deposit_event(CommonEvent::Approved(856 collection.id,857 token,858 sender.clone(),859 spender.clone(),860 1,861 ));862 }863 } else {864 let old_spender = <Allowance<T>>::take((collection.id, token));865 if !assume_implicit_eth {866 // In ERC721 there is only one possible approved user of token, so we set867 // approved user to zero address868 <PalletEvm<T>>::deposit_log(869 ERC721Events::Approval {870 owner: *sender.as_eth(),871 approved: H160::default(),872 token_id: token.into(),873 }874 .to_log(collection_id_to_address(collection.id)),875 );876 }877 // In Unique chain, any token can have any amount of approved users, so we need to878 // set allowance of old owner to 0879 if let Some(old_spender) = old_spender {880 <PalletCommon<T>>::deposit_event(CommonEvent::Approved(881 collection.id,882 token,883 sender.clone(),884 old_spender,885 0,886 ));887 }888 }889 }890891 pub fn set_allowance(892 collection: &NonfungibleHandle<T>,893 sender: &T::CrossAccountId,894 token: TokenId,895 spender: Option<&T::CrossAccountId>,896 ) -> DispatchResult {897 if collection.permissions.access() == AccessMode::AllowList {898 collection.check_allowlist(sender)?;899 if let Some(spender) = spender {900 collection.check_allowlist(spender)?;901 }902 }903904 if let Some(spender) = spender {905 <PalletCommon<T>>::ensure_correct_receiver(spender)?;906 }907908 let token_data =909 <TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;910 if &token_data.owner != sender {911 ensure!(912 collection.ignores_owned_amount(sender),913 <CommonError<T>>::CantApproveMoreThanOwned914 );915 }916917 // =========918919 Self::set_allowance_unchecked(collection, sender, token, spender, false);920 Ok(())921 }922923 fn check_allowed(924 collection: &NonfungibleHandle<T>,925 spender: &T::CrossAccountId,926 from: &T::CrossAccountId,927 token: TokenId,928 nesting_budget: &dyn Budget,929 ) -> DispatchResult {930 if spender.conv_eq(from) {931 return Ok(());932 }933 if collection.permissions.access() == AccessMode::AllowList {934 // `from`, `to` checked in [`transfer`]935 collection.check_allowlist(spender)?;936 }937 if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {938 // TODO: should collection owner be allowed to perform this transfer?939 ensure!(940 <PalletStructure<T>>::check_indirectly_owned(941 spender.clone(),942 source.0,943 source.1,944 None,945 nesting_budget946 )?,947 <CommonError<T>>::ApprovedValueTooLow,948 );949 return Ok(());950 }951 if <Allowance<T>>::get((collection.id, token)).as_ref() == Some(spender) {952 return Ok(());953 }954 ensure!(955 collection.ignores_allowance(spender),956 <CommonError<T>>::ApprovedValueTooLow957 );958 Ok(())959 }960961 pub fn transfer_from(962 collection: &NonfungibleHandle<T>,963 spender: &T::CrossAccountId,964 from: &T::CrossAccountId,965 to: &T::CrossAccountId,966 token: TokenId,967 nesting_budget: &dyn Budget,968 ) -> DispatchResult {969 Self::check_allowed(collection, spender, from, token, nesting_budget)?;970971 // =========972973 // Allowance is reset in [`transfer`]974 Self::transfer(collection, from, to, token, nesting_budget)975 }976977 pub fn burn_from(978 collection: &NonfungibleHandle<T>,979 spender: &T::CrossAccountId,980 from: &T::CrossAccountId,981 token: TokenId,982 nesting_budget: &dyn Budget,983 ) -> DispatchResult {984 Self::check_allowed(collection, spender, from, token, nesting_budget)?;985986 // =========987988 Self::burn(collection, from, token)989 }990991 pub fn check_nesting(992 handle: &NonfungibleHandle<T>,993 sender: T::CrossAccountId,994 from: (CollectionId, TokenId),995 under: TokenId,996 nesting_budget: &dyn Budget,997 ) -> DispatchResult {998 fn ensure_sender_allowed<T: Config>(999 collection: CollectionId,1000 token: TokenId,1001 for_nest: (CollectionId, TokenId),1002 sender: T::CrossAccountId,1003 budget: &dyn Budget,1004 ) -> DispatchResult {1005 ensure!(1006 <PalletStructure<T>>::check_indirectly_owned(1007 sender,1008 collection,1009 token,1010 Some(for_nest),1011 budget1012 )?,1013 <CommonError<T>>::OnlyOwnerAllowedToNest,1014 );1015 Ok(())1016 }1017 match handle.permissions.nesting() {1018 NestingRule::Disabled => fail!(<CommonError<T>>::NestingIsDisabled),1019 NestingRule::Owner => {1020 ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?1021 }1022 NestingRule::OwnerRestricted(whitelist) => {1023 ensure!(1024 whitelist.contains(&from.0),1025 <CommonError<T>>::SourceCollectionIsNotAllowedToNest1026 );1027 ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?1028 }1029 NestingRule::Permissive => {}1030 }1031 Ok(())1032 }10331034 fn nest(under: (CollectionId, TokenId), to_nest: (CollectionId, TokenId)) {1035 <TokenChildren<T>>::insert((under.0, under.1, (to_nest.0, to_nest.1)), true);1036 }10371038 fn unnest(under: (CollectionId, TokenId), to_unnest: (CollectionId, TokenId)) {1039 <TokenChildren<T>>::remove((under.0, under.1, to_unnest));1040 }10411042 fn collection_has_tokens(collection_id: CollectionId) -> bool {1043 <TokenData<T>>::iter_prefix((collection_id,))1044 .next()1045 .is_some()1046 }10471048 fn token_has_children(collection_id: CollectionId, token_id: TokenId) -> bool {1049 <TokenChildren<T>>::iter_prefix((collection_id, token_id))1050 .next()1051 .is_some()1052 }10531054 pub fn token_children_ids(collection_id: CollectionId, token_id: TokenId) -> Vec<TokenChild> {1055 <TokenChildren<T>>::iter_prefix((collection_id, token_id))1056 .map(|((child_collection_id, child_id), _)| TokenChild {1057 collection: child_collection_id,1058 token: child_id,1059 })1060 .collect()1061 }10621063 /// Delegated to `create_multiple_items`1064 pub fn create_item(1065 collection: &NonfungibleHandle<T>,1066 sender: &T::CrossAccountId,1067 data: CreateItemData<T>,1068 nesting_budget: &dyn Budget,1069 ) -> DispatchResult {1070 Self::create_multiple_items(collection, sender, vec![data], nesting_budget)1071 }1072}