difftreelog
fix unable to destroy collection with nested tokens
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::{BoundedVec, ensure, fail, transactional, storage::with_transaction};22use up_data_structs::{23 AccessMode, CollectionId, CustomDataLimit, TokenId, CreateCollectionData, CreateNftExData,24 mapping::TokenAddressMapping, NestingRule, budget::Budget, Property, PropertyPermission,25 PropertyKey, PropertyKeyPermission, Properties, PropertyScope, TrySetProperty,26};27use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};28use pallet_common::{29 Error as CommonError, Pallet as PalletCommon, Event as CommonEvent, CollectionHandle,30 eth::collection_id_to_address,31};32use pallet_structure::Pallet as PalletStructure;33use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};34use sp_core::H160;35use sp_runtime::{ArithmeticError, DispatchError, DispatchResult, TransactionOutcome};36use sp_std::{vec::Vec, vec, collections::btree_set::BTreeSet};37use core::ops::Deref;38use sp_std::collections::btree_map::BTreeMap;39use codec::{Encode, Decode, MaxEncodedLen};40use scale_info::TypeInfo;4142pub use pallet::*;43#[cfg(feature = "runtime-benchmarks")]44pub mod benchmarking;45pub mod common;46pub mod erc;47pub mod weights;4849pub type CreateItemData<T> = CreateNftExData<<T as pallet_evm::account::Config>::CrossAccountId>;50pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;5152#[struct_versioning::versioned(version = 2, upper)]53#[derive(Encode, Decode, TypeInfo, MaxEncodedLen)]54pub struct ItemData<CrossAccountId> {55 #[version(..2)]56 pub const_data: BoundedVec<u8, CustomDataLimit>,5758 #[version(..2)]59 pub variable_data: BoundedVec<u8, CustomDataLimit>,6061 pub owner: CrossAccountId,62}6364#[frame_support::pallet]65pub mod pallet {66 use super::*;67 use frame_support::{68 Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key, traits::StorageVersion,69 };70 use frame_system::pallet_prelude::*;71 use up_data_structs::{CollectionId, TokenId};72 use super::weights::WeightInfo;7374 #[pallet::error]75 pub enum Error<T> {76 /// Not Nonfungible item data used to mint in Nonfungible collection.77 NotNonfungibleDataUsedToMintFungibleCollectionToken,78 /// Used amount > 1 with NFT79 NonfungibleItemsHaveNoAmount,80 /// Unable to burn NFT with children81 CantBurnNftWithChildren,82 }8384 #[pallet::config]85 pub trait Config:86 frame_system::Config + pallet_common::Config + pallet_structure::Config + pallet_evm::Config87 {88 type WeightInfo: WeightInfo;89 }9091 const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);9293 #[pallet::pallet]94 #[pallet::storage_version(STORAGE_VERSION)]95 #[pallet::generate_store(pub(super) trait Store)]96 pub struct Pallet<T>(_);9798 #[pallet::storage]99 pub type TokensMinted<T: Config> =100 StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;101 #[pallet::storage]102 pub type TokensBurnt<T: Config> =103 StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;104105 #[pallet::storage]106 pub type TokenData<T: Config> = StorageNMap<107 Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),108 Value = ItemData<T::CrossAccountId>,109 QueryKind = OptionQuery,110 >;111112 #[pallet::storage]113 #[pallet::getter(fn token_properties)]114 pub type TokenProperties<T: Config> = StorageNMap<115 Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),116 Value = Properties,117 QueryKind = ValueQuery,118 OnEmpty = up_data_structs::TokenProperties,119 >;120121 /// Used to enumerate tokens owned by account122 #[pallet::storage]123 pub type Owned<T: Config> = StorageNMap<124 Key = (125 Key<Twox64Concat, CollectionId>,126 Key<Blake2_128Concat, T::CrossAccountId>,127 Key<Twox64Concat, TokenId>,128 ),129 Value = bool,130 QueryKind = ValueQuery,131 >;132133 /// Used to enumerate token's children134 #[pallet::storage]135 #[pallet::getter(fn token_children)]136 pub type TokenChildren<T: Config> = StorageNMap<137 Key = (138 Key<Twox64Concat, CollectionId>,139 Key<Twox64Concat, TokenId>,140 Key<Twox64Concat, (CollectionId, TokenId)>,141 ),142 Value = bool,143 QueryKind = ValueQuery,144 >;145146 #[pallet::storage]147 pub type AccountBalance<T: Config> = StorageNMap<148 Key = (149 Key<Twox64Concat, CollectionId>,150 Key<Blake2_128Concat, T::CrossAccountId>,151 ),152 Value = u32,153 QueryKind = ValueQuery,154 >;155156 #[pallet::storage]157 pub type Allowance<T: Config> = StorageNMap<158 Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),159 Value = T::CrossAccountId,160 QueryKind = OptionQuery,161 >;162163 #[pallet::hooks]164 impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {165 fn on_runtime_upgrade() -> Weight {166 if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {167 let mut had_consts = BTreeSet::new();168 <TokenData<T>>::translate::<ItemDataVersion1<T::CrossAccountId>, _>(|(collection, token), v| {169 let mut props = vec![];170 if !v.const_data.is_empty() {171 props.push(Property {172 key: b"_old_constData".to_vec().try_into().unwrap(),173 value: v.const_data.clone().into_inner().try_into().expect("const too long"),174 });175 had_consts.insert(collection);176 }177 if !v.variable_data.is_empty() {178 props.push(Property {179 key: b"_old_variableData".to_vec().try_into().unwrap(),180 value: v.variable_data.clone().into_inner().try_into().expect("variable too long"),181 })182 }183 if !props.is_empty() {184 Self::set_scoped_token_properties(185 collection,186 token,187 PropertyScope::None,188 props.into_iter(),189 ).expect("existing token data exceeds property storage");190 }191 Some(<ItemDataVersion2<T::CrossAccountId>>::from(v))192 });193 for collection in had_consts {194 <PalletCommon<T>>::set_property_permission_unchecked(195 collection,196 PropertyKeyPermission {197 key: b"_old_constData".to_vec().try_into().unwrap(),198 permission: PropertyPermission {199 mutable: false,200 collection_admin: true,201 token_owner: false,202 },203 }204 ).expect("failed to configure permission");205 }206 }207208 0209 }210 }211}212213pub struct NonfungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);214impl<T: Config> NonfungibleHandle<T> {215 pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {216 Self(inner)217 }218 pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {219 self.0220 }221 pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {222 &mut self.0223 }224}225impl<T: Config> WithRecorder<T> for NonfungibleHandle<T> {226 fn recorder(&self) -> &SubstrateRecorder<T> {227 self.0.recorder()228 }229 fn into_recorder(self) -> SubstrateRecorder<T> {230 self.0.into_recorder()231 }232}233impl<T: Config> Deref for NonfungibleHandle<T> {234 type Target = pallet_common::CollectionHandle<T>;235236 fn deref(&self) -> &Self::Target {237 &self.0238 }239}240241impl<T: Config> Pallet<T> {242 pub fn total_supply(collection: &NonfungibleHandle<T>) -> u32 {243 <TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)244 }245 pub fn token_exists(collection: &NonfungibleHandle<T>, token: TokenId) -> bool {246 <TokenData<T>>::contains_key((collection.id, token))247 }248249 pub fn set_scoped_token_property(250 collection_id: CollectionId,251 token_id: TokenId,252 scope: PropertyScope,253 property: Property,254 ) -> DispatchResult {255 TokenProperties::<T>::try_mutate((collection_id, token_id), |properties| {256 properties.try_scoped_set(scope, property.key, property.value)257 })258 .map_err(<CommonError<T>>::from)?;259260 Ok(())261 }262263 pub fn set_scoped_token_properties(264 collection_id: CollectionId,265 token_id: TokenId,266 scope: PropertyScope,267 properties: impl Iterator<Item=Property>,268 ) -> DispatchResult {269 TokenProperties::<T>::try_mutate((collection_id, token_id), |stored_properties| {270 stored_properties.try_scoped_set_from_iter(scope, properties)271 })272 .map_err(<CommonError<T>>::from)?;273274 Ok(())275 }276277 pub fn current_token_id(collection_id: CollectionId) -> TokenId {278 TokenId(<TokensMinted<T>>::get(collection_id))279 }280}281282// unchecked calls skips any permission checks283impl<T: Config> Pallet<T> {284 pub fn init_collection(285 owner: T::AccountId,286 data: CreateCollectionData<T::AccountId>,287 ) -> Result<CollectionId, DispatchError> {288 <PalletCommon<T>>::init_collection(owner, data)289 }290 pub fn destroy_collection(291 collection: NonfungibleHandle<T>,292 sender: &T::CrossAccountId,293 ) -> DispatchResult {294 let id = collection.id;295296 // =========297298 PalletCommon::destroy_collection(collection.0, sender)?;299300 <TokenData<T>>::remove_prefix((id,), None);301 <TokenChildren<T>>::remove_prefix((id,), None);302 <Owned<T>>::remove_prefix((id,), None);303 <TokensMinted<T>>::remove(id);304 <TokensBurnt<T>>::remove(id);305 <Allowance<T>>::remove_prefix((id,), None);306 <AccountBalance<T>>::remove_prefix((id,), None);307 Ok(())308 }309310 pub fn burn(311 collection: &NonfungibleHandle<T>,312 sender: &T::CrossAccountId,313 token: TokenId,314 ) -> DispatchResult {315 let token_data =316 <TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;317 ensure!(318 &token_data.owner == sender319 || (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(sender)),320 <CommonError<T>>::NoPermission321 );322323 if collection.permissions.access() == AccessMode::AllowList {324 collection.check_allowlist(sender)?;325 }326327 if Self::token_has_children(collection.id, token) {328 return Err(<Error<T>>::CantBurnNftWithChildren.into());329 }330331 let burnt = <TokensBurnt<T>>::get(collection.id)332 .checked_add(1)333 .ok_or(ArithmeticError::Overflow)?;334335 let balance = <AccountBalance<T>>::get((collection.id, token_data.owner.clone()))336 .checked_sub(1)337 .ok_or(ArithmeticError::Overflow)?;338339 if balance == 0 {340 <AccountBalance<T>>::remove((collection.id, token_data.owner.clone()));341 } else {342 <AccountBalance<T>>::insert((collection.id, token_data.owner.clone()), balance);343 }344345 if let Some(owner) = T::CrossTokenAddressMapping::address_to_token(&token_data.owner) {346 Self::unnest(owner, (collection.id, token));347 }348349 // =========350351 <Owned<T>>::remove((collection.id, &token_data.owner, token));352 <TokensBurnt<T>>::insert(collection.id, burnt);353 <TokenData<T>>::remove((collection.id, token));354 <TokenProperties<T>>::remove((collection.id, token));355 let old_spender = <Allowance<T>>::take((collection.id, token));356357 if let Some(old_spender) = old_spender {358 <PalletCommon<T>>::deposit_event(CommonEvent::Approved(359 collection.id,360 token,361 sender.clone(),362 old_spender,363 0,364 ));365 }366367 <PalletEvm<T>>::deposit_log(368 ERC721Events::Transfer {369 from: *token_data.owner.as_eth(),370 to: H160::default(),371 token_id: token.into(),372 }373 .to_log(collection_id_to_address(collection.id)),374 );375 <PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(376 collection.id,377 token,378 token_data.owner,379 1,380 ));381 Ok(())382 }383384 pub fn set_token_property(385 collection: &NonfungibleHandle<T>,386 sender: &T::CrossAccountId,387 token_id: TokenId,388 property: Property,389 ) -> DispatchResult {390 Self::check_token_change_permission(collection, sender, token_id, &property.key)?;391392 <TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {393 let property = property.clone();394 properties.try_set(property.key, property.value)395 })396 .map_err(<CommonError<T>>::from)?;397398 <PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertySet(399 collection.id,400 token_id,401 property.key,402 ));403404 Ok(())405 }406407 #[transactional]408 pub fn set_token_properties(409 collection: &NonfungibleHandle<T>,410 sender: &T::CrossAccountId,411 token_id: TokenId,412 properties: Vec<Property>,413 ) -> DispatchResult {414 for property in properties {415 Self::set_token_property(collection, sender, token_id, property)?;416 }417418 Ok(())419 }420421 pub fn delete_token_property(422 collection: &NonfungibleHandle<T>,423 sender: &T::CrossAccountId,424 token_id: TokenId,425 property_key: PropertyKey,426 ) -> DispatchResult {427 Self::check_token_change_permission(collection, sender, token_id, &property_key)?;428429 <TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {430 properties.remove(&property_key)431 })432 .map_err(<CommonError<T>>::from)?;433434 <PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(435 collection.id,436 token_id,437 property_key,438 ));439440 Ok(())441 }442443 fn check_token_change_permission(444 collection: &NonfungibleHandle<T>,445 sender: &T::CrossAccountId,446 token_id: TokenId,447 property_key: &PropertyKey,448 ) -> DispatchResult {449 let permission = <PalletCommon<T>>::property_permissions(collection.id)450 .get(property_key)451 .cloned()452 .unwrap_or_else(PropertyPermission::none);453454 let token_data = <TokenData<T>>::get((collection.id, token_id))455 .ok_or(<CommonError<T>>::TokenNotFound)?;456457 let check_token_owner = || -> DispatchResult {458 ensure!(&token_data.owner == sender, <CommonError<T>>::NoPermission);459 Ok(())460 };461462 let is_property_exists = TokenProperties::<T>::get((collection.id, token_id))463 .get(property_key)464 .is_some();465466 match permission {467 PropertyPermission { mutable: false, .. } if is_property_exists => {468 Err(<CommonError<T>>::NoPermission.into())469 }470471 PropertyPermission {472 collection_admin,473 token_owner,474 ..475 } => {476 let mut check_result = Err(<CommonError<T>>::NoPermission.into());477478 if collection_admin {479 check_result = collection.check_is_owner_or_admin(sender);480 }481482 if token_owner {483 check_result.or_else(|_| check_token_owner())484 } else {485 check_result486 }487 }488 }489 }490491 #[transactional]492 pub fn delete_token_properties(493 collection: &NonfungibleHandle<T>,494 sender: &T::CrossAccountId,495 token_id: TokenId,496 property_keys: Vec<PropertyKey>,497 ) -> DispatchResult {498 for key in property_keys {499 Self::delete_token_property(collection, sender, token_id, key)?;500 }501502 Ok(())503 }504505 pub fn set_collection_properties(506 collection: &NonfungibleHandle<T>,507 sender: &T::CrossAccountId,508 properties: Vec<Property>,509 ) -> DispatchResult {510 <PalletCommon<T>>::set_collection_properties(collection, sender, properties)511 }512513 pub fn delete_collection_properties(514 collection: &CollectionHandle<T>,515 sender: &T::CrossAccountId,516 property_keys: Vec<PropertyKey>,517 ) -> DispatchResult {518 <PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)519 }520521 pub fn set_property_permissions(522 collection: &CollectionHandle<T>,523 sender: &T::CrossAccountId,524 property_permissions: Vec<PropertyKeyPermission>,525 ) -> DispatchResult {526 <PalletCommon<T>>::set_property_permissions(collection, sender, property_permissions)527 }528529 pub fn set_property_permission(530 collection: &CollectionHandle<T>,531 sender: &T::CrossAccountId,532 permission: PropertyKeyPermission,533 ) -> DispatchResult {534 <PalletCommon<T>>::set_property_permission(collection, sender, permission)535 }536537 pub fn transfer(538 collection: &NonfungibleHandle<T>,539 from: &T::CrossAccountId,540 to: &T::CrossAccountId,541 token: TokenId,542 nesting_budget: &dyn Budget,543 ) -> DispatchResult {544 ensure!(545 collection.limits.transfers_enabled(),546 <CommonError<T>>::TransferNotAllowed547 );548549 let token_data =550 <TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;551 // TODO: require sender to be token, owner, require admins to go through transfer_from552 ensure!(553 &token_data.owner == from554 || (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(from)),555 <CommonError<T>>::NoPermission556 );557558 if collection.permissions.access() == AccessMode::AllowList {559 collection.check_allowlist(from)?;560 collection.check_allowlist(to)?;561 }562 <PalletCommon<T>>::ensure_correct_receiver(to)?;563564 let balance_from = <AccountBalance<T>>::get((collection.id, from))565 .checked_sub(1)566 .ok_or(<CommonError<T>>::TokenValueTooLow)?;567 let balance_to = if from != to {568 let balance_to = <AccountBalance<T>>::get((collection.id, to))569 .checked_add(1)570 .ok_or(ArithmeticError::Overflow)?;571572 ensure!(573 balance_to < collection.limits.account_token_ownership_limit(),574 <CommonError<T>>::AccountTokenLimitExceeded,575 );576577 Some(balance_to)578 } else {579 None580 };581582 <PalletStructure<T>>::try_nest_if_sent_to_token(583 from.clone(),584 to,585 collection.id,586 token,587 nesting_budget588 )?;589590 // =========591592 <TokenData<T>>::insert(593 (collection.id, token),594 ItemData {595 owner: to.clone(),596 ..token_data597 },598 );599600 if let Some(balance_to) = balance_to {601 // from != to602 if balance_from == 0 {603 <AccountBalance<T>>::remove((collection.id, from));604 } else {605 <AccountBalance<T>>::insert((collection.id, from), balance_from);606 }607 <AccountBalance<T>>::insert((collection.id, to), balance_to);608 <Owned<T>>::remove((collection.id, from, token));609 <Owned<T>>::insert((collection.id, to, token), true);610 }611 Self::set_allowance_unchecked(collection, from, token, None, true);612613 <PalletEvm<T>>::deposit_log(614 ERC721Events::Transfer {615 from: *from.as_eth(),616 to: *to.as_eth(),617 token_id: token.into(),618 }619 .to_log(collection_id_to_address(collection.id)),620 );621 <PalletCommon<T>>::deposit_event(CommonEvent::Transfer(622 collection.id,623 token,624 from.clone(),625 to.clone(),626 1,627 ));628 Ok(())629 }630631 pub fn create_multiple_items(632 collection: &NonfungibleHandle<T>,633 sender: &T::CrossAccountId,634 data: Vec<CreateItemData<T>>,635 nesting_budget: &dyn Budget,636 ) -> DispatchResult {637 if !collection.is_owner_or_admin(sender) {638 ensure!(639 collection.permissions.mint_mode(),640 <CommonError<T>>::PublicMintingNotAllowed641 );642 collection.check_allowlist(sender)?;643644 for item in data.iter() {645 collection.check_allowlist(&item.owner)?;646 }647 }648649 for data in data.iter() {650 <PalletCommon<T>>::ensure_correct_receiver(&data.owner)?;651 }652653 let first_token = <TokensMinted<T>>::get(collection.id);654 let tokens_minted = first_token655 .checked_add(data.len() as u32)656 .ok_or(ArithmeticError::Overflow)?;657 ensure!(658 tokens_minted <= collection.limits.token_limit(),659 <CommonError<T>>::CollectionTokenLimitExceeded660 );661662 let mut balances = BTreeMap::new();663 for data in &data {664 let balance = balances665 .entry(&data.owner)666 .or_insert_with(|| <AccountBalance<T>>::get((collection.id, &data.owner)));667 *balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;668669 ensure!(670 *balance <= collection.limits.account_token_ownership_limit(),671 <CommonError<T>>::AccountTokenLimitExceeded,672 );673 }674675 for (i, data) in data.iter().enumerate() {676 let token = TokenId(first_token + i as u32 + 1);677678 <PalletStructure<T>>::check_nesting(679 sender.clone(),680 &data.owner,681 collection.id,682 token,683 nesting_budget,684 )?;685 }686687 // =========688689 with_transaction(|| {690 for (i, data) in data.iter().enumerate() {691 let token = first_token + i as u32 + 1;692693 <TokenData<T>>::insert(694 (collection.id, token),695 ItemData {696 // const_data: data.const_data.clone(),697 owner: data.owner.clone(),698 },699 );700701 <PalletStructure<T>>::nest_if_sent_to_token(&data.owner, collection.id, TokenId(token));702703 if let Err(e) = Self::set_token_properties(704 collection,705 sender,706 TokenId(token),707 data.properties.clone().into_inner(),708 ) {709 return TransactionOutcome::Rollback(Err(e));710 }711 }712 TransactionOutcome::Commit(Ok(()))713 })?;714715 <TokensMinted<T>>::insert(collection.id, tokens_minted);716 for (account, balance) in balances {717 <AccountBalance<T>>::insert((collection.id, account), balance);718 }719 for (i, data) in data.into_iter().enumerate() {720 let token = first_token + i as u32 + 1;721 <Owned<T>>::insert((collection.id, &data.owner, token), true);722723 <PalletEvm<T>>::deposit_log(724 ERC721Events::Transfer {725 from: H160::default(),726 to: *data.owner.as_eth(),727 token_id: token.into(),728 }729 .to_log(collection_id_to_address(collection.id)),730 );731 <PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(732 collection.id,733 TokenId(token),734 data.owner.clone(),735 1,736 ));737 }738 Ok(())739 }740741 pub fn set_allowance_unchecked(742 collection: &NonfungibleHandle<T>,743 sender: &T::CrossAccountId,744 token: TokenId,745 spender: Option<&T::CrossAccountId>,746 assume_implicit_eth: bool,747 ) {748 if let Some(spender) = spender {749 let old_spender = <Allowance<T>>::get((collection.id, token));750 <Allowance<T>>::insert((collection.id, token), spender);751 // In ERC721 there is only one possible approved user of token, so we set752 // approved user to spender753 <PalletEvm<T>>::deposit_log(754 ERC721Events::Approval {755 owner: *sender.as_eth(),756 approved: *spender.as_eth(),757 token_id: token.into(),758 }759 .to_log(collection_id_to_address(collection.id)),760 );761 // In Unique chain, any token can have any amount of approved users, so we need to762 // set allowance of old owner to 0, and allowance of new owner to 1763 if old_spender.as_ref() != Some(spender) {764 if let Some(old_owner) = old_spender {765 <PalletCommon<T>>::deposit_event(CommonEvent::Approved(766 collection.id,767 token,768 sender.clone(),769 old_owner,770 0,771 ));772 }773 <PalletCommon<T>>::deposit_event(CommonEvent::Approved(774 collection.id,775 token,776 sender.clone(),777 spender.clone(),778 1,779 ));780 }781 } else {782 let old_spender = <Allowance<T>>::take((collection.id, token));783 if !assume_implicit_eth {784 // In ERC721 there is only one possible approved user of token, so we set785 // approved user to zero address786 <PalletEvm<T>>::deposit_log(787 ERC721Events::Approval {788 owner: *sender.as_eth(),789 approved: H160::default(),790 token_id: token.into(),791 }792 .to_log(collection_id_to_address(collection.id)),793 );794 }795 // In Unique chain, any token can have any amount of approved users, so we need to796 // set allowance of old owner to 0797 if let Some(old_spender) = old_spender {798 <PalletCommon<T>>::deposit_event(CommonEvent::Approved(799 collection.id,800 token,801 sender.clone(),802 old_spender,803 0,804 ));805 }806 }807 }808809 pub fn set_allowance(810 collection: &NonfungibleHandle<T>,811 sender: &T::CrossAccountId,812 token: TokenId,813 spender: Option<&T::CrossAccountId>,814 ) -> DispatchResult {815 if collection.permissions.access() == AccessMode::AllowList {816 collection.check_allowlist(sender)?;817 if let Some(spender) = spender {818 collection.check_allowlist(spender)?;819 }820 }821822 if let Some(spender) = spender {823 <PalletCommon<T>>::ensure_correct_receiver(spender)?;824 }825 let token_data =826 <TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;827 if &token_data.owner != sender {828 ensure!(829 collection.ignores_owned_amount(sender),830 <CommonError<T>>::CantApproveMoreThanOwned831 );832 }833834 // =========835836 Self::set_allowance_unchecked(collection, sender, token, spender, false);837 Ok(())838 }839840 fn check_allowed(841 collection: &NonfungibleHandle<T>,842 spender: &T::CrossAccountId,843 from: &T::CrossAccountId,844 token: TokenId,845 nesting_budget: &dyn Budget,846 ) -> DispatchResult {847 if spender.conv_eq(from) {848 return Ok(());849 }850 if collection.permissions.access() == AccessMode::AllowList {851 // `from`, `to` checked in [`transfer`]852 collection.check_allowlist(spender)?;853 }854 if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {855 // TODO: should collection owner be allowed to perform this transfer?856 ensure!(857 <PalletStructure<T>>::check_indirectly_owned(858 spender.clone(),859 source.0,860 source.1,861 None,862 nesting_budget863 )?,864 <CommonError<T>>::ApprovedValueTooLow,865 );866 return Ok(());867 }868 if <Allowance<T>>::get((collection.id, token)).as_ref() == Some(spender) {869 return Ok(());870 }871 ensure!(872 collection.ignores_allowance(spender),873 <CommonError<T>>::ApprovedValueTooLow874 );875 Ok(())876 }877878 pub fn transfer_from(879 collection: &NonfungibleHandle<T>,880 spender: &T::CrossAccountId,881 from: &T::CrossAccountId,882 to: &T::CrossAccountId,883 token: TokenId,884 nesting_budget: &dyn Budget,885 ) -> DispatchResult {886 Self::check_allowed(collection, spender, from, token, nesting_budget)?;887888 // =========889890 // Allowance is reset in [`transfer`]891 Self::transfer(collection, from, to, token, nesting_budget)892 }893894 pub fn burn_from(895 collection: &NonfungibleHandle<T>,896 spender: &T::CrossAccountId,897 from: &T::CrossAccountId,898 token: TokenId,899 nesting_budget: &dyn Budget,900 ) -> DispatchResult {901 Self::check_allowed(collection, spender, from, token, nesting_budget)?;902903 // =========904905 Self::burn(collection, from, token)906 }907908 pub fn check_nesting(909 handle: &NonfungibleHandle<T>,910 sender: T::CrossAccountId,911 from: (CollectionId, TokenId),912 under: TokenId,913 nesting_budget: &dyn Budget,914 ) -> DispatchResult {915 fn ensure_sender_allowed<T: Config>(916 collection: CollectionId,917 token: TokenId,918 for_nest: (CollectionId, TokenId),919 sender: T::CrossAccountId,920 budget: &dyn Budget,921 ) -> DispatchResult {922 ensure!(923 <PalletStructure<T>>::check_indirectly_owned(924 sender,925 collection,926 token,927 Some(for_nest),928 budget929 )?,930 <CommonError<T>>::OnlyOwnerAllowedToNest,931 );932 Ok(())933 }934 match handle.permissions.nesting() {935 NestingRule::Disabled => fail!(<CommonError<T>>::NestingIsDisabled),936 NestingRule::Owner => {937 ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?938 }939 NestingRule::OwnerRestricted(whitelist) => {940 ensure!(941 whitelist.contains(&from.0),942 <CommonError<T>>::SourceCollectionIsNotAllowedToNest943 );944 ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?945 }946 }947 Ok(())948 }949950 fn nest(951 under: (CollectionId, TokenId),952 to_nest: (CollectionId, TokenId),953 ) {954 <TokenChildren<T>>::insert(955 (under.0, under.1, (to_nest.0, to_nest.1)),956 true957 );958 }959960 fn unnest(961 under: (CollectionId, TokenId),962 to_unnest: (CollectionId, TokenId),963 ) {964 <TokenChildren<T>>::remove(965 (under.0, under.1, to_unnest)966 );967 }968969 fn token_has_children(collection_id: CollectionId, token_id: TokenId) -> bool {970 <TokenChildren<T>>::iter_prefix((collection_id, token_id)).next().is_some()971 }972973 /// Delegated to `create_multiple_items`974 pub fn create_item(975 collection: &NonfungibleHandle<T>,976 sender: &T::CrossAccountId,977 data: CreateItemData<T>,978 nesting_budget: &dyn Budget,979 ) -> DispatchResult {980 Self::create_multiple_items(collection, sender, vec![data], nesting_budget)981 }982}1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617#![cfg_attr(not(feature = "std"), no_std)]1819use erc::ERC721Events;20use evm_coder::ToLog;21use frame_support::{BoundedVec, ensure, fail, transactional, storage::with_transaction};22use up_data_structs::{23 AccessMode, CollectionId, CustomDataLimit, TokenId, CreateCollectionData, CreateNftExData,24 mapping::TokenAddressMapping, NestingRule, budget::Budget, Property, PropertyPermission,25 PropertyKey, PropertyKeyPermission, Properties, PropertyScope, TrySetProperty,26};27use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};28use pallet_common::{29 Error as CommonError, Pallet as PalletCommon, Event as CommonEvent, CollectionHandle,30 eth::collection_id_to_address,31};32use pallet_structure::Pallet as PalletStructure;33use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};34use sp_core::H160;35use sp_runtime::{ArithmeticError, DispatchError, DispatchResult, TransactionOutcome};36use sp_std::{vec::Vec, vec, collections::btree_set::BTreeSet};37use core::ops::Deref;38use sp_std::collections::btree_map::BTreeMap;39use codec::{Encode, Decode, MaxEncodedLen};40use scale_info::TypeInfo;4142pub use pallet::*;43#[cfg(feature = "runtime-benchmarks")]44pub mod benchmarking;45pub mod common;46pub mod erc;47pub mod weights;4849pub type CreateItemData<T> = CreateNftExData<<T as pallet_evm::account::Config>::CrossAccountId>;50pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;5152#[struct_versioning::versioned(version = 2, upper)]53#[derive(Encode, Decode, TypeInfo, MaxEncodedLen)]54pub struct ItemData<CrossAccountId> {55 #[version(..2)]56 pub const_data: BoundedVec<u8, CustomDataLimit>,5758 #[version(..2)]59 pub variable_data: BoundedVec<u8, CustomDataLimit>,6061 pub owner: CrossAccountId,62}6364#[frame_support::pallet]65pub mod pallet {66 use super::*;67 use frame_support::{68 Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key, traits::StorageVersion,69 };70 use frame_system::pallet_prelude::*;71 use up_data_structs::{CollectionId, TokenId};72 use super::weights::WeightInfo;7374 #[pallet::error]75 pub enum Error<T> {76 /// Not Nonfungible item data used to mint in Nonfungible collection.77 NotNonfungibleDataUsedToMintFungibleCollectionToken,78 /// Used amount > 1 with NFT79 NonfungibleItemsHaveNoAmount,80 /// Unable to burn NFT with children81 CantBurnNftWithChildren,82 /// Unable to burn a collection containing NFTs that have children83 CantBurnCollectionWithNestedTokens84 }8586 #[pallet::config]87 pub trait Config:88 frame_system::Config + pallet_common::Config + pallet_structure::Config + pallet_evm::Config89 {90 type WeightInfo: WeightInfo;91 }9293 const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);9495 #[pallet::pallet]96 #[pallet::storage_version(STORAGE_VERSION)]97 #[pallet::generate_store(pub(super) trait Store)]98 pub struct Pallet<T>(_);99100 #[pallet::storage]101 pub type TokensMinted<T: Config> =102 StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;103 #[pallet::storage]104 pub type TokensBurnt<T: Config> =105 StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;106107 #[pallet::storage]108 pub type TokenData<T: Config> = StorageNMap<109 Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),110 Value = ItemData<T::CrossAccountId>,111 QueryKind = OptionQuery,112 >;113114 #[pallet::storage]115 #[pallet::getter(fn token_properties)]116 pub type TokenProperties<T: Config> = StorageNMap<117 Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),118 Value = Properties,119 QueryKind = ValueQuery,120 OnEmpty = up_data_structs::TokenProperties,121 >;122123 /// Used to enumerate tokens owned by account124 #[pallet::storage]125 pub type Owned<T: Config> = StorageNMap<126 Key = (127 Key<Twox64Concat, CollectionId>,128 Key<Blake2_128Concat, T::CrossAccountId>,129 Key<Twox64Concat, TokenId>,130 ),131 Value = bool,132 QueryKind = ValueQuery,133 >;134135 /// Used to enumerate token's children136 #[pallet::storage]137 #[pallet::getter(fn token_children)]138 pub type TokenChildren<T: Config> = StorageNMap<139 Key = (140 Key<Twox64Concat, CollectionId>,141 Key<Twox64Concat, TokenId>,142 Key<Twox64Concat, (CollectionId, TokenId)>,143 ),144 Value = bool,145 QueryKind = ValueQuery,146 >;147148 #[pallet::storage]149 pub type AccountBalance<T: Config> = StorageNMap<150 Key = (151 Key<Twox64Concat, CollectionId>,152 Key<Blake2_128Concat, T::CrossAccountId>,153 ),154 Value = u32,155 QueryKind = ValueQuery,156 >;157158 #[pallet::storage]159 pub type Allowance<T: Config> = StorageNMap<160 Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),161 Value = T::CrossAccountId,162 QueryKind = OptionQuery,163 >;164165 #[pallet::hooks]166 impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {167 fn on_runtime_upgrade() -> Weight {168 if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {169 let mut had_consts = BTreeSet::new();170 <TokenData<T>>::translate::<ItemDataVersion1<T::CrossAccountId>, _>(|(collection, token), v| {171 let mut props = vec![];172 if !v.const_data.is_empty() {173 props.push(Property {174 key: b"_old_constData".to_vec().try_into().unwrap(),175 value: v.const_data.clone().into_inner().try_into().expect("const too long"),176 });177 had_consts.insert(collection);178 }179 if !v.variable_data.is_empty() {180 props.push(Property {181 key: b"_old_variableData".to_vec().try_into().unwrap(),182 value: v.variable_data.clone().into_inner().try_into().expect("variable too long"),183 })184 }185 if !props.is_empty() {186 Self::set_scoped_token_properties(187 collection,188 token,189 PropertyScope::None,190 props.into_iter(),191 ).expect("existing token data exceeds property storage");192 }193 Some(<ItemDataVersion2<T::CrossAccountId>>::from(v))194 });195 for collection in had_consts {196 <PalletCommon<T>>::set_property_permission_unchecked(197 collection,198 PropertyKeyPermission {199 key: b"_old_constData".to_vec().try_into().unwrap(),200 permission: PropertyPermission {201 mutable: false,202 collection_admin: true,203 token_owner: false,204 },205 }206 ).expect("failed to configure permission");207 }208 }209210 0211 }212 }213}214215pub struct NonfungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);216impl<T: Config> NonfungibleHandle<T> {217 pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {218 Self(inner)219 }220 pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {221 self.0222 }223 pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {224 &mut self.0225 }226}227impl<T: Config> WithRecorder<T> for NonfungibleHandle<T> {228 fn recorder(&self) -> &SubstrateRecorder<T> {229 self.0.recorder()230 }231 fn into_recorder(self) -> SubstrateRecorder<T> {232 self.0.into_recorder()233 }234}235impl<T: Config> Deref for NonfungibleHandle<T> {236 type Target = pallet_common::CollectionHandle<T>;237238 fn deref(&self) -> &Self::Target {239 &self.0240 }241}242243impl<T: Config> Pallet<T> {244 pub fn total_supply(collection: &NonfungibleHandle<T>) -> u32 {245 <TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)246 }247 pub fn token_exists(collection: &NonfungibleHandle<T>, token: TokenId) -> bool {248 <TokenData<T>>::contains_key((collection.id, token))249 }250251 pub fn set_scoped_token_property(252 collection_id: CollectionId,253 token_id: TokenId,254 scope: PropertyScope,255 property: Property,256 ) -> DispatchResult {257 TokenProperties::<T>::try_mutate((collection_id, token_id), |properties| {258 properties.try_scoped_set(scope, property.key, property.value)259 })260 .map_err(<CommonError<T>>::from)?;261262 Ok(())263 }264265 pub fn set_scoped_token_properties(266 collection_id: CollectionId,267 token_id: TokenId,268 scope: PropertyScope,269 properties: impl Iterator<Item=Property>,270 ) -> DispatchResult {271 TokenProperties::<T>::try_mutate((collection_id, token_id), |stored_properties| {272 stored_properties.try_scoped_set_from_iter(scope, properties)273 })274 .map_err(<CommonError<T>>::from)?;275276 Ok(())277 }278279 pub fn current_token_id(collection_id: CollectionId) -> TokenId {280 TokenId(<TokensMinted<T>>::get(collection_id))281 }282}283284// unchecked calls skips any permission checks285impl<T: Config> Pallet<T> {286 pub fn init_collection(287 owner: T::AccountId,288 data: CreateCollectionData<T::AccountId>,289 ) -> Result<CollectionId, DispatchError> {290 <PalletCommon<T>>::init_collection(owner, data)291 }292 pub fn destroy_collection(293 collection: NonfungibleHandle<T>,294 sender: &T::CrossAccountId,295 ) -> DispatchResult {296 let id = collection.id;297298 if Self::collection_has_nested_tokens(id) {299 return Err(<Error<T>>::CantBurnCollectionWithNestedTokens.into());300 }301302 // =========303304 PalletCommon::destroy_collection(collection.0, sender)?;305306 <TokenData<T>>::remove_prefix((id,), None);307 <TokenChildren<T>>::remove_prefix((id,), None);308 <Owned<T>>::remove_prefix((id,), None);309 <TokensMinted<T>>::remove(id);310 <TokensBurnt<T>>::remove(id);311 <Allowance<T>>::remove_prefix((id,), None);312 <AccountBalance<T>>::remove_prefix((id,), None);313 Ok(())314 }315316 pub fn burn(317 collection: &NonfungibleHandle<T>,318 sender: &T::CrossAccountId,319 token: TokenId,320 ) -> DispatchResult {321 let token_data =322 <TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;323 ensure!(324 &token_data.owner == sender325 || (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(sender)),326 <CommonError<T>>::NoPermission327 );328329 if collection.permissions.access() == AccessMode::AllowList {330 collection.check_allowlist(sender)?;331 }332333 if Self::token_has_children(collection.id, token) {334 return Err(<Error<T>>::CantBurnNftWithChildren.into());335 }336337 let burnt = <TokensBurnt<T>>::get(collection.id)338 .checked_add(1)339 .ok_or(ArithmeticError::Overflow)?;340341 let balance = <AccountBalance<T>>::get((collection.id, token_data.owner.clone()))342 .checked_sub(1)343 .ok_or(ArithmeticError::Overflow)?;344345 if balance == 0 {346 <AccountBalance<T>>::remove((collection.id, token_data.owner.clone()));347 } else {348 <AccountBalance<T>>::insert((collection.id, token_data.owner.clone()), balance);349 }350351 if let Some(owner) = T::CrossTokenAddressMapping::address_to_token(&token_data.owner) {352 Self::unnest(owner, (collection.id, token));353 }354355 // =========356357 <Owned<T>>::remove((collection.id, &token_data.owner, token));358 <TokensBurnt<T>>::insert(collection.id, burnt);359 <TokenData<T>>::remove((collection.id, token));360 <TokenProperties<T>>::remove((collection.id, token));361 let old_spender = <Allowance<T>>::take((collection.id, token));362363 if let Some(old_spender) = old_spender {364 <PalletCommon<T>>::deposit_event(CommonEvent::Approved(365 collection.id,366 token,367 sender.clone(),368 old_spender,369 0,370 ));371 }372373 <PalletEvm<T>>::deposit_log(374 ERC721Events::Transfer {375 from: *token_data.owner.as_eth(),376 to: H160::default(),377 token_id: token.into(),378 }379 .to_log(collection_id_to_address(collection.id)),380 );381 <PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(382 collection.id,383 token,384 token_data.owner,385 1,386 ));387 Ok(())388 }389390 pub fn set_token_property(391 collection: &NonfungibleHandle<T>,392 sender: &T::CrossAccountId,393 token_id: TokenId,394 property: Property,395 ) -> DispatchResult {396 Self::check_token_change_permission(collection, sender, token_id, &property.key)?;397398 <TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {399 let property = property.clone();400 properties.try_set(property.key, property.value)401 })402 .map_err(<CommonError<T>>::from)?;403404 <PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertySet(405 collection.id,406 token_id,407 property.key,408 ));409410 Ok(())411 }412413 #[transactional]414 pub fn set_token_properties(415 collection: &NonfungibleHandle<T>,416 sender: &T::CrossAccountId,417 token_id: TokenId,418 properties: Vec<Property>,419 ) -> DispatchResult {420 for property in properties {421 Self::set_token_property(collection, sender, token_id, property)?;422 }423424 Ok(())425 }426427 pub fn delete_token_property(428 collection: &NonfungibleHandle<T>,429 sender: &T::CrossAccountId,430 token_id: TokenId,431 property_key: PropertyKey,432 ) -> DispatchResult {433 Self::check_token_change_permission(collection, sender, token_id, &property_key)?;434435 <TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {436 properties.remove(&property_key)437 })438 .map_err(<CommonError<T>>::from)?;439440 <PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(441 collection.id,442 token_id,443 property_key,444 ));445446 Ok(())447 }448449 fn check_token_change_permission(450 collection: &NonfungibleHandle<T>,451 sender: &T::CrossAccountId,452 token_id: TokenId,453 property_key: &PropertyKey,454 ) -> DispatchResult {455 let permission = <PalletCommon<T>>::property_permissions(collection.id)456 .get(property_key)457 .cloned()458 .unwrap_or_else(PropertyPermission::none);459460 let token_data = <TokenData<T>>::get((collection.id, token_id))461 .ok_or(<CommonError<T>>::TokenNotFound)?;462463 let check_token_owner = || -> DispatchResult {464 ensure!(&token_data.owner == sender, <CommonError<T>>::NoPermission);465 Ok(())466 };467468 let is_property_exists = TokenProperties::<T>::get((collection.id, token_id))469 .get(property_key)470 .is_some();471472 match permission {473 PropertyPermission { mutable: false, .. } if is_property_exists => {474 Err(<CommonError<T>>::NoPermission.into())475 }476477 PropertyPermission {478 collection_admin,479 token_owner,480 ..481 } => {482 let mut check_result = Err(<CommonError<T>>::NoPermission.into());483484 if collection_admin {485 check_result = collection.check_is_owner_or_admin(sender);486 }487488 if token_owner {489 check_result.or_else(|_| check_token_owner())490 } else {491 check_result492 }493 }494 }495 }496497 #[transactional]498 pub fn delete_token_properties(499 collection: &NonfungibleHandle<T>,500 sender: &T::CrossAccountId,501 token_id: TokenId,502 property_keys: Vec<PropertyKey>,503 ) -> DispatchResult {504 for key in property_keys {505 Self::delete_token_property(collection, sender, token_id, key)?;506 }507508 Ok(())509 }510511 pub fn set_collection_properties(512 collection: &NonfungibleHandle<T>,513 sender: &T::CrossAccountId,514 properties: Vec<Property>,515 ) -> DispatchResult {516 <PalletCommon<T>>::set_collection_properties(collection, sender, properties)517 }518519 pub fn delete_collection_properties(520 collection: &CollectionHandle<T>,521 sender: &T::CrossAccountId,522 property_keys: Vec<PropertyKey>,523 ) -> DispatchResult {524 <PalletCommon<T>>::delete_collection_properties(collection, sender, property_keys)525 }526527 pub fn set_property_permissions(528 collection: &CollectionHandle<T>,529 sender: &T::CrossAccountId,530 property_permissions: Vec<PropertyKeyPermission>,531 ) -> DispatchResult {532 <PalletCommon<T>>::set_property_permissions(collection, sender, property_permissions)533 }534535 pub fn set_property_permission(536 collection: &CollectionHandle<T>,537 sender: &T::CrossAccountId,538 permission: PropertyKeyPermission,539 ) -> DispatchResult {540 <PalletCommon<T>>::set_property_permission(collection, sender, permission)541 }542543 pub fn transfer(544 collection: &NonfungibleHandle<T>,545 from: &T::CrossAccountId,546 to: &T::CrossAccountId,547 token: TokenId,548 nesting_budget: &dyn Budget,549 ) -> DispatchResult {550 ensure!(551 collection.limits.transfers_enabled(),552 <CommonError<T>>::TransferNotAllowed553 );554555 let token_data =556 <TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;557 // TODO: require sender to be token, owner, require admins to go through transfer_from558 ensure!(559 &token_data.owner == from560 || (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(from)),561 <CommonError<T>>::NoPermission562 );563564 if collection.permissions.access() == AccessMode::AllowList {565 collection.check_allowlist(from)?;566 collection.check_allowlist(to)?;567 }568 <PalletCommon<T>>::ensure_correct_receiver(to)?;569570 let balance_from = <AccountBalance<T>>::get((collection.id, from))571 .checked_sub(1)572 .ok_or(<CommonError<T>>::TokenValueTooLow)?;573 let balance_to = if from != to {574 let balance_to = <AccountBalance<T>>::get((collection.id, to))575 .checked_add(1)576 .ok_or(ArithmeticError::Overflow)?;577578 ensure!(579 balance_to < collection.limits.account_token_ownership_limit(),580 <CommonError<T>>::AccountTokenLimitExceeded,581 );582583 Some(balance_to)584 } else {585 None586 };587588 <PalletStructure<T>>::try_nest_if_sent_to_token(589 from.clone(),590 to,591 collection.id,592 token,593 nesting_budget594 )?;595596 // =========597598 <TokenData<T>>::insert(599 (collection.id, token),600 ItemData {601 owner: to.clone(),602 ..token_data603 },604 );605606 if let Some(balance_to) = balance_to {607 // from != to608 if balance_from == 0 {609 <AccountBalance<T>>::remove((collection.id, from));610 } else {611 <AccountBalance<T>>::insert((collection.id, from), balance_from);612 }613 <AccountBalance<T>>::insert((collection.id, to), balance_to);614 <Owned<T>>::remove((collection.id, from, token));615 <Owned<T>>::insert((collection.id, to, token), true);616 }617 Self::set_allowance_unchecked(collection, from, token, None, true);618619 <PalletEvm<T>>::deposit_log(620 ERC721Events::Transfer {621 from: *from.as_eth(),622 to: *to.as_eth(),623 token_id: token.into(),624 }625 .to_log(collection_id_to_address(collection.id)),626 );627 <PalletCommon<T>>::deposit_event(CommonEvent::Transfer(628 collection.id,629 token,630 from.clone(),631 to.clone(),632 1,633 ));634 Ok(())635 }636637 pub fn create_multiple_items(638 collection: &NonfungibleHandle<T>,639 sender: &T::CrossAccountId,640 data: Vec<CreateItemData<T>>,641 nesting_budget: &dyn Budget,642 ) -> DispatchResult {643 if !collection.is_owner_or_admin(sender) {644 ensure!(645 collection.permissions.mint_mode(),646 <CommonError<T>>::PublicMintingNotAllowed647 );648 collection.check_allowlist(sender)?;649650 for item in data.iter() {651 collection.check_allowlist(&item.owner)?;652 }653 }654655 for data in data.iter() {656 <PalletCommon<T>>::ensure_correct_receiver(&data.owner)?;657 }658659 let first_token = <TokensMinted<T>>::get(collection.id);660 let tokens_minted = first_token661 .checked_add(data.len() as u32)662 .ok_or(ArithmeticError::Overflow)?;663 ensure!(664 tokens_minted <= collection.limits.token_limit(),665 <CommonError<T>>::CollectionTokenLimitExceeded666 );667668 let mut balances = BTreeMap::new();669 for data in &data {670 let balance = balances671 .entry(&data.owner)672 .or_insert_with(|| <AccountBalance<T>>::get((collection.id, &data.owner)));673 *balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;674675 ensure!(676 *balance <= collection.limits.account_token_ownership_limit(),677 <CommonError<T>>::AccountTokenLimitExceeded,678 );679 }680681 for (i, data) in data.iter().enumerate() {682 let token = TokenId(first_token + i as u32 + 1);683684 <PalletStructure<T>>::check_nesting(685 sender.clone(),686 &data.owner,687 collection.id,688 token,689 nesting_budget,690 )?;691 }692693 // =========694695 with_transaction(|| {696 for (i, data) in data.iter().enumerate() {697 let token = first_token + i as u32 + 1;698699 <TokenData<T>>::insert(700 (collection.id, token),701 ItemData {702 // const_data: data.const_data.clone(),703 owner: data.owner.clone(),704 },705 );706707 <PalletStructure<T>>::nest_if_sent_to_token(&data.owner, collection.id, TokenId(token));708709 if let Err(e) = Self::set_token_properties(710 collection,711 sender,712 TokenId(token),713 data.properties.clone().into_inner(),714 ) {715 return TransactionOutcome::Rollback(Err(e));716 }717 }718 TransactionOutcome::Commit(Ok(()))719 })?;720721 <TokensMinted<T>>::insert(collection.id, tokens_minted);722 for (account, balance) in balances {723 <AccountBalance<T>>::insert((collection.id, account), balance);724 }725 for (i, data) in data.into_iter().enumerate() {726 let token = first_token + i as u32 + 1;727 <Owned<T>>::insert((collection.id, &data.owner, token), true);728729 <PalletEvm<T>>::deposit_log(730 ERC721Events::Transfer {731 from: H160::default(),732 to: *data.owner.as_eth(),733 token_id: token.into(),734 }735 .to_log(collection_id_to_address(collection.id)),736 );737 <PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(738 collection.id,739 TokenId(token),740 data.owner.clone(),741 1,742 ));743 }744 Ok(())745 }746747 pub fn set_allowance_unchecked(748 collection: &NonfungibleHandle<T>,749 sender: &T::CrossAccountId,750 token: TokenId,751 spender: Option<&T::CrossAccountId>,752 assume_implicit_eth: bool,753 ) {754 if let Some(spender) = spender {755 let old_spender = <Allowance<T>>::get((collection.id, token));756 <Allowance<T>>::insert((collection.id, token), spender);757 // In ERC721 there is only one possible approved user of token, so we set758 // approved user to spender759 <PalletEvm<T>>::deposit_log(760 ERC721Events::Approval {761 owner: *sender.as_eth(),762 approved: *spender.as_eth(),763 token_id: token.into(),764 }765 .to_log(collection_id_to_address(collection.id)),766 );767 // In Unique chain, any token can have any amount of approved users, so we need to768 // set allowance of old owner to 0, and allowance of new owner to 1769 if old_spender.as_ref() != Some(spender) {770 if let Some(old_owner) = old_spender {771 <PalletCommon<T>>::deposit_event(CommonEvent::Approved(772 collection.id,773 token,774 sender.clone(),775 old_owner,776 0,777 ));778 }779 <PalletCommon<T>>::deposit_event(CommonEvent::Approved(780 collection.id,781 token,782 sender.clone(),783 spender.clone(),784 1,785 ));786 }787 } else {788 let old_spender = <Allowance<T>>::take((collection.id, token));789 if !assume_implicit_eth {790 // In ERC721 there is only one possible approved user of token, so we set791 // approved user to zero address792 <PalletEvm<T>>::deposit_log(793 ERC721Events::Approval {794 owner: *sender.as_eth(),795 approved: H160::default(),796 token_id: token.into(),797 }798 .to_log(collection_id_to_address(collection.id)),799 );800 }801 // In Unique chain, any token can have any amount of approved users, so we need to802 // set allowance of old owner to 0803 if let Some(old_spender) = old_spender {804 <PalletCommon<T>>::deposit_event(CommonEvent::Approved(805 collection.id,806 token,807 sender.clone(),808 old_spender,809 0,810 ));811 }812 }813 }814815 pub fn set_allowance(816 collection: &NonfungibleHandle<T>,817 sender: &T::CrossAccountId,818 token: TokenId,819 spender: Option<&T::CrossAccountId>,820 ) -> DispatchResult {821 if collection.permissions.access() == AccessMode::AllowList {822 collection.check_allowlist(sender)?;823 if let Some(spender) = spender {824 collection.check_allowlist(spender)?;825 }826 }827828 if let Some(spender) = spender {829 <PalletCommon<T>>::ensure_correct_receiver(spender)?;830 }831 let token_data =832 <TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;833 if &token_data.owner != sender {834 ensure!(835 collection.ignores_owned_amount(sender),836 <CommonError<T>>::CantApproveMoreThanOwned837 );838 }839840 // =========841842 Self::set_allowance_unchecked(collection, sender, token, spender, false);843 Ok(())844 }845846 fn check_allowed(847 collection: &NonfungibleHandle<T>,848 spender: &T::CrossAccountId,849 from: &T::CrossAccountId,850 token: TokenId,851 nesting_budget: &dyn Budget,852 ) -> DispatchResult {853 if spender.conv_eq(from) {854 return Ok(());855 }856 if collection.permissions.access() == AccessMode::AllowList {857 // `from`, `to` checked in [`transfer`]858 collection.check_allowlist(spender)?;859 }860 if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) {861 // TODO: should collection owner be allowed to perform this transfer?862 ensure!(863 <PalletStructure<T>>::check_indirectly_owned(864 spender.clone(),865 source.0,866 source.1,867 None,868 nesting_budget869 )?,870 <CommonError<T>>::ApprovedValueTooLow,871 );872 return Ok(());873 }874 if <Allowance<T>>::get((collection.id, token)).as_ref() == Some(spender) {875 return Ok(());876 }877 ensure!(878 collection.ignores_allowance(spender),879 <CommonError<T>>::ApprovedValueTooLow880 );881 Ok(())882 }883884 pub fn transfer_from(885 collection: &NonfungibleHandle<T>,886 spender: &T::CrossAccountId,887 from: &T::CrossAccountId,888 to: &T::CrossAccountId,889 token: TokenId,890 nesting_budget: &dyn Budget,891 ) -> DispatchResult {892 Self::check_allowed(collection, spender, from, token, nesting_budget)?;893894 // =========895896 // Allowance is reset in [`transfer`]897 Self::transfer(collection, from, to, token, nesting_budget)898 }899900 pub fn burn_from(901 collection: &NonfungibleHandle<T>,902 spender: &T::CrossAccountId,903 from: &T::CrossAccountId,904 token: TokenId,905 nesting_budget: &dyn Budget,906 ) -> DispatchResult {907 Self::check_allowed(collection, spender, from, token, nesting_budget)?;908909 // =========910911 Self::burn(collection, from, token)912 }913914 pub fn check_nesting(915 handle: &NonfungibleHandle<T>,916 sender: T::CrossAccountId,917 from: (CollectionId, TokenId),918 under: TokenId,919 nesting_budget: &dyn Budget,920 ) -> DispatchResult {921 fn ensure_sender_allowed<T: Config>(922 collection: CollectionId,923 token: TokenId,924 for_nest: (CollectionId, TokenId),925 sender: T::CrossAccountId,926 budget: &dyn Budget,927 ) -> DispatchResult {928 ensure!(929 <PalletStructure<T>>::check_indirectly_owned(930 sender,931 collection,932 token,933 Some(for_nest),934 budget935 )?,936 <CommonError<T>>::OnlyOwnerAllowedToNest,937 );938 Ok(())939 }940 match handle.permissions.nesting() {941 NestingRule::Disabled => fail!(<CommonError<T>>::NestingIsDisabled),942 NestingRule::Owner => {943 ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?944 }945 NestingRule::OwnerRestricted(whitelist) => {946 ensure!(947 whitelist.contains(&from.0),948 <CommonError<T>>::SourceCollectionIsNotAllowedToNest949 );950 ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?951 }952 }953 Ok(())954 }955956 fn nest(957 under: (CollectionId, TokenId),958 to_nest: (CollectionId, TokenId),959 ) {960 <TokenChildren<T>>::insert(961 (under.0, under.1, (to_nest.0, to_nest.1)),962 true963 );964 }965966 fn unnest(967 under: (CollectionId, TokenId),968 to_unnest: (CollectionId, TokenId),969 ) {970 <TokenChildren<T>>::remove(971 (under.0, under.1, to_unnest)972 );973 }974975 fn collection_has_nested_tokens(collection_id: CollectionId) -> bool {976 <TokenChildren<T>>::iter_prefix((collection_id,)).next().is_some()977 }978979 fn token_has_children(collection_id: CollectionId, token_id: TokenId) -> bool {980 <TokenChildren<T>>::iter_prefix((collection_id, token_id)).next().is_some()981 }982983 /// Delegated to `create_multiple_items`984 pub fn create_item(985 collection: &NonfungibleHandle<T>,986 sender: &T::CrossAccountId,987 data: CreateItemData<T>,988 nesting_budget: &dyn Budget,989 ) -> DispatchResult {990 Self::create_multiple_items(collection, sender, vec![data], nesting_budget)991 }992}