123456#![recursion_limit = "1024"]7#![cfg_attr(not(feature = "std"), no_std)]8#![allow(9 clippy::too_many_arguments,10 clippy::unnecessary_mut_passed,11 clippy::unused_unit12)]1314extern crate alloc;1516pub use serde::{Serialize, Deserialize};1718pub use frame_support::{19 construct_runtime, decl_event, decl_module, decl_storage, decl_error,20 dispatch::DispatchResult,21 ensure, fail, parameter_types,22 traits::{23 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,24 Randomness, IsSubType, WithdrawReasons,25 },26 weights::{27 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},28 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,29 WeightToFeePolynomial, DispatchClass,30 },31 StorageValue, transactional,32};3334use frame_system::{self as system, ensure_signed};35use sp_core::H160;36use sp_std::vec;37use sp_runtime::{DispatchError, sp_std::prelude::Vec};38use core::ops::{Deref, DerefMut};39use nft_data_structs::{40 MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,41 CUSTOM_DATA_LIMIT, COLLECTION_NUMBER_LIMIT, ACCOUNT_TOKEN_OWNERSHIP_LIMIT,42 VARIABLE_ON_CHAIN_SCHEMA_LIMIT, CONST_ON_CHAIN_SCHEMA_LIMIT, COLLECTION_ADMINS_LIMIT,43 OFFCHAIN_SCHEMA_LIMIT, MAX_TOKEN_PREFIX_LENGTH, MAX_COLLECTION_NAME_LENGTH,44 MAX_COLLECTION_DESCRIPTION_LENGTH, AccessMode, Collection, CreateItemData, CollectionLimits,45 CollectionId, CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,46 FungibleItemType, ReFungibleItemType,47};4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod eth;56mod sponsorship;57pub use sponsorship::NftSponsorshipHandler;58pub use eth::sponsoring::NftEthSponsorshipHandler;5960pub use eth::NftErcSupport;61pub use eth::account::*;62use eth::erc::{ERC20Events, ERC721Events};6364#[cfg(feature = "runtime-benchmarks")]65mod benchmarking;66pub mod weights;67use weights::WeightInfo;6869decl_error! {70 71 pub enum Error for Module<T: Config> {72 73 TotalCollectionsLimitExceeded,74 75 CollectionDecimalPointLimitExceeded,76 77 CollectionNameLimitExceeded,78 79 CollectionDescriptionLimitExceeded,80 81 CollectionTokenPrefixLimitExceeded,82 83 CollectionNotFound,84 85 TokenNotFound,86 87 AdminNotFound,88 89 NumOverflow,90 91 AlreadyAdmin,92 93 NoPermission,94 95 ConfirmUnsetSponsorFail,96 97 PublicMintingNotAllowed,98 99 MustBeTokenOwner,100 101 TokenValueTooLow,102 103 NftSizeLimitExceeded,104 105 ApproveNotFound,106 107 TokenValueNotEnough,108 109 ApproveRequired,110 111 AddresNotInWhiteList,112 113 CollectionAdminsLimitExceeded,114 115 AddressOwnershipLimitExceeded,116 117 EmptyArgument,118 119 TokenConstDataLimitExceeded,120 121 TokenVariableDataLimitExceeded,122 123 NotNftDataUsedToMintNftCollectionToken,124 125 NotFungibleDataUsedToMintFungibleCollectionToken,126 127 NotReFungibleDataUsedToMintReFungibleCollectionToken,128 129 UnexpectedCollectionType,130 131 CantStoreMetadataInFungibleTokens,132 133 CollectionTokenLimitExceeded,134 135 AccountTokenLimitExceeded,136 137 CollectionLimitBoundsExceeded,138 139 OwnerPermissionsCantBeReverted,140 141 SchemaDataLimitExceeded,142 143 WrongRefungiblePieces,144 145 BadCreateRefungibleCall,146 147 OutOfGas,148 149 MetadataUpdateDenied,150 151 MetadataFlagFrozen,152 153 TransferNotAllowed,154 155 AddressIsZero,156 }157}158159#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]160pub struct CollectionHandle<T: Config> {161 pub id: CollectionId,162 collection: Collection<T>,163 recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,164}165impl<T: Config> CollectionHandle<T> {166 pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {167 <CollectionById<T>>::get(id).map(|collection| Self {168 id,169 collection,170 recorder: pallet_evm_coder_substrate::SubstrateRecorder::new(171 eth::collection_id_to_address(id),172 gas_limit,173 ),174 })175 }176 pub fn get(id: CollectionId) -> Option<Self> {177 Self::get_with_gas_limit(id, u64::MAX)178 }179 pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {180 self.recorder.log_sub(log)181 }182 #[allow(dead_code)]183 fn consume_gas(&self, gas: u64) -> DispatchResult {184 self.recorder.consume_gas_sub(gas)185 }186 fn consume_sload(&self) -> DispatchResult {187 self.recorder.consume_sload_sub()188 }189 fn consume_sstore(&self) -> DispatchResult {190 self.recorder.consume_sstore_sub()191 }192 pub fn submit_logs(self) -> DispatchResult {193 self.recorder.submit_logs()194 }195 pub fn save(self) -> DispatchResult {196 self.recorder.submit_logs()?;197 <CollectionById<T>>::insert(self.id, self.collection);198 Ok(())199 }200}201impl<T: Config> Deref for CollectionHandle<T> {202 type Target = Collection<T>;203204 fn deref(&self) -> &Self::Target {205 &self.collection206 }207}208209impl<T: Config> DerefMut for CollectionHandle<T> {210 fn deref_mut(&mut self) -> &mut Self::Target {211 &mut self.collection212 }213}214215pub trait Config: system::Config + pallet_evm_coder_substrate::Config + Sized {216 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;217218 219 type WeightInfo: WeightInfo;220221 type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;222 type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;223224 type CrossAccountId: CrossAccountId<Self::AccountId>;225 type Currency: Currency<Self::AccountId>;226 type CollectionCreationPrice: Get<227 <<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,228 >;229 type TreasuryAccountId: Get<Self::AccountId>;230}231232type SelfWeightOf<T> = <T as Config>::WeightInfo;233234trait WeightInfoHelpers: WeightInfo {235 fn transfer() -> Weight {236 Self::transfer_nft()237 .max(Self::transfer_fungible())238 .max(Self::transfer_refungible())239 }240 fn transfer_from() -> Weight {241 Self::transfer_from_nft()242 .max(Self::transfer_from_fungible())243 .max(Self::transfer_from_refungible())244 }245 fn approve() -> Weight {246 247 Self::approve_nft()248 }249 fn set_variable_meta_data(data: u32) -> Weight {250 251 Self::set_variable_meta_data_nft(data)252 }253 fn create_item(data: u32) -> Weight {254 Self::create_item_nft(data)255 .max(Self::create_item_fungible())256 .max(Self::create_item_refungible(data))257 }258 fn burn_item() -> Weight {259 260 Self::burn_item_nft()261 }262}263impl<T: WeightInfo> WeightInfoHelpers for T {}264265266267268269270271272273274275276277278279280281282283284285286287decl_storage! {288 trait Store for Module<T: Config> as Nft {289290 291 292 CreatedCollectionCount: u32;293 294 ChainVersion: u64;295 296 297 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;298 299300 301 302 303 DestroyedCollectionCount: u32;304 305 306 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;307 308309 310 311 312 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;313 314 315 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;316 317 318 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;319 320321 322 323 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;324325 326 327 328 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;329330 331 332 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;333 334 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;335 336 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;337 338339 340 341 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;342 343344 345 346 347 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;348 349 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;350 351 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;352 353 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;354 355356 357 358 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;359 }360 add_extra_genesis {361 build(|config: &GenesisConfig<T>| {362 363 for (_num, _c) in &config.collection_id {364 <Module<T>>::init_collection(_c);365 }366367 for (_num, _c, _i) in &config.nft_item_id {368 <Module<T>>::init_nft_token(*_c, _i);369 }370371 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {372 <Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);373 }374375 for (_num, _c, _i) in &config.refungible_item_id {376 <Module<T>>::init_refungible_token(*_c, _i);377 }378 })379 }380}381382decl_event!(383 pub enum Event<T>384 where385 AccountId = <T as frame_system::Config>::AccountId,386 CrossAccountId = <T as Config>::CrossAccountId,387 {388 389 390 391 392 393 394 395 396 397 CollectionCreated(CollectionId, u8, AccountId),398399 400 401 402 403 404 405 406 407 408 ItemCreated(CollectionId, TokenId, CrossAccountId),409410 411 412 413 414 415 416 417 ItemDestroyed(CollectionId, TokenId),418419 420 421 422 423 424 425 426 427 428 429 430 Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),431432 433 434 435 436 437 438 439 440 441 Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),442 }443);444445decl_module! {446 pub struct Module<T: Config> for enum Call447 where448 origin: T::Origin449 {450 fn deposit_event() = default;451 const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;452 type Error = Error<T>;453454 fn on_initialize(_now: T::BlockNumber) -> Weight {455 0456 }457458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 #[weight = <SelfWeightOf<T>>::create_collection()]475 #[transactional]476 pub fn create_collection(origin,477 collection_name: Vec<u16>,478 collection_description: Vec<u16>,479 token_prefix: Vec<u8>,480 mode: CollectionMode) -> DispatchResult {481482 483 let who = ensure_signed(origin)?;484485 486 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();487 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(488 &T::TreasuryAccountId::get(),489 T::CollectionCreationPrice::get(),490 ));491 <T as Config>::Currency::settle(492 &who,493 imbalance,494 WithdrawReasons::TRANSFER,495 ExistenceRequirement::KeepAlive,496 ).map_err(|_| Error::<T>::NoPermission)?;497498 let decimal_points = match mode {499 CollectionMode::Fungible(points) => points,500 _ => 0501 };502503 let created_count = CreatedCollectionCount::get();504 let destroyed_count = DestroyedCollectionCount::get();505506 507 ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);508509 510 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);511 ensure!(collection_name.len() <= MAX_COLLECTION_NAME_LENGTH, Error::<T>::CollectionNameLimitExceeded);512 ensure!(collection_description.len() <= MAX_COLLECTION_DESCRIPTION_LENGTH, Error::<T>::CollectionDescriptionLimitExceeded);513 ensure!(token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH, Error::<T>::CollectionTokenPrefixLimitExceeded);514515 516 let next_id = created_count517 .checked_add(1)518 .ok_or(Error::<T>::NumOverflow)?;519520 CreatedCollectionCount::put(next_id);521522 let limits = CollectionLimits {523 sponsored_data_size: CUSTOM_DATA_LIMIT,524 ..Default::default()525 };526527 528 let new_collection = Collection {529 owner: who.clone(),530 name: collection_name,531 mode: mode.clone(),532 mint_mode: false,533 access: AccessMode::Normal,534 description: collection_description,535 decimal_points,536 token_prefix,537 offchain_schema: Vec::new(),538 schema_version: SchemaVersion::ImageURL,539 sponsorship: SponsorshipState::Disabled,540 variable_on_chain_schema: Vec::new(),541 const_on_chain_schema: Vec::new(),542 limits,543 meta_update_permission: MetaUpdatePermission::default(),544 transfers_enabled: true,545 };546547 548 <CollectionById<T>>::insert(next_id, new_collection);549550 551 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));552553 Ok(())554 }555556 557 558 559 560 561 562 563 564 565 #[weight = <SelfWeightOf<T>>::destroy_collection()]566 #[transactional]567 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {568569 let sender = ensure_signed(origin)?;570 let collection = Self::get_collection(collection_id)?;571 Self::check_owner_permissions(&collection, &sender)?;572 if !collection.limits.owner_can_destroy {573 fail!(Error::<T>::NoPermission);574 }575576 <AddressTokens<T>>::remove_prefix(collection_id, None);577 <Allowances<T>>::remove_prefix(collection_id, None);578 <Balance<T>>::remove_prefix(collection_id, None);579 <ItemListIndex>::remove(collection_id);580 <AdminList<T>>::remove(collection_id);581 <CollectionById<T>>::remove(collection_id);582 <WhiteList<T>>::remove_prefix(collection_id, None);583584 <NftItemList<T>>::remove_prefix(collection_id, None);585 <FungibleItemList<T>>::remove_prefix(collection_id, None);586 <ReFungibleItemList<T>>::remove_prefix(collection_id, None);587588 <NftTransferBasket<T>>::remove_prefix(collection_id, None);589 <FungibleTransferBasket<T>>::remove_prefix(collection_id, None);590 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);591592 <VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);593594 DestroyedCollectionCount::put(DestroyedCollectionCount::get()595 .checked_add(1)596 .ok_or(Error::<T>::NumOverflow)?);597598 Ok(())599 }600601 602 603 604 605 606 607 608 609 610 611 612 613 #[weight = <SelfWeightOf<T>>::add_to_white_list()]614 #[transactional]615 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{616617 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);618 let collection = Self::get_collection(collection_id)?;619620 Self::toggle_white_list_internal(621 &sender,622 &collection,623 &address,624 true,625 )?;626627 Ok(())628 }629630 631 632 633 634 635 636 637 638 639 640 641 642 #[weight = <SelfWeightOf<T>>::remove_from_white_list()]643 #[transactional]644 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{645646 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);647 let collection = Self::get_collection(collection_id)?;648649 Self::toggle_white_list_internal(650 &sender,651 &collection,652 &address,653 false,654 )?;655656 Ok(())657 }658659 660 661 662 663 664 665 666 667 668 669 670 #[weight = <SelfWeightOf<T>>::set_public_access_mode()]671 #[transactional]672 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult673 {674 let sender = ensure_signed(origin)?;675676 let mut target_collection = Self::get_collection(collection_id)?;677 Self::check_owner_permissions(&target_collection, &sender)?;678 target_collection.access = mode;679 target_collection.save()680 }681682 683 684 685 686 687 688 689 690 691 692 693 694 695 #[weight = <SelfWeightOf<T>>::set_mint_permission()]696 #[transactional]697 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult698 {699 let sender = ensure_signed(origin)?;700701 let mut target_collection = Self::get_collection(collection_id)?;702 Self::check_owner_permissions(&target_collection, &sender)?;703 target_collection.mint_mode = mint_permission;704 target_collection.save()705 }706707 708 709 710 711 712 713 714 715 716 717 718 #[weight = <SelfWeightOf<T>>::change_collection_owner()]719 #[transactional]720 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {721722 let sender = ensure_signed(origin)?;723 let mut target_collection = Self::get_collection(collection_id)?;724 Self::check_owner_permissions(&target_collection, &sender)?;725 target_collection.owner = new_owner;726 target_collection.save()727 }728729 730 731 732 733 734 735 736 737 738 739 740 741 742 #[weight = <SelfWeightOf<T>>::add_collection_admin()]743 #[transactional]744 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {745 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);746 let collection = Self::get_collection(collection_id)?;747 Self::check_owner_or_admin_permissions(&collection, &sender)?;748 let mut admin_arr = <AdminList<T>>::get(collection_id);749750 match admin_arr.binary_search(&new_admin_id) {751 Ok(_) => {},752 Err(idx) => {753 ensure!(admin_arr.len() < COLLECTION_ADMINS_LIMIT as usize, Error::<T>::CollectionAdminsLimitExceeded);754 admin_arr.insert(idx, new_admin_id);755 <AdminList<T>>::insert(collection_id, admin_arr);756 }757 }758 Ok(())759 }760761 762 763 764 765 766 767 768 769 770 771 772 773 #[weight = <SelfWeightOf<T>>::remove_collection_admin()]774 #[transactional]775 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {776 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);777 let collection = Self::get_collection(collection_id)?;778 Self::check_owner_or_admin_permissions(&collection, &sender)?;779 let mut admin_arr = <AdminList<T>>::get(collection_id);780781 if let Ok(idx) = admin_arr.binary_search(&account_id) {782 admin_arr.remove(idx);783 <AdminList<T>>::insert(collection_id, admin_arr);784 }785 Ok(())786 }787788 789 790 791 792 793 794 795 796 797 #[weight = <SelfWeightOf<T>>::set_collection_sponsor()]798 #[transactional]799 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {800 let sender = ensure_signed(origin)?;801 let mut target_collection = Self::get_collection(collection_id)?;802 Self::check_owner_permissions(&target_collection, &sender)?;803804 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);805 target_collection.save()806 }807808 809 810 811 812 813 814 815 #[weight = <SelfWeightOf<T>>::confirm_sponsorship()]816 #[transactional]817 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {818 let sender = ensure_signed(origin)?;819820 let mut target_collection = Self::get_collection(collection_id)?;821 ensure!(822 target_collection.sponsorship.pending_sponsor() == Some(&sender),823 Error::<T>::ConfirmUnsetSponsorFail824 );825826 target_collection.sponsorship = SponsorshipState::Confirmed(sender);827 target_collection.save()828 }829830 831 832 833 834 835 836 837 838 839 #[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]840 #[transactional]841 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {842 let sender = ensure_signed(origin)?;843844 let mut target_collection = Self::get_collection(collection_id)?;845 Self::check_owner_permissions(&target_collection, &sender)?;846847 target_collection.sponsorship = SponsorshipState::Disabled;848 target_collection.save()849 }850851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874875 #[weight = <SelfWeightOf<T>>::create_item(data.data_size() as u32)]876 #[transactional]877 pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {878 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);879 let collection = Self::get_collection(collection_id)?;880881 Self::create_item_internal(&sender, &collection, &owner, data)?;882883 collection.submit_logs()884 }885886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 #[weight = <SelfWeightOf<T>>::create_item(items_data.iter()905 .map(|data| { data.data_size() as u32 })906 .sum())]907 #[transactional]908 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {909910 ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);911 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);912 let collection = Self::get_collection(collection_id)?;913914 Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;915916 collection.submit_logs()917 }918919 920921 922 923 924 925 926 927 928 929 930 931 932 #[weight = <SelfWeightOf<T>>::burn_item()]933 #[transactional]934 pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {935936 let sender = ensure_signed(origin)?;937 let mut target_collection = Self::get_collection(collection_id)?;938939 Self::check_owner_permissions(&target_collection, &sender)?;940941 target_collection.transfers_enabled = value;942 target_collection.save()943 }944945 946 947 948 949 950 951 952 953 954 955 956 957 #[weight = <T as Config>::WeightInfo::burn_item()]958 #[transactional]959 pub fn set_meta_update_permission_flag(origin, collection_id: CollectionId, value: MetaUpdatePermission) -> DispatchResult {960961 let sender = ensure_signed(origin)?;962 let mut target_collection = Self::get_collection(collection_id)?;963964 ensure!(965 target_collection.meta_update_permission != MetaUpdatePermission::None,966 Error::<T>::MetadataFlagFrozen967 );968 Self::check_owner_permissions(&target_collection, &sender)?;969970 target_collection.meta_update_permission = value;971 Self::save_collection(target_collection);972973 Ok(())974 }975976 977 978 979 980 981 982 983 984 985 986 987 988 989 #[weight = <SelfWeightOf<T>>::burn_item()]990 #[transactional]991 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {992993 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);994 let target_collection = Self::get_collection(collection_id)?;995996 Self::burn_item_internal(&sender, &target_collection, item_id, value)?;997998 target_collection.submit_logs()999 }10001001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 #[weight = <SelfWeightOf<T>>::transfer()]1025 #[transactional]1026 pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1027 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1028 let collection = Self::get_collection(collection_id)?;10291030 Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;10311032 collection.submit_logs()1033 }10341035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 #[weight = <SelfWeightOf<T>>::approve()]1051 #[transactional]1052 pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1053 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1054 let collection = Self::get_collection(collection_id)?;10551056 Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10571058 collection.submit_logs()1059 }10601061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 #[weight = <SelfWeightOf<T>>::transfer_from()]1081 #[transactional]1082 pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1083 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1084 let collection = Self::get_collection(collection_id)?;10851086 Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10871088 collection.submit_logs()1089 }1090 1091 1092 1093 1094 10951096 10971098 10991100 1101 11021103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 #[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]1116 #[transactional]1117 pub fn set_variable_meta_data (1118 origin,1119 collection_id: CollectionId,1120 item_id: TokenId,1121 data: Vec<u8>1122 ) -> DispatchResult {1123 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);11241125 let collection = Self::get_collection(collection_id)?;11261127 Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;11281129 Ok(())1130 }11311132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 #[weight = <SelfWeightOf<T>>::set_schema_version()]1147 #[transactional]1148 pub fn set_schema_version(1149 origin,1150 collection_id: CollectionId,1151 version: SchemaVersion1152 ) -> DispatchResult {1153 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1154 let mut target_collection = Self::get_collection(collection_id)?;1155 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1156 target_collection.schema_version = version;1157 target_collection.save()1158 }11591160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 #[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]1173 #[transactional]1174 pub fn set_offchain_schema(1175 origin,1176 collection_id: CollectionId,1177 schema: Vec<u8>1178 ) -> DispatchResult {1179 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1180 let mut target_collection = Self::get_collection(collection_id)?;1181 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11821183 1184 ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");11851186 target_collection.offchain_schema = schema;1187 target_collection.save()1188 }11891190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1203 #[transactional]1204 pub fn set_const_on_chain_schema (1205 origin,1206 collection_id: CollectionId,1207 schema: Vec<u8>1208 ) -> DispatchResult {1209 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1210 let mut target_collection = Self::get_collection(collection_id)?;1211 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12121213 1214 ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");12151216 target_collection.const_on_chain_schema = schema;1217 target_collection.save()1218 }12191220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1233 #[transactional]1234 pub fn set_variable_on_chain_schema (1235 origin,1236 collection_id: CollectionId,1237 schema: Vec<u8>1238 ) -> DispatchResult {1239 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1240 let mut target_collection = Self::get_collection(collection_id)?;1241 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12421243 1244 ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");12451246 target_collection.variable_on_chain_schema = schema;1247 target_collection.save()1248 }12491250 #[weight = <SelfWeightOf<T>>::set_collection_limits()]1251 #[transactional]1252 pub fn set_collection_limits(1253 origin,1254 collection_id: u32,1255 new_limits: CollectionLimits<T::BlockNumber>,1256 ) -> DispatchResult {1257 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1258 let mut target_collection = Self::get_collection(collection_id)?;1259 Self::check_owner_permissions(&target_collection, sender.as_sub())?;1260 let old_limits = &target_collection.limits;12611262 1263 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1264 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1265 new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,1266 Error::<T>::CollectionLimitBoundsExceeded);12671268 1269 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1270 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12711272 ensure!(1273 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1274 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1275 Error::<T>::OwnerPermissionsCantBeReverted,1276 );12771278 target_collection.limits = new_limits;12791280 target_collection.save()1281 }1282 }1283}12841285impl<T: Config> Module<T> {1286 pub fn create_item_internal(1287 sender: &T::CrossAccountId,1288 collection: &CollectionHandle<T>,1289 owner: &T::CrossAccountId,1290 data: CreateItemData,1291 ) -> DispatchResult {1292 ensure!(1293 owner != &T::CrossAccountId::from_eth(H160([0; 20])),1294 Error::<T>::AddressIsZero1295 );12961297 Self::can_create_items_in_collection(collection, sender, owner, 1)?;1298 Self::validate_create_item_args(collection, &data)?;1299 Self::create_item_no_validation(collection, owner, data)?;13001301 Ok(())1302 }13031304 pub fn transfer_internal(1305 sender: &T::CrossAccountId,1306 recipient: &T::CrossAccountId,1307 target_collection: &CollectionHandle<T>,1308 item_id: TokenId,1309 value: u128,1310 ) -> DispatchResult {1311 ensure!(1312 recipient != &T::CrossAccountId::from_eth(H160([0; 20])),1313 Error::<T>::AddressIsZero1314 );13151316 1317 Self::is_correct_transfer(target_collection, recipient)?;13181319 1320 ensure!(1321 Self::is_item_owner(sender, target_collection, item_id)?1322 || Self::is_owner_or_admin_permissions(target_collection, sender)?,1323 Error::<T>::NoPermission1324 );13251326 if target_collection.access == AccessMode::WhiteList {1327 Self::check_white_list(target_collection, sender)?;1328 Self::check_white_list(target_collection, recipient)?;1329 }13301331 match target_collection.mode {1332 CollectionMode::NFT => Self::transfer_nft(1333 target_collection,1334 item_id,1335 sender.clone(),1336 recipient.clone(),1337 )?,1338 CollectionMode::Fungible(_) => {1339 Self::transfer_fungible(target_collection, value, sender, recipient)?1340 }1341 CollectionMode::ReFungible => Self::transfer_refungible(1342 target_collection,1343 item_id,1344 value,1345 sender.clone(),1346 recipient.clone(),1347 )?,1348 _ => (),1349 };13501351 Self::deposit_event(RawEvent::Transfer(1352 target_collection.id,1353 item_id,1354 sender.clone(),1355 recipient.clone(),1356 value,1357 ));13581359 Ok(())1360 }13611362 pub fn approve_internal(1363 sender: &T::CrossAccountId,1364 spender: &T::CrossAccountId,1365 collection: &CollectionHandle<T>,1366 item_id: TokenId,1367 amount: u128,1368 ) -> DispatchResult {1369 Self::token_exists(collection, item_id)?;13701371 1372 let bypasses_limits = collection.limits.owner_can_transfer1373 && Self::is_owner_or_admin_permissions(collection, sender)?;13741375 let allowance_limit = if bypasses_limits {1376 None1377 } else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {1378 Some(amount)1379 } else {1380 fail!(Error::<T>::NoPermission);1381 };13821383 if collection.access == AccessMode::WhiteList {1384 Self::check_white_list(collection, sender)?;1385 Self::check_white_list(collection, spender)?;1386 }13871388 collection.consume_sload()?;1389 let allowance: u128 = amount1390 .checked_add(<Allowances<T>>::get(1391 collection.id,1392 (item_id, sender.as_sub(), spender.as_sub()),1393 ))1394 .ok_or(Error::<T>::NumOverflow)?;1395 if let Some(limit) = allowance_limit {1396 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1397 }1398 collection.consume_sstore()?;1399 <Allowances<T>>::insert(1400 collection.id,1401 (item_id, sender.as_sub(), spender.as_sub()),1402 allowance,1403 );14041405 if matches!(collection.mode, CollectionMode::NFT) {1406 1407 collection.log(ERC721Events::Approval {1408 owner: *sender.as_eth(),1409 approved: *spender.as_eth(),1410 token_id: item_id.into(),1411 })?;1412 }14131414 if matches!(collection.mode, CollectionMode::Fungible(_)) {1415 1416 collection.log(ERC20Events::Approval {1417 owner: *sender.as_eth(),1418 spender: *spender.as_eth(),1419 value: allowance.into(),1420 })?;1421 }14221423 Self::deposit_event(RawEvent::Approved(1424 collection.id,1425 item_id,1426 sender.clone(),1427 spender.clone(),1428 allowance,1429 ));1430 Ok(())1431 }14321433 pub fn transfer_from_internal(1434 sender: &T::CrossAccountId,1435 from: &T::CrossAccountId,1436 recipient: &T::CrossAccountId,1437 collection: &CollectionHandle<T>,1438 item_id: TokenId,1439 amount: u128,1440 ) -> DispatchResult {1441 if sender == from {1442 1443 return Self::transfer_internal(from, recipient, collection, item_id, amount);1444 }14451446 1447 collection.consume_sload()?;1448 let approval: u128 =1449 <Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14501451 1452 Self::is_correct_transfer(collection, recipient)?;14531454 1455 ensure!(1456 approval >= amount1457 || (collection.limits.owner_can_transfer1458 && Self::is_owner_or_admin_permissions(collection, sender)?),1459 Error::<T>::NoPermission1460 );14611462 if collection.access == AccessMode::WhiteList {1463 Self::check_white_list(collection, sender)?;1464 Self::check_white_list(collection, recipient)?;1465 }14661467 1468 let allowance = approval.saturating_sub(amount);1469 collection.consume_sstore()?;1470 if allowance > 0 {1471 <Allowances<T>>::insert(1472 collection.id,1473 (item_id, from.as_sub(), sender.as_sub()),1474 allowance,1475 );1476 } else {1477 <Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1478 }14791480 match collection.mode {1481 CollectionMode::NFT => {1482 Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1483 }1484 CollectionMode::Fungible(_) => {1485 Self::transfer_fungible(collection, amount, from, recipient)?1486 }1487 CollectionMode::ReFungible => Self::transfer_refungible(1488 collection,1489 item_id,1490 amount,1491 from.clone(),1492 recipient.clone(),1493 )?,1494 _ => (),1495 };14961497 if matches!(collection.mode, CollectionMode::Fungible(_)) {1498 collection.log(ERC20Events::Approval {1499 owner: *from.as_eth(),1500 spender: *sender.as_eth(),1501 value: allowance.into(),1502 })?;1503 }15041505 Ok(())1506 }15071508 pub fn set_variable_meta_data_internal(1509 sender: &T::CrossAccountId,1510 collection: &CollectionHandle<T>,1511 item_id: TokenId,1512 data: Vec<u8>,1513 ) -> DispatchResult {1514 Self::token_exists(collection, item_id)?;15151516 ensure!(1517 CUSTOM_DATA_LIMIT >= data.len() as u32,1518 Error::<T>::TokenVariableDataLimitExceeded1519 );15201521 1522 ensure!(1523 Self::is_item_owner(sender, collection, item_id)?1524 || Self::is_owner_or_admin_permissions(collection, sender)?,1525 Error::<T>::NoPermission1526 );15271528 match collection.mode {1529 CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1530 CollectionMode::ReFungible => {1531 Self::set_re_fungible_variable_data(collection, item_id, data)?1532 }1533 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1534 _ => fail!(Error::<T>::UnexpectedCollectionType),1535 };15361537 Ok(())1538 }15391540 pub fn meta_update_check(1541 sender: &T::CrossAccountId,1542 collection: &CollectionHandle<T>,1543 item_id: TokenId,1544 ) -> DispatchResult {1545 match collection.meta_update_permission {1546 MetaUpdatePermission::ItemOwner => {1547 ensure!(1548 Self::is_item_owner(sender, collection, item_id),1549 Error::<T>::NoPermission1550 );1551 }1552 MetaUpdatePermission::Admin => {1553 ensure!(1554 Self::is_owner_or_admin_permissions(collection, sender),1555 Error::<T>::NoPermission1556 );1557 }1558 MetaUpdatePermission::None => {1559 fail!(Error::<T>::MetadataUpdateDenied);1560 }1561 }15621563 Ok(())1564 }15651566 pub fn create_multiple_items_internal(1567 sender: &T::CrossAccountId,1568 collection: &CollectionHandle<T>,1569 owner: &T::CrossAccountId,1570 items_data: Vec<CreateItemData>,1571 ) -> DispatchResult {1572 Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15731574 for data in &items_data {1575 Self::validate_create_item_args(collection, data)?;1576 }1577 for data in &items_data {1578 Self::create_item_no_validation(collection, owner, data.clone())?;1579 }15801581 Ok(())1582 }15831584 pub fn burn_item_internal(1585 sender: &T::CrossAccountId,1586 collection: &CollectionHandle<T>,1587 item_id: TokenId,1588 value: u128,1589 ) -> DispatchResult {1590 ensure!(1591 Self::is_item_owner(sender, collection, item_id)?1592 || (collection.limits.owner_can_transfer1593 && Self::is_owner_or_admin_permissions(collection, sender)?),1594 Error::<T>::NoPermission1595 );15961597 if collection.access == AccessMode::WhiteList {1598 Self::check_white_list(collection, sender)?;1599 }16001601 match collection.mode {1602 CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1603 CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1604 CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1605 _ => (),1606 };16071608 Ok(())1609 }16101611 pub fn toggle_white_list_internal(1612 sender: &T::CrossAccountId,1613 collection: &CollectionHandle<T>,1614 address: &T::CrossAccountId,1615 whitelisted: bool,1616 ) -> DispatchResult {1617 Self::check_owner_or_admin_permissions(collection, sender)?;16181619 if whitelisted {1620 <WhiteList<T>>::insert(collection.id, address.as_sub(), true);1621 } else {1622 <WhiteList<T>>::remove(collection.id, address.as_sub());1623 }16241625 Ok(())1626 }16271628 fn is_correct_transfer(1629 collection: &CollectionHandle<T>,1630 recipient: &T::CrossAccountId,1631 ) -> DispatchResult {1632 let collection_id = collection.id;16331634 1635 collection.consume_sload()?;1636 let account_items: u32 =1637 <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1638 ensure!(1639 collection.limits.account_token_ownership_limit > account_items,1640 Error::<T>::AccountTokenLimitExceeded1641 );16421643 1644 ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);16451646 Ok(())1647 }16481649 fn can_create_items_in_collection(1650 collection: &CollectionHandle<T>,1651 sender: &T::CrossAccountId,1652 owner: &T::CrossAccountId,1653 amount: u32,1654 ) -> DispatchResult {1655 let collection_id = collection.id;16561657 1658 let total_items: u32 = ItemListIndex::get(collection_id)1659 .checked_add(amount)1660 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1661 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1662 as u32)1663 .checked_add(amount)1664 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1665 ensure!(1666 collection.limits.token_limit >= total_items,1667 Error::<T>::CollectionTokenLimitExceeded1668 );1669 ensure!(1670 collection.limits.account_token_ownership_limit >= account_items,1671 Error::<T>::AccountTokenLimitExceeded1672 );16731674 if !Self::is_owner_or_admin_permissions(collection, sender)? {1675 ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1676 Self::check_white_list(collection, owner)?;1677 Self::check_white_list(collection, sender)?;1678 }16791680 Ok(())1681 }16821683 fn validate_create_item_args(1684 target_collection: &CollectionHandle<T>,1685 data: &CreateItemData,1686 ) -> DispatchResult {1687 match target_collection.mode {1688 CollectionMode::NFT => {1689 if !matches!(data, CreateItemData::NFT(_)) {1690 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1691 }1692 }1693 CollectionMode::Fungible(_) => {1694 if !matches!(data, CreateItemData::Fungible(_)) {1695 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1696 }1697 }1698 CollectionMode::ReFungible => {1699 if let CreateItemData::ReFungible(data) = data {1700 1701 ensure!(1702 data.pieces <= MAX_REFUNGIBLE_PIECES,1703 Error::<T>::WrongRefungiblePieces1704 );1705 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1706 } else {1707 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1708 }1709 }1710 _ => {1711 fail!(Error::<T>::UnexpectedCollectionType);1712 }1713 };17141715 Ok(())1716 }17171718 fn create_item_no_validation(1719 collection: &CollectionHandle<T>,1720 owner: &T::CrossAccountId,1721 data: CreateItemData,1722 ) -> DispatchResult {1723 match data {1724 CreateItemData::NFT(data) => {1725 let item = NftItemType {1726 owner: owner.clone(),1727 const_data: data.const_data.into_inner(),1728 variable_data: data.variable_data.into_inner(),1729 };17301731 Self::add_nft_item(collection, item)?;1732 }1733 CreateItemData::Fungible(data) => {1734 Self::add_fungible_item(collection, owner, data.value)?;1735 }1736 CreateItemData::ReFungible(data) => {1737 let owner_list = vec![Ownership {1738 owner: owner.clone(),1739 fraction: data.pieces,1740 }];17411742 let item = ReFungibleItemType {1743 owner: owner_list,1744 const_data: data.const_data.into_inner(),1745 variable_data: data.variable_data.into_inner(),1746 };17471748 Self::add_refungible_item(collection, item)?;1749 }1750 };17511752 Ok(())1753 }17541755 fn add_fungible_item(1756 collection: &CollectionHandle<T>,1757 owner: &T::CrossAccountId,1758 value: u128,1759 ) -> DispatchResult {1760 let collection_id = collection.id;17611762 1763 collection.consume_sload()?;1764 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17651766 1767 let item = FungibleItemType {1768 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1769 };1770 collection.consume_sstore()?;1771 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);17721773 1774 collection.consume_sload()?;1775 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1776 .checked_add(value)1777 .ok_or(Error::<T>::NumOverflow)?;1778 collection.consume_sstore()?;1779 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17801781 collection.log(ERC20Events::Transfer {1782 from: H160::default(),1783 to: *owner.as_eth(),1784 value: value.into(),1785 })?;1786 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1787 Ok(())1788 }17891790 fn add_refungible_item(1791 collection: &CollectionHandle<T>,1792 item: ReFungibleItemType<T::CrossAccountId>,1793 ) -> DispatchResult {1794 let collection_id = collection.id;17951796 let current_index = <ItemListIndex>::get(collection_id)1797 .checked_add(1)1798 .ok_or(Error::<T>::NumOverflow)?;1799 let itemcopy = item.clone();18001801 ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1802 let item_owner = item.owner.first().expect("only one owner is defined");18031804 let value = item_owner.fraction;1805 let owner = item_owner.owner.clone();18061807 Self::add_token_index(collection, current_index, &owner)?;18081809 <ItemListIndex>::insert(collection_id, current_index);1810 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);18111812 1813 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1814 .checked_add(value)1815 .ok_or(Error::<T>::NumOverflow)?;1816 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18171818 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1819 Ok(())1820 }18211822 fn add_nft_item(1823 collection: &CollectionHandle<T>,1824 item: NftItemType<T::CrossAccountId>,1825 ) -> DispatchResult {1826 let collection_id = collection.id;18271828 let current_index = <ItemListIndex>::get(collection_id)1829 .checked_add(1)1830 .ok_or(Error::<T>::NumOverflow)?;18311832 let item_owner = item.owner.clone();1833 Self::add_token_index(collection, current_index, &item.owner)?;18341835 <ItemListIndex>::insert(collection_id, current_index);1836 <NftItemList<T>>::insert(collection_id, current_index, item);18371838 1839 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1840 .checked_add(1)1841 .ok_or(Error::<T>::NumOverflow)?;1842 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);18431844 collection.log(ERC721Events::Transfer {1845 from: H160::default(),1846 to: *item_owner.as_eth(),1847 token_id: current_index.into(),1848 })?;1849 Self::deposit_event(RawEvent::ItemCreated(1850 collection_id,1851 current_index,1852 item_owner,1853 ));1854 Ok(())1855 }18561857 fn burn_refungible_item(1858 collection: &CollectionHandle<T>,1859 item_id: TokenId,1860 owner: &T::CrossAccountId,1861 ) -> DispatchResult {1862 let collection_id = collection.id;18631864 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1865 .ok_or(Error::<T>::TokenNotFound)?;1866 let rft_balance = token1867 .owner1868 .iter()1869 .find(|&i| i.owner == *owner)1870 .ok_or(Error::<T>::TokenNotFound)?;1871 Self::remove_token_index(collection, item_id, owner)?;18721873 1874 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1875 .checked_sub(rft_balance.fraction)1876 .ok_or(Error::<T>::NumOverflow)?;1877 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);18781879 1880 let index = token1881 .owner1882 .iter()1883 .position(|i| i.owner == *owner)1884 .expect("owned item is exists");1885 token.owner.remove(index);1886 let owner_count = token.owner.len();18871888 1889 if owner_count == 0 {1890 <ReFungibleItemList<T>>::remove(collection_id, item_id);1891 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);1892 } else {1893 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1894 }18951896 Ok(())1897 }18981899 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1900 let collection_id = collection.id;19011902 let item =1903 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1904 Self::remove_token_index(collection, item_id, &item.owner)?;19051906 1907 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1908 .checked_sub(1)1909 .ok_or(Error::<T>::NumOverflow)?;1910 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1911 <NftItemList<T>>::remove(collection_id, item_id);1912 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);19131914 collection.log(ERC721Events::Transfer {1915 from: *item.owner.as_eth(),1916 to: H160::default(),1917 token_id: item_id.into(),1918 })?;1919 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1920 Ok(())1921 }19221923 fn burn_fungible_item(1924 owner: &T::CrossAccountId,1925 collection: &CollectionHandle<T>,1926 value: u128,1927 ) -> DispatchResult {1928 let collection_id = collection.id;19291930 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1931 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19321933 1934 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1935 .checked_sub(value)1936 .ok_or(Error::<T>::NumOverflow)?;1937 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19381939 if balance.value - value > 0 {1940 balance.value -= value;1941 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1942 } else {1943 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());1944 }19451946 collection.log(ERC20Events::Transfer {1947 from: *owner.as_eth(),1948 to: H160::default(),1949 value: value.into(),1950 })?;1951 Ok(())1952 }19531954 pub fn get_collection(1955 collection_id: CollectionId,1956 ) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1957 Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1958 }19591960 fn check_owner_permissions(1961 target_collection: &CollectionHandle<T>,1962 subject: &T::AccountId,1963 ) -> DispatchResult {1964 ensure!(1965 *subject == target_collection.owner,1966 Error::<T>::NoPermission1967 );19681969 Ok(())1970 }19711972 fn is_owner_or_admin_permissions(1973 collection: &CollectionHandle<T>,1974 subject: &T::CrossAccountId,1975 ) -> Result<bool, DispatchError> {1976 collection.consume_sload()?;1977 Ok(*subject.as_sub() == collection.owner1978 || <AdminList<T>>::get(collection.id).contains(subject))1979 }19801981 fn check_owner_or_admin_permissions(1982 collection: &CollectionHandle<T>,1983 subject: &T::CrossAccountId,1984 ) -> DispatchResult {1985 ensure!(1986 Self::is_owner_or_admin_permissions(collection, subject)?,1987 Error::<T>::NoPermission1988 );19891990 Ok(())1991 }19921993 fn owned_amount(1994 subject: &T::CrossAccountId,1995 collection: &CollectionHandle<T>,1996 item_id: TokenId,1997 ) -> Result<Option<u128>, DispatchError> {1998 collection.consume_sload()?;1999 Ok(Self::owned_amount_unchecked(subject, collection, item_id))2000 }20012002 fn owned_amount_unchecked(2003 subject: &T::CrossAccountId,2004 target_collection: &CollectionHandle<T>,2005 item_id: TokenId,2006 ) -> Option<u128> {2007 let collection_id = target_collection.id;20082009 match target_collection.mode {2010 CollectionMode::NFT => {2011 (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)2012 }2013 CollectionMode::Fungible(_) => {2014 Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)2015 }2016 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2017 .owner2018 .iter()2019 .find(|i| i.owner == *subject)2020 .map(|i| i.fraction),2021 CollectionMode::Invalid => None,2022 }2023 }20242025 fn is_item_owner(2026 subject: &T::CrossAccountId,2027 target_collection: &CollectionHandle<T>,2028 item_id: TokenId,2029 ) -> Result<bool, DispatchError> {2030 Ok(match target_collection.mode {2031 CollectionMode::Fungible(_) => true,2032 _ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),2033 })2034 }20352036 fn check_white_list(2037 collection: &CollectionHandle<T>,2038 address: &T::CrossAccountId,2039 ) -> DispatchResult {2040 collection.consume_sload()?;2041 ensure!(2042 <WhiteList<T>>::contains_key(collection.id, address.as_sub()),2043 Error::<T>::AddresNotInWhiteList,2044 );2045 Ok(())2046 }20472048 2049 2050 fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2051 let collection_id = target_collection.id;2052 let exists = match target_collection.mode {2053 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2054 CollectionMode::Fungible(_) => true,2055 CollectionMode::ReFungible => {2056 <ReFungibleItemList<T>>::contains_key(collection_id, item_id)2057 }2058 _ => false,2059 };20602061 ensure!(exists, Error::<T>::TokenNotFound);2062 Ok(())2063 }20642065 fn transfer_fungible(2066 collection: &CollectionHandle<T>,2067 value: u128,2068 owner: &T::CrossAccountId,2069 recipient: &T::CrossAccountId,2070 ) -> DispatchResult {2071 let collection_id = collection.id;20722073 collection.consume_sload()?;2074 collection.consume_sload()?;2075 let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2076 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());20772078 recipient_balance.value = recipient_balance2079 .value2080 .checked_add(value)2081 .ok_or(Error::<T>::NumOverflow)?;2082 balance.value = balance2083 .value2084 .checked_sub(value)2085 .ok_or(Error::<T>::TokenValueTooLow)?;20862087 2088 collection.consume_sstore()?;2089 collection.consume_sstore()?;2090 if balance.value != 0 {2091 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2092 } else {2093 <Balance<T>>::remove(collection_id, owner.as_sub());2094 }2095 <Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);20962097 2098 collection.consume_sstore()?;2099 collection.consume_sstore()?;2100 if balance.value != 0 {2101 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2102 } else {2103 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2104 }2105 <FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);21062107 collection.log(ERC20Events::Transfer {2108 from: *owner.as_eth(),2109 to: *recipient.as_eth(),2110 value: value.into(),2111 })?;2112 Self::deposit_event(RawEvent::Transfer(2113 collection.id,2114 1,2115 owner.clone(),2116 recipient.clone(),2117 value,2118 ));21192120 Ok(())2121 }21222123 fn transfer_refungible(2124 collection: &CollectionHandle<T>,2125 item_id: TokenId,2126 value: u128,2127 owner: T::CrossAccountId,2128 new_owner: T::CrossAccountId,2129 ) -> DispatchResult {2130 let collection_id = collection.id;2131 collection.consume_sload()?;2132 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2133 .ok_or(Error::<T>::TokenNotFound)?;21342135 let item = full_item2136 .owner2137 .iter()2138 .find(|i| i.owner == owner)2139 .ok_or(Error::<T>::TokenNotFound)?;2140 let amount = item.fraction;21412142 ensure!(amount >= value, Error::<T>::TokenValueTooLow);21432144 collection.consume_sload()?;2145 2146 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2147 .checked_sub(value)2148 .ok_or(Error::<T>::NumOverflow)?;2149 collection.consume_sstore()?;2150 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21512152 collection.consume_sload()?;2153 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2154 .checked_add(value)2155 .ok_or(Error::<T>::NumOverflow)?;2156 collection.consume_sstore()?;2157 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21582159 let old_owner = item.owner.clone();2160 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21612162 let mut new_full_item = full_item.clone();2163 2164 if amount == value && !new_owner_has_account {2165 2166 2167 new_full_item2168 .owner2169 .iter_mut()2170 .find(|i| i.owner == owner)2171 .expect("old owner does present in refungible")2172 .owner = new_owner.clone();2173 collection.consume_sstore()?;2174 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);21752176 2177 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2178 } else {2179 new_full_item2180 .owner2181 .iter_mut()2182 .find(|i| i.owner == owner)2183 .expect("old owner does present in refungible")2184 .fraction -= value;21852186 2187 if new_owner_has_account {2188 2189 new_full_item2190 .owner2191 .iter_mut()2192 .find(|i| i.owner == new_owner)2193 .expect("new owner has account")2194 .fraction += value;2195 } else {2196 2197 new_full_item.owner.push(Ownership {2198 owner: new_owner.clone(),2199 fraction: value,2200 });2201 Self::add_token_index(collection, item_id, &new_owner)?;2202 }22032204 collection.consume_sstore()?;2205 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2206 }22072208 Self::deposit_event(RawEvent::Transfer(2209 collection.id,2210 item_id,2211 owner,2212 new_owner,2213 amount,2214 ));22152216 Ok(())2217 }22182219 fn transfer_nft(2220 collection: &CollectionHandle<T>,2221 item_id: TokenId,2222 sender: T::CrossAccountId,2223 new_owner: T::CrossAccountId,2224 ) -> DispatchResult {2225 let collection_id = collection.id;2226 collection.consume_sload()?;2227 let mut item =2228 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22292230 ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);22312232 collection.consume_sload()?;2233 2234 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2235 .checked_sub(1)2236 .ok_or(Error::<T>::NumOverflow)?;2237 collection.consume_sstore()?;2238 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);22392240 collection.consume_sload()?;2241 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2242 .checked_add(1)2243 .ok_or(Error::<T>::NumOverflow)?;2244 collection.consume_sstore()?;2245 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22462247 2248 let old_owner = item.owner.clone();2249 item.owner = new_owner.clone();2250 collection.consume_sstore()?;2251 <NftItemList<T>>::insert(collection_id, item_id, item);22522253 2254 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;22552256 collection.log(ERC721Events::Transfer {2257 from: *sender.as_eth(),2258 to: *new_owner.as_eth(),2259 token_id: item_id.into(),2260 })?;2261 Self::deposit_event(RawEvent::Transfer(2262 collection.id,2263 item_id,2264 sender,2265 new_owner,2266 1,2267 ));22682269 Ok(())2270 }22712272 fn set_re_fungible_variable_data(2273 collection: &CollectionHandle<T>,2274 item_id: TokenId,2275 data: Vec<u8>,2276 ) -> DispatchResult {2277 let collection_id = collection.id;2278 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2279 .ok_or(Error::<T>::TokenNotFound)?;22802281 item.variable_data = data;22822283 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);22842285 Ok(())2286 }22872288 fn set_nft_variable_data(2289 collection: &CollectionHandle<T>,2290 item_id: TokenId,2291 data: Vec<u8>,2292 ) -> DispatchResult {2293 let collection_id = collection.id;2294 let mut item =2295 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22962297 item.variable_data = data;22982299 <NftItemList<T>>::insert(collection_id, item_id, item);23002301 Ok(())2302 }23032304 #[allow(dead_code)]2305 fn init_collection(item: &Collection<T>) {2306 2307 assert!(2308 item.decimal_points <= MAX_DECIMAL_POINTS,2309 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2310 );2311 assert!(2312 item.name.len() <= 64,2313 "Collection name can not be longer than 63 char"2314 );2315 assert!(2316 item.name.len() <= 256,2317 "Collection description can not be longer than 255 char"2318 );2319 assert!(2320 item.token_prefix.len() <= 16,2321 "Token prefix can not be longer than 15 char"2322 );23232324 2325 let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();23262327 CreatedCollectionCount::put(next_id);2328 }23292330 #[allow(dead_code)]2331 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2332 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23332334 Self::add_token_index(2335 &CollectionHandle::get(collection_id).unwrap(),2336 current_index,2337 &item.owner,2338 )2339 .unwrap();23402341 <ItemListIndex>::insert(collection_id, current_index);23422343 2344 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2345 .checked_add(1)2346 .unwrap();2347 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2348 }23492350 #[allow(dead_code)]2351 fn init_fungible_token(2352 collection_id: CollectionId,2353 owner: &T::CrossAccountId,2354 item: &FungibleItemType,2355 ) {2356 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23572358 Self::add_token_index(2359 &CollectionHandle::get(collection_id).unwrap(),2360 current_index,2361 owner,2362 )2363 .unwrap();23642365 <ItemListIndex>::insert(collection_id, current_index);23662367 2368 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2369 .checked_add(item.value)2370 .unwrap();2371 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2372 }23732374 #[allow(dead_code)]2375 fn init_refungible_token(2376 collection_id: CollectionId,2377 item: &ReFungibleItemType<T::CrossAccountId>,2378 ) {2379 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23802381 let value = item.owner.first().unwrap().fraction;2382 let owner = item.owner.first().unwrap().owner.clone();23832384 Self::add_token_index(2385 &CollectionHandle::get(collection_id).unwrap(),2386 current_index,2387 &owner,2388 )2389 .unwrap();23902391 <ItemListIndex>::insert(collection_id, current_index);23922393 2394 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2395 .checked_add(value)2396 .unwrap();2397 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2398 }23992400 fn add_token_index(2401 collection: &CollectionHandle<T>,2402 item_index: TokenId,2403 owner: &T::CrossAccountId,2404 ) -> DispatchResult {2405 2406 collection.consume_sload()?;2407 if <AccountItemCount<T>>::contains_key(owner.as_sub()) {2408 2409 collection.consume_sload()?;2410 let count = <AccountItemCount<T>>::get(owner.as_sub());2411 ensure!(2412 count < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2413 Error::<T>::AddressOwnershipLimitExceeded2414 );24152416 collection.consume_sstore()?;2417 <AccountItemCount<T>>::insert(2418 owner.as_sub(),2419 count.checked_add(1).ok_or(Error::<T>::NumOverflow)?,2420 );2421 } else {2422 collection.consume_sstore()?;2423 <AccountItemCount<T>>::insert(owner.as_sub(), 1);2424 }24252426 collection.consume_sload()?;2427 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2428 if list_exists {2429 collection.consume_sload()?;2430 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2431 let item_contains = list.contains(&item_index.clone());24322433 if !item_contains {2434 list.push(item_index);2435 }24362437 collection.consume_sstore()?;2438 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2439 } else {2440 let itm = vec![item_index];2441 collection.consume_sstore()?;2442 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2443 }24442445 Ok(())2446 }24472448 fn remove_token_index(2449 collection: &CollectionHandle<T>,2450 item_index: TokenId,2451 owner: &T::CrossAccountId,2452 ) -> DispatchResult {2453 2454 collection.consume_sload()?;2455 collection.consume_sstore()?;2456 <AccountItemCount<T>>::insert(2457 owner.as_sub(),2458 <AccountItemCount<T>>::get(owner.as_sub())2459 .checked_sub(1)2460 .ok_or(Error::<T>::NumOverflow)?,2461 );24622463 collection.consume_sload()?;2464 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2465 if list_exists {2466 collection.consume_sload()?;2467 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2468 let item_contains = list.contains(&item_index.clone());24692470 if item_contains {2471 list.retain(|&item| item != item_index);2472 collection.consume_sstore()?;2473 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2474 }2475 }24762477 Ok(())2478 }24792480 fn move_token_index(2481 collection: &CollectionHandle<T>,2482 item_index: TokenId,2483 old_owner: &T::CrossAccountId,2484 new_owner: &T::CrossAccountId,2485 ) -> DispatchResult {2486 Self::remove_token_index(collection, item_index, old_owner)?;2487 Self::add_token_index(collection, item_index, new_owner)?;24882489 Ok(())2490 }2491}24922493sp_api::decl_runtime_apis! {2494 pub trait NftApi {2495 2496 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2497 }2498}