1#![cfg_attr(not(feature = "std"), no_std)]23use erc::ERC721Events;4use frame_support::{BoundedVec, ensure};5use up_data_structs::{6 AccessMode, Collection, CollectionId, CustomDataLimit, TokenId, CreateCollectionData,7};8use pallet_common::{9 Error as CommonError, Pallet as PalletCommon, Event as CommonEvent, account::CrossAccountId,10};11use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};12use sp_core::H160;13use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};14use sp_std::{vec::Vec, vec};15use core::ops::Deref;16use sp_std::collections::btree_map::BTreeMap;17use codec::{Encode, Decode, MaxEncodedLen};18use scale_info::TypeInfo;1920pub use pallet::*;21#[cfg(feature = "runtime-benchmarks")]22pub mod benchmarking;23pub mod common;24pub mod erc;25pub mod weights;2627pub struct CreateItemData<T: Config> {28 pub const_data: BoundedVec<u8, CustomDataLimit>,29 pub variable_data: BoundedVec<u8, CustomDataLimit>,30 pub owner: T::CrossAccountId,31}32pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;3334#[derive(Encode, Decode, TypeInfo, MaxEncodedLen)]35pub struct ItemData<CrossAccountId> {36 pub const_data: BoundedVec<u8, CustomDataLimit>,37 pub variable_data: BoundedVec<u8, CustomDataLimit>,38 pub owner: CrossAccountId,39}4041#[frame_support::pallet]42pub mod pallet {43 use super::*;44 use frame_support::{Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key};45 use up_data_structs::{CollectionId, TokenId};46 use super::weights::WeightInfo;4748 #[pallet::error]49 pub enum Error<T> {50 51 NotNonfungibleDataUsedToMintFungibleCollectionToken,52 53 NonfungibleItemsHaveNoAmount,54 }5556 #[pallet::config]57 pub trait Config: frame_system::Config + pallet_common::Config {58 type WeightInfo: WeightInfo;59 }6061 #[pallet::pallet]62 #[pallet::generate_store(pub(super) trait Store)]63 pub struct Pallet<T>(_);6465 #[pallet::storage]66 pub type TokensMinted<T: Config> =67 StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;68 #[pallet::storage]69 pub type TokensBurnt<T: Config> =70 StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u32, QueryKind = ValueQuery>;7172 #[pallet::storage]73 pub type TokenData<T: Config> = StorageNMap<74 Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),75 Value = ItemData<T::CrossAccountId>,76 QueryKind = OptionQuery,77 >;7879 80 #[pallet::storage]81 pub type Owned<T: Config> = StorageNMap<82 Key = (83 Key<Twox64Concat, CollectionId>,84 Key<Blake2_128Concat, T::CrossAccountId>,85 Key<Twox64Concat, TokenId>,86 ),87 Value = bool,88 QueryKind = ValueQuery,89 >;9091 #[pallet::storage]92 pub type AccountBalance<T: Config> = StorageNMap<93 Key = (94 Key<Twox64Concat, CollectionId>,95 Key<Blake2_128Concat, T::CrossAccountId>,96 ),97 Value = u32,98 QueryKind = ValueQuery,99 >;100101 #[pallet::storage]102 pub type Allowance<T: Config> = StorageNMap<103 Key = (Key<Twox64Concat, CollectionId>, Key<Twox64Concat, TokenId>),104 Value = T::CrossAccountId,105 QueryKind = OptionQuery,106 >;107}108109pub struct NonfungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);110impl<T: Config> NonfungibleHandle<T> {111 pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {112 Self(inner)113 }114 pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {115 self.0116 }117}118impl<T: Config> WithRecorder<T> for NonfungibleHandle<T> {119 fn recorder(&self) -> &SubstrateRecorder<T> {120 self.0.recorder()121 }122 fn into_recorder(self) -> SubstrateRecorder<T> {123 self.0.into_recorder()124 }125}126impl<T: Config> Deref for NonfungibleHandle<T> {127 type Target = pallet_common::CollectionHandle<T>;128129 fn deref(&self) -> &Self::Target {130 &self.0131 }132}133134impl<T: Config> Pallet<T> {135 pub fn total_supply(collection: &NonfungibleHandle<T>) -> u32 {136 <TokensMinted<T>>::get(collection.id) - <TokensBurnt<T>>::get(collection.id)137 }138 pub fn token_exists(collection: &NonfungibleHandle<T>, token: TokenId) -> bool {139 <TokenData<T>>::contains_key((collection.id, token))140 }141}142143144impl<T: Config> Pallet<T> {145 pub fn init_collection(146 owner: T::AccountId,147 data: CreateCollectionData<T::AccountId>,148 ) -> Result<CollectionId, DispatchError> {149 <PalletCommon<T>>::init_collection(owner, data)150 }151 pub fn destroy_collection(152 collection: NonfungibleHandle<T>,153 sender: &T::CrossAccountId,154 ) -> DispatchResult {155 let id = collection.id;156157 158159 PalletCommon::destroy_collection(collection.0, sender)?;160161 <TokenData<T>>::remove_prefix((id,), None);162 <Owned<T>>::remove_prefix((id,), None);163 <TokensMinted<T>>::remove(id);164 <TokensBurnt<T>>::remove(id);165 <Allowance<T>>::remove_prefix((id,), None);166 <AccountBalance<T>>::remove_prefix((id,), None);167 Ok(())168 }169170 pub fn burn(171 collection: &NonfungibleHandle<T>,172 sender: &T::CrossAccountId,173 token: TokenId,174 ) -> DispatchResult {175 let token_data =176 <TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;177 ensure!(178 &token_data.owner == sender179 || (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(sender)),180 <CommonError<T>>::NoPermission181 );182183 if collection.access == AccessMode::AllowList {184 collection.check_allowlist(sender)?;185 }186187 let burnt = <TokensBurnt<T>>::get(collection.id)188 .checked_add(1)189 .ok_or(ArithmeticError::Overflow)?;190191 let balance = <AccountBalance<T>>::get((collection.id, token_data.owner.clone()))192 .checked_sub(1)193 .ok_or(ArithmeticError::Overflow)?;194195 if balance == 0 {196 <AccountBalance<T>>::remove((collection.id, token_data.owner.clone()));197 } else {198 <AccountBalance<T>>::insert((collection.id, token_data.owner.clone()), balance);199 }200 201202 <Owned<T>>::remove((collection.id, &token_data.owner, token));203 <TokensBurnt<T>>::insert(collection.id, burnt);204 <TokenData<T>>::remove((collection.id, token));205 let old_spender = <Allowance<T>>::take((collection.id, token));206207 if let Some(old_spender) = old_spender {208 <PalletCommon<T>>::deposit_event(CommonEvent::Approved(209 collection.id,210 token,211 sender.clone(),212 old_spender,213 0,214 ));215 }216217 collection.log_mirrored(ERC721Events::Transfer {218 from: *token_data.owner.as_eth(),219 to: H160::default(),220 token_id: token.into(),221 });222 <PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(223 collection.id,224 token,225 token_data.owner,226 1,227 ));228 Ok(())229 }230231 pub fn transfer(232 collection: &NonfungibleHandle<T>,233 from: &T::CrossAccountId,234 to: &T::CrossAccountId,235 token: TokenId,236 ) -> DispatchResult {237 ensure!(238 collection.limits.transfers_enabled(),239 <CommonError<T>>::TransferNotAllowed240 );241242 let token_data =243 <TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;244 ensure!(245 &token_data.owner == from246 || (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(from)),247 <CommonError<T>>::NoPermission248 );249250 if collection.access == AccessMode::AllowList {251 collection.check_allowlist(from)?;252 collection.check_allowlist(to)?;253 }254 <PalletCommon<T>>::ensure_correct_receiver(to)?;255256 let balance_from = <AccountBalance<T>>::get((collection.id, from))257 .checked_sub(1)258 .ok_or(<CommonError<T>>::TokenValueTooLow)?;259 let balance_to = if from != to {260 let balance_to = <AccountBalance<T>>::get((collection.id, to))261 .checked_add(1)262 .ok_or(ArithmeticError::Overflow)?;263264 ensure!(265 balance_to < collection.limits.account_token_ownership_limit(),266 <CommonError<T>>::AccountTokenLimitExceeded,267 );268269 Some(balance_to)270 } else {271 None272 };273274 275276 <TokenData<T>>::insert(277 (collection.id, token),278 ItemData {279 owner: to.clone(),280 ..token_data281 },282 );283284 if let Some(balance_to) = balance_to {285 286 if balance_from == 0 {287 <AccountBalance<T>>::remove((collection.id, from));288 } else {289 <AccountBalance<T>>::insert((collection.id, from), balance_from);290 }291 <AccountBalance<T>>::insert((collection.id, to), balance_to);292 <Owned<T>>::remove((collection.id, from, token));293 <Owned<T>>::insert((collection.id, to, token), true);294 }295 Self::set_allowance_unchecked(collection, from, token, None, true);296297 collection.log_mirrored(ERC721Events::Transfer {298 from: *from.as_eth(),299 to: *to.as_eth(),300 token_id: token.into(),301 });302 <PalletCommon<T>>::deposit_event(CommonEvent::Transfer(303 collection.id,304 token,305 from.clone(),306 to.clone(),307 1,308 ));309 Ok(())310 }311312 pub fn create_multiple_items(313 collection: &NonfungibleHandle<T>,314 sender: &T::CrossAccountId,315 data: Vec<CreateItemData<T>>,316 ) -> DispatchResult {317 if !collection.is_owner_or_admin(sender) {318 ensure!(319 collection.mint_mode,320 <CommonError<T>>::PublicMintingNotAllowed321 );322 collection.check_allowlist(sender)?;323324 for item in data.iter() {325 collection.check_allowlist(&item.owner)?;326 }327 }328329 for data in data.iter() {330 <PalletCommon<T>>::ensure_correct_receiver(&data.owner)?;331 }332333 let first_token = <TokensMinted<T>>::get(collection.id);334 let tokens_minted = first_token335 .checked_add(data.len() as u32)336 .ok_or(ArithmeticError::Overflow)?;337 ensure!(338 tokens_minted <= collection.limits.token_limit(),339 <CommonError<T>>::CollectionTokenLimitExceeded340 );341342 let mut balances = BTreeMap::new();343 for data in &data {344 let balance = balances345 .entry(&data.owner)346 .or_insert_with(|| <AccountBalance<T>>::get((collection.id, &data.owner)));347 *balance = balance.checked_add(1).ok_or(ArithmeticError::Overflow)?;348349 ensure!(350 *balance <= collection.limits.account_token_ownership_limit(),351 <CommonError<T>>::AccountTokenLimitExceeded,352 );353 }354355 356357 <TokensMinted<T>>::insert(collection.id, tokens_minted);358 for (account, balance) in balances {359 <AccountBalance<T>>::insert((collection.id, account), balance);360 }361 for (i, data) in data.into_iter().enumerate() {362 let token = first_token + i as u32 + 1;363364 <TokenData<T>>::insert(365 (collection.id, token),366 ItemData {367 const_data: data.const_data,368 variable_data: data.variable_data,369 owner: data.owner.clone(),370 },371 );372 <Owned<T>>::insert((collection.id, &data.owner, token), true);373374 collection.log_mirrored(ERC721Events::Transfer {375 from: H160::default(),376 to: *data.owner.as_eth(),377 token_id: token.into(),378 });379 <PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(380 collection.id,381 TokenId(token),382 data.owner.clone(),383 1,384 ));385 }386 Ok(())387 }388389 pub fn set_allowance_unchecked(390 collection: &NonfungibleHandle<T>,391 sender: &T::CrossAccountId,392 token: TokenId,393 spender: Option<&T::CrossAccountId>,394 assume_implicit_eth: bool,395 ) {396 if let Some(spender) = spender {397 let old_spender = <Allowance<T>>::get((collection.id, token));398 <Allowance<T>>::insert((collection.id, token), spender);399 400 401 collection.log_mirrored(ERC721Events::Approval {402 owner: *sender.as_eth(),403 approved: *spender.as_eth(),404 token_id: token.into(),405 });406 407 408 if old_spender.as_ref() != Some(spender) {409 if let Some(old_owner) = old_spender {410 <PalletCommon<T>>::deposit_event(CommonEvent::Approved(411 collection.id,412 token,413 sender.clone(),414 old_owner,415 0,416 ));417 }418 <PalletCommon<T>>::deposit_event(CommonEvent::Approved(419 collection.id,420 token,421 sender.clone(),422 spender.clone(),423 1,424 ));425 }426 } else {427 let old_spender = <Allowance<T>>::take((collection.id, token));428 if !assume_implicit_eth {429 430 431 collection.log_mirrored(ERC721Events::Approval {432 owner: *sender.as_eth(),433 approved: H160::default(),434 token_id: token.into(),435 });436 }437 438 439 if let Some(old_spender) = old_spender {440 <PalletCommon<T>>::deposit_event(CommonEvent::Approved(441 collection.id,442 token,443 sender.clone(),444 old_spender,445 0,446 ));447 }448 }449 }450451 pub fn set_allowance(452 collection: &NonfungibleHandle<T>,453 sender: &T::CrossAccountId,454 token: TokenId,455 spender: Option<&T::CrossAccountId>,456 ) -> DispatchResult {457 if collection.access == AccessMode::AllowList {458 collection.check_allowlist(sender)?;459 if let Some(spender) = spender {460 collection.check_allowlist(spender)?;461 }462 }463464 if let Some(spender) = spender {465 <PalletCommon<T>>::ensure_correct_receiver(spender)?;466 }467 let token_data =468 <TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;469 if &token_data.owner != sender {470 ensure!(471 collection.ignores_owned_amount(sender),472 <CommonError<T>>::CantApproveMoreThanOwned473 );474 }475476 477478 Self::set_allowance_unchecked(collection, sender, token, spender, false);479 Ok(())480 }481482 pub fn transfer_from(483 collection: &NonfungibleHandle<T>,484 spender: &T::CrossAccountId,485 from: &T::CrossAccountId,486 to: &T::CrossAccountId,487 token: TokenId,488 ) -> DispatchResult {489 if spender.conv_eq(from) {490 return Self::transfer(collection, from, to, token);491 }492 if collection.access == AccessMode::AllowList {493 494 collection.check_allowlist(spender)?;495 }496497 if <Allowance<T>>::get((collection.id, token)).as_ref() != Some(spender) {498 ensure!(499 collection.ignores_allowance(spender),500 <CommonError<T>>::TokenValueNotEnough501 );502 }503504 505506 Self::transfer(collection, from, to, token)?;507 508 Ok(())509 }510511 pub fn burn_from(512 collection: &NonfungibleHandle<T>,513 spender: &T::CrossAccountId,514 from: &T::CrossAccountId,515 token: TokenId,516 ) -> DispatchResult {517 if spender.conv_eq(from) {518 return Self::burn(collection, from, token);519 }520 if collection.access == AccessMode::AllowList {521 522 collection.check_allowlist(spender)?;523 }524525 if <Allowance<T>>::get((collection.id, token)).as_ref() != Some(spender) {526 ensure!(527 collection.ignores_allowance(spender),528 <CommonError<T>>::TokenValueNotEnough529 );530 }531532 533534 Self::burn(collection, from, token)535 }536537 pub fn set_variable_metadata(538 collection: &NonfungibleHandle<T>,539 sender: &T::CrossAccountId,540 token: TokenId,541 data: BoundedVec<u8, CustomDataLimit>,542 ) -> DispatchResult {543 let token_data =544 <TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;545 collection.check_can_update_meta(sender, &token_data.owner)?;546547 548549 <TokenData<T>>::insert(550 (collection.id, token),551 ItemData {552 variable_data: data,553 ..token_data554 },555 );556 Ok(())557 }558559 560 pub fn create_item(561 collection: &NonfungibleHandle<T>,562 sender: &T::CrossAccountId,563 data: CreateItemData<T>,564 ) -> DispatchResult {565 Self::create_multiple_items(collection, sender, vec![data])566 }567}