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 TransferNotAllowed,150 151 AddressIsZero,152 }153}154155#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]156pub struct CollectionHandle<T: Config> {157 pub id: CollectionId,158 collection: Collection<T>,159 recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,160}161impl<T: Config> CollectionHandle<T> {162 pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {163 <CollectionById<T>>::get(id).map(|collection| Self {164 id,165 collection,166 recorder: pallet_evm_coder_substrate::SubstrateRecorder::new(167 eth::collection_id_to_address(id),168 gas_limit,169 ),170 })171 }172 pub fn get(id: CollectionId) -> Option<Self> {173 Self::get_with_gas_limit(id, u64::MAX)174 }175 pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {176 self.recorder.log_sub(log)177 }178 #[allow(dead_code)]179 fn consume_gas(&self, gas: u64) -> DispatchResult {180 self.recorder.consume_gas_sub(gas)181 }182 fn consume_sload(&self) -> DispatchResult {183 self.recorder.consume_sload_sub()184 }185 fn consume_sstore(&self) -> DispatchResult {186 self.recorder.consume_sstore_sub()187 }188 pub fn submit_logs(self) -> DispatchResult {189 self.recorder.submit_logs()190 }191 pub fn save(self) -> DispatchResult {192 self.recorder.submit_logs()?;193 <CollectionById<T>>::insert(self.id, self.collection);194 Ok(())195 }196}197impl<T: Config> Deref for CollectionHandle<T> {198 type Target = Collection<T>;199200 fn deref(&self) -> &Self::Target {201 &self.collection202 }203}204205impl<T: Config> DerefMut for CollectionHandle<T> {206 fn deref_mut(&mut self) -> &mut Self::Target {207 &mut self.collection208 }209}210211pub trait Config: system::Config + pallet_evm_coder_substrate::Config + Sized {212 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;213214 215 type WeightInfo: WeightInfo;216217 type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;218 type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;219220 type CrossAccountId: CrossAccountId<Self::AccountId>;221 type Currency: Currency<Self::AccountId>;222 type CollectionCreationPrice: Get<223 <<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,224 >;225 type TreasuryAccountId: Get<Self::AccountId>;226}227228type SelfWeightOf<T> = <T as Config>::WeightInfo;229230trait WeightInfoHelpers: WeightInfo {231 fn transfer() -> Weight {232 Self::transfer_nft()233 .max(Self::transfer_fungible())234 .max(Self::transfer_refungible())235 }236 fn transfer_from() -> Weight {237 Self::transfer_from_nft()238 .max(Self::transfer_from_fungible())239 .max(Self::transfer_from_refungible())240 }241 fn approve() -> Weight {242 243 Self::approve_nft()244 }245 fn set_variable_meta_data(data: u32) -> Weight {246 247 Self::set_variable_meta_data_nft(data)248 }249 fn create_item(data: u32) -> Weight {250 Self::create_item_nft(data)251 .max(Self::create_item_fungible())252 .max(Self::create_item_refungible(data))253 }254 fn create_multiple_items(amount: u32) -> Weight {255 Self::create_multiple_items_nft(amount)256 .max(Self::create_multiple_items_fungible(amount))257 .max(Self::create_multiple_items_refungible(amount))258 }259 fn burn_item() -> Weight {260 261 Self::burn_item_nft()262 }263}264impl<T: WeightInfo> WeightInfoHelpers for T {}265266267268269270271272273274275276277278279280281282283284285286287288decl_storage! {289 trait Store for Module<T: Config> as Nft {290291 292 293 CreatedCollectionCount: u32;294 295 ChainVersion: u64;296 297 298 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;299 300301 302 303 304 DestroyedCollectionCount: u32;305 306 307 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;308 309310 311 312 313 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;314 315 316 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;317 318 319 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;320 321322 323 324 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;325326 327 328 329 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;330331 332 333 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;334 335 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;336 337 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;338 339340 341 342 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;343 344345 346 347 348 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;349 350 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;351 352 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;353 354 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;355 356357 358 359 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;360 }361 add_extra_genesis {362 build(|config: &GenesisConfig<T>| {363 364 for (_num, _c) in &config.collection_id {365 <Module<T>>::init_collection(_c);366 }367368 for (_num, _c, _i) in &config.nft_item_id {369 <Module<T>>::init_nft_token(*_c, _i);370 }371372 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {373 <Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);374 }375376 for (_num, _c, _i) in &config.refungible_item_id {377 <Module<T>>::init_refungible_token(*_c, _i);378 }379 })380 }381}382383decl_event!(384 pub enum Event<T>385 where386 AccountId = <T as frame_system::Config>::AccountId,387 CrossAccountId = <T as Config>::CrossAccountId,388 {389 390 391 392 393 394 395 396 397 398 CollectionCreated(CollectionId, u8, AccountId),399400 401 402 403 404 405 406 407 408 409 ItemCreated(CollectionId, TokenId, CrossAccountId),410411 412 413 414 415 416 417 418 ItemDestroyed(CollectionId, TokenId),419420 421 422 423 424 425 426 427 428 429 430 431 Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),432433 434 435 436 437 438 439 440 441 442 Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),443 }444);445446decl_module! {447 pub struct Module<T: Config> for enum Call448 where449 origin: T::Origin450 {451 fn deposit_event() = default;452 const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;453 type Error = Error<T>;454455 fn on_initialize(_now: T::BlockNumber) -> Weight {456 0457 }458459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 #[weight = <SelfWeightOf<T>>::create_collection()]476 #[transactional]477 pub fn create_collection(origin,478 collection_name: Vec<u16>,479 collection_description: Vec<u16>,480 token_prefix: Vec<u8>,481 mode: CollectionMode) -> DispatchResult {482483 484 let who = ensure_signed(origin)?;485486 487 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();488 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(489 &T::TreasuryAccountId::get(),490 T::CollectionCreationPrice::get(),491 ));492 <T as Config>::Currency::settle(493 &who,494 imbalance,495 WithdrawReasons::TRANSFER,496 ExistenceRequirement::KeepAlive,497 ).map_err(|_| Error::<T>::NoPermission)?;498499 let decimal_points = match mode {500 CollectionMode::Fungible(points) => points,501 _ => 0502 };503504 let created_count = CreatedCollectionCount::get();505 let destroyed_count = DestroyedCollectionCount::get();506507 508 ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);509510 511 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);512 ensure!(collection_name.len() <= MAX_COLLECTION_NAME_LENGTH, Error::<T>::CollectionNameLimitExceeded);513 ensure!(collection_description.len() <= MAX_COLLECTION_DESCRIPTION_LENGTH, Error::<T>::CollectionDescriptionLimitExceeded);514 ensure!(token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH, Error::<T>::CollectionTokenPrefixLimitExceeded);515516 517 let next_id = created_count518 .checked_add(1)519 .ok_or(Error::<T>::NumOverflow)?;520521 CreatedCollectionCount::put(next_id);522523 let limits = CollectionLimits {524 sponsored_data_size: CUSTOM_DATA_LIMIT,525 ..Default::default()526 };527528 529 let new_collection = Collection {530 owner: who.clone(),531 name: collection_name,532 mode: mode.clone(),533 mint_mode: false,534 access: AccessMode::Normal,535 description: collection_description,536 decimal_points,537 token_prefix,538 offchain_schema: Vec::new(),539 schema_version: SchemaVersion::ImageURL,540 sponsorship: SponsorshipState::Disabled,541 variable_on_chain_schema: Vec::new(),542 const_on_chain_schema: Vec::new(),543 limits,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_multiple_items(items_data.len() as u32)]905 #[transactional]906 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {907908 ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);909 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);910 let collection = Self::get_collection(collection_id)?;911912 Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;913914 collection.submit_logs()915 }916917 918919 920 921 922 923 924 925 926 927 928 929 930 #[weight = <SelfWeightOf<T>>::set_transfers_enabled_flag()]931 #[transactional]932 pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {933934 let sender = ensure_signed(origin)?;935 let mut target_collection = Self::get_collection(collection_id)?;936937 Self::check_owner_permissions(&target_collection, &sender)?;938939 target_collection.transfers_enabled = value;940 target_collection.save()941 }942943 944 945 946 947 948 949 950 951 952 953 954 955 956 #[weight = <SelfWeightOf<T>>::burn_item()]957 #[transactional]958 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {959960 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);961 let target_collection = Self::get_collection(collection_id)?;962963 Self::burn_item_internal(&sender, &target_collection, item_id, value)?;964965 target_collection.submit_logs()966 }967968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 #[weight = <SelfWeightOf<T>>::transfer()]992 #[transactional]993 pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {994 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);995 let collection = Self::get_collection(collection_id)?;996997 Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;998999 collection.submit_logs()1000 }10011002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 #[weight = <SelfWeightOf<T>>::approve()]1018 #[transactional]1019 pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1020 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1021 let collection = Self::get_collection(collection_id)?;10221023 Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10241025 collection.submit_logs()1026 }10271028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 #[weight = <SelfWeightOf<T>>::transfer_from()]1048 #[transactional]1049 pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1050 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1051 let collection = Self::get_collection(collection_id)?;10521053 Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10541055 collection.submit_logs()1056 }1057 1058 1059 1060 1061 10621063 10641065 10661067 1068 10691070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 #[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]1083 #[transactional]1084 pub fn set_variable_meta_data (1085 origin,1086 collection_id: CollectionId,1087 item_id: TokenId,1088 data: Vec<u8>1089 ) -> DispatchResult {1090 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);10911092 let collection = Self::get_collection(collection_id)?;10931094 Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;10951096 Ok(())1097 }10981099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 #[weight = <SelfWeightOf<T>>::set_schema_version()]1114 #[transactional]1115 pub fn set_schema_version(1116 origin,1117 collection_id: CollectionId,1118 version: SchemaVersion1119 ) -> DispatchResult {1120 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1121 let mut target_collection = Self::get_collection(collection_id)?;1122 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1123 target_collection.schema_version = version;1124 target_collection.save()1125 }11261127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 #[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]1140 #[transactional]1141 pub fn set_offchain_schema(1142 origin,1143 collection_id: CollectionId,1144 schema: Vec<u8>1145 ) -> DispatchResult {1146 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1147 let mut target_collection = Self::get_collection(collection_id)?;1148 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11491150 1151 ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");11521153 target_collection.offchain_schema = schema;1154 target_collection.save()1155 }11561157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1170 #[transactional]1171 pub fn set_const_on_chain_schema (1172 origin,1173 collection_id: CollectionId,1174 schema: Vec<u8>1175 ) -> DispatchResult {1176 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1177 let mut target_collection = Self::get_collection(collection_id)?;1178 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11791180 1181 ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");11821183 target_collection.const_on_chain_schema = schema;1184 target_collection.save()1185 }11861187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1200 #[transactional]1201 pub fn set_variable_on_chain_schema (1202 origin,1203 collection_id: CollectionId,1204 schema: Vec<u8>1205 ) -> DispatchResult {1206 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1207 let mut target_collection = Self::get_collection(collection_id)?;1208 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12091210 1211 ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");12121213 target_collection.variable_on_chain_schema = schema;1214 target_collection.save()1215 }12161217 #[weight = <SelfWeightOf<T>>::set_collection_limits()]1218 #[transactional]1219 pub fn set_collection_limits(1220 origin,1221 collection_id: u32,1222 new_limits: CollectionLimits<T::BlockNumber>,1223 ) -> DispatchResult {1224 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1225 let mut target_collection = Self::get_collection(collection_id)?;1226 Self::check_owner_permissions(&target_collection, sender.as_sub())?;1227 let old_limits = &target_collection.limits;12281229 1230 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1231 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1232 new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,1233 Error::<T>::CollectionLimitBoundsExceeded);12341235 1236 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1237 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12381239 ensure!(1240 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1241 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1242 Error::<T>::OwnerPermissionsCantBeReverted,1243 );12441245 target_collection.limits = new_limits;12461247 target_collection.save()1248 }1249 }1250}12511252impl<T: Config> Module<T> {1253 pub fn create_item_internal(1254 sender: &T::CrossAccountId,1255 collection: &CollectionHandle<T>,1256 owner: &T::CrossAccountId,1257 data: CreateItemData,1258 ) -> DispatchResult {1259 ensure!(1260 owner != &T::CrossAccountId::from_eth(H160([0; 20])),1261 Error::<T>::AddressIsZero1262 );12631264 Self::can_create_items_in_collection(collection, sender, owner, 1)?;1265 Self::validate_create_item_args(collection, &data)?;1266 Self::create_item_no_validation(collection, owner, data)?;12671268 Ok(())1269 }12701271 pub fn transfer_internal(1272 sender: &T::CrossAccountId,1273 recipient: &T::CrossAccountId,1274 target_collection: &CollectionHandle<T>,1275 item_id: TokenId,1276 value: u128,1277 ) -> DispatchResult {1278 ensure!(1279 recipient != &T::CrossAccountId::from_eth(H160([0; 20])),1280 Error::<T>::AddressIsZero1281 );12821283 1284 Self::is_correct_transfer(target_collection, recipient)?;12851286 1287 ensure!(1288 Self::is_item_owner(sender, target_collection, item_id)?1289 || Self::is_owner_or_admin_permissions(target_collection, sender)?,1290 Error::<T>::NoPermission1291 );12921293 if target_collection.access == AccessMode::WhiteList {1294 Self::check_white_list(target_collection, sender)?;1295 Self::check_white_list(target_collection, recipient)?;1296 }12971298 match target_collection.mode {1299 CollectionMode::NFT => Self::transfer_nft(1300 target_collection,1301 item_id,1302 sender.clone(),1303 recipient.clone(),1304 )?,1305 CollectionMode::Fungible(_) => {1306 Self::transfer_fungible(target_collection, value, sender, recipient)?1307 }1308 CollectionMode::ReFungible => Self::transfer_refungible(1309 target_collection,1310 item_id,1311 value,1312 sender.clone(),1313 recipient.clone(),1314 )?,1315 _ => (),1316 };13171318 Self::deposit_event(RawEvent::Transfer(1319 target_collection.id,1320 item_id,1321 sender.clone(),1322 recipient.clone(),1323 value,1324 ));13251326 Ok(())1327 }13281329 pub fn approve_internal(1330 sender: &T::CrossAccountId,1331 spender: &T::CrossAccountId,1332 collection: &CollectionHandle<T>,1333 item_id: TokenId,1334 amount: u128,1335 ) -> DispatchResult {1336 Self::token_exists(collection, item_id)?;13371338 1339 let bypasses_limits = collection.limits.owner_can_transfer1340 && Self::is_owner_or_admin_permissions(collection, sender)?;13411342 let allowance_limit = if bypasses_limits {1343 None1344 } else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {1345 Some(amount)1346 } else {1347 fail!(Error::<T>::NoPermission);1348 };13491350 if collection.access == AccessMode::WhiteList {1351 Self::check_white_list(collection, sender)?;1352 Self::check_white_list(collection, spender)?;1353 }13541355 collection.consume_sload()?;1356 let allowance: u128 = amount1357 .checked_add(<Allowances<T>>::get(1358 collection.id,1359 (item_id, sender.as_sub(), spender.as_sub()),1360 ))1361 .ok_or(Error::<T>::NumOverflow)?;1362 if let Some(limit) = allowance_limit {1363 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1364 }1365 collection.consume_sstore()?;1366 <Allowances<T>>::insert(1367 collection.id,1368 (item_id, sender.as_sub(), spender.as_sub()),1369 allowance,1370 );13711372 if matches!(collection.mode, CollectionMode::NFT) {1373 1374 collection.log(ERC721Events::Approval {1375 owner: *sender.as_eth(),1376 approved: *spender.as_eth(),1377 token_id: item_id.into(),1378 })?;1379 }13801381 if matches!(collection.mode, CollectionMode::Fungible(_)) {1382 1383 collection.log(ERC20Events::Approval {1384 owner: *sender.as_eth(),1385 spender: *spender.as_eth(),1386 value: allowance.into(),1387 })?;1388 }13891390 Self::deposit_event(RawEvent::Approved(1391 collection.id,1392 item_id,1393 sender.clone(),1394 spender.clone(),1395 allowance,1396 ));1397 Ok(())1398 }13991400 pub fn transfer_from_internal(1401 sender: &T::CrossAccountId,1402 from: &T::CrossAccountId,1403 recipient: &T::CrossAccountId,1404 collection: &CollectionHandle<T>,1405 item_id: TokenId,1406 amount: u128,1407 ) -> DispatchResult {1408 if sender == from {1409 1410 return Self::transfer_internal(from, recipient, collection, item_id, amount);1411 }14121413 1414 collection.consume_sload()?;1415 let approval: u128 =1416 <Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14171418 1419 Self::is_correct_transfer(collection, recipient)?;14201421 1422 ensure!(1423 approval >= amount1424 || (collection.limits.owner_can_transfer1425 && Self::is_owner_or_admin_permissions(collection, sender)?),1426 Error::<T>::NoPermission1427 );14281429 if collection.access == AccessMode::WhiteList {1430 Self::check_white_list(collection, sender)?;1431 Self::check_white_list(collection, recipient)?;1432 }14331434 1435 let allowance = approval.saturating_sub(amount);1436 collection.consume_sstore()?;1437 if allowance > 0 {1438 <Allowances<T>>::insert(1439 collection.id,1440 (item_id, from.as_sub(), sender.as_sub()),1441 allowance,1442 );1443 } else {1444 <Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1445 }14461447 match collection.mode {1448 CollectionMode::NFT => {1449 Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1450 }1451 CollectionMode::Fungible(_) => {1452 Self::transfer_fungible(collection, amount, from, recipient)?1453 }1454 CollectionMode::ReFungible => Self::transfer_refungible(1455 collection,1456 item_id,1457 amount,1458 from.clone(),1459 recipient.clone(),1460 )?,1461 _ => (),1462 };14631464 if matches!(collection.mode, CollectionMode::Fungible(_)) {1465 collection.log(ERC20Events::Approval {1466 owner: *from.as_eth(),1467 spender: *sender.as_eth(),1468 value: allowance.into(),1469 })?;1470 }14711472 Ok(())1473 }14741475 pub fn set_variable_meta_data_internal(1476 sender: &T::CrossAccountId,1477 collection: &CollectionHandle<T>,1478 item_id: TokenId,1479 data: Vec<u8>,1480 ) -> DispatchResult {1481 Self::token_exists(collection, item_id)?;14821483 ensure!(1484 CUSTOM_DATA_LIMIT >= data.len() as u32,1485 Error::<T>::TokenVariableDataLimitExceeded1486 );14871488 1489 ensure!(1490 Self::is_item_owner(sender, collection, item_id)?1491 || Self::is_owner_or_admin_permissions(collection, sender)?,1492 Error::<T>::NoPermission1493 );14941495 match collection.mode {1496 CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1497 CollectionMode::ReFungible => {1498 Self::set_re_fungible_variable_data(collection, item_id, data)?1499 }1500 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1501 _ => fail!(Error::<T>::UnexpectedCollectionType),1502 };15031504 Ok(())1505 }15061507 pub fn create_multiple_items_internal(1508 sender: &T::CrossAccountId,1509 collection: &CollectionHandle<T>,1510 owner: &T::CrossAccountId,1511 items_data: Vec<CreateItemData>,1512 ) -> DispatchResult {1513 Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15141515 for data in &items_data {1516 Self::validate_create_item_args(collection, data)?;1517 }1518 for data in &items_data {1519 Self::create_item_no_validation(collection, owner, data.clone())?;1520 }15211522 Ok(())1523 }15241525 pub fn burn_item_internal(1526 sender: &T::CrossAccountId,1527 collection: &CollectionHandle<T>,1528 item_id: TokenId,1529 value: u128,1530 ) -> DispatchResult {1531 ensure!(1532 Self::is_item_owner(sender, collection, item_id)?1533 || (collection.limits.owner_can_transfer1534 && Self::is_owner_or_admin_permissions(collection, sender)?),1535 Error::<T>::NoPermission1536 );15371538 if collection.access == AccessMode::WhiteList {1539 Self::check_white_list(collection, sender)?;1540 }15411542 match collection.mode {1543 CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1544 CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1545 CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1546 _ => (),1547 };15481549 Ok(())1550 }15511552 pub fn toggle_white_list_internal(1553 sender: &T::CrossAccountId,1554 collection: &CollectionHandle<T>,1555 address: &T::CrossAccountId,1556 whitelisted: bool,1557 ) -> DispatchResult {1558 Self::check_owner_or_admin_permissions(collection, sender)?;15591560 if whitelisted {1561 <WhiteList<T>>::insert(collection.id, address.as_sub(), true);1562 } else {1563 <WhiteList<T>>::remove(collection.id, address.as_sub());1564 }15651566 Ok(())1567 }15681569 fn is_correct_transfer(1570 collection: &CollectionHandle<T>,1571 recipient: &T::CrossAccountId,1572 ) -> DispatchResult {1573 let collection_id = collection.id;15741575 1576 collection.consume_sload()?;1577 let account_items: u32 =1578 <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1579 ensure!(1580 collection.limits.account_token_ownership_limit > account_items,1581 Error::<T>::AccountTokenLimitExceeded1582 );15831584 1585 ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);15861587 Ok(())1588 }15891590 fn can_create_items_in_collection(1591 collection: &CollectionHandle<T>,1592 sender: &T::CrossAccountId,1593 owner: &T::CrossAccountId,1594 amount: u32,1595 ) -> DispatchResult {1596 let collection_id = collection.id;15971598 1599 let total_items: u32 = ItemListIndex::get(collection_id)1600 .checked_add(amount)1601 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1602 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1603 as u32)1604 .checked_add(amount)1605 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1606 ensure!(1607 collection.limits.token_limit >= total_items,1608 Error::<T>::CollectionTokenLimitExceeded1609 );1610 ensure!(1611 collection.limits.account_token_ownership_limit >= account_items,1612 Error::<T>::AccountTokenLimitExceeded1613 );16141615 if !Self::is_owner_or_admin_permissions(collection, sender)? {1616 ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1617 Self::check_white_list(collection, owner)?;1618 Self::check_white_list(collection, sender)?;1619 }16201621 Ok(())1622 }16231624 fn validate_create_item_args(1625 target_collection: &CollectionHandle<T>,1626 data: &CreateItemData,1627 ) -> DispatchResult {1628 match target_collection.mode {1629 CollectionMode::NFT => {1630 if !matches!(data, CreateItemData::NFT(_)) {1631 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1632 }1633 }1634 CollectionMode::Fungible(_) => {1635 if !matches!(data, CreateItemData::Fungible(_)) {1636 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1637 }1638 }1639 CollectionMode::ReFungible => {1640 if let CreateItemData::ReFungible(data) = data {1641 1642 ensure!(1643 data.pieces <= MAX_REFUNGIBLE_PIECES,1644 Error::<T>::WrongRefungiblePieces1645 );1646 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1647 } else {1648 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1649 }1650 }1651 _ => {1652 fail!(Error::<T>::UnexpectedCollectionType);1653 }1654 };16551656 Ok(())1657 }16581659 fn create_item_no_validation(1660 collection: &CollectionHandle<T>,1661 owner: &T::CrossAccountId,1662 data: CreateItemData,1663 ) -> DispatchResult {1664 match data {1665 CreateItemData::NFT(data) => {1666 let item = NftItemType {1667 owner: owner.clone(),1668 const_data: data.const_data.into_inner(),1669 variable_data: data.variable_data.into_inner(),1670 };16711672 Self::add_nft_item(collection, item)?;1673 }1674 CreateItemData::Fungible(data) => {1675 Self::add_fungible_item(collection, owner, data.value)?;1676 }1677 CreateItemData::ReFungible(data) => {1678 let owner_list = vec![Ownership {1679 owner: owner.clone(),1680 fraction: data.pieces,1681 }];16821683 let item = ReFungibleItemType {1684 owner: owner_list,1685 const_data: data.const_data.into_inner(),1686 variable_data: data.variable_data.into_inner(),1687 };16881689 Self::add_refungible_item(collection, item)?;1690 }1691 };16921693 Ok(())1694 }16951696 fn add_fungible_item(1697 collection: &CollectionHandle<T>,1698 owner: &T::CrossAccountId,1699 value: u128,1700 ) -> DispatchResult {1701 let collection_id = collection.id;17021703 1704 collection.consume_sload()?;1705 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17061707 1708 let item = FungibleItemType {1709 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1710 };1711 collection.consume_sstore()?;1712 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);17131714 1715 collection.consume_sload()?;1716 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1717 .checked_add(value)1718 .ok_or(Error::<T>::NumOverflow)?;1719 collection.consume_sstore()?;1720 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17211722 collection.log(ERC20Events::Transfer {1723 from: H160::default(),1724 to: *owner.as_eth(),1725 value: value.into(),1726 })?;1727 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1728 Ok(())1729 }17301731 fn add_refungible_item(1732 collection: &CollectionHandle<T>,1733 item: ReFungibleItemType<T::CrossAccountId>,1734 ) -> DispatchResult {1735 let collection_id = collection.id;17361737 let current_index = <ItemListIndex>::get(collection_id)1738 .checked_add(1)1739 .ok_or(Error::<T>::NumOverflow)?;1740 let itemcopy = item.clone();17411742 ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1743 let item_owner = item.owner.first().expect("only one owner is defined");17441745 let value = item_owner.fraction;1746 let owner = item_owner.owner.clone();17471748 Self::add_token_index(collection, current_index, &owner)?;17491750 <ItemListIndex>::insert(collection_id, current_index);1751 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17521753 1754 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1755 .checked_add(value)1756 .ok_or(Error::<T>::NumOverflow)?;1757 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17581759 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1760 Ok(())1761 }17621763 fn add_nft_item(1764 collection: &CollectionHandle<T>,1765 item: NftItemType<T::CrossAccountId>,1766 ) -> DispatchResult {1767 let collection_id = collection.id;17681769 let current_index = <ItemListIndex>::get(collection_id)1770 .checked_add(1)1771 .ok_or(Error::<T>::NumOverflow)?;17721773 let item_owner = item.owner.clone();1774 Self::add_token_index(collection, current_index, &item.owner)?;17751776 <ItemListIndex>::insert(collection_id, current_index);1777 <NftItemList<T>>::insert(collection_id, current_index, item);17781779 1780 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1781 .checked_add(1)1782 .ok_or(Error::<T>::NumOverflow)?;1783 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);17841785 collection.log(ERC721Events::Transfer {1786 from: H160::default(),1787 to: *item_owner.as_eth(),1788 token_id: current_index.into(),1789 })?;1790 Self::deposit_event(RawEvent::ItemCreated(1791 collection_id,1792 current_index,1793 item_owner,1794 ));1795 Ok(())1796 }17971798 fn burn_refungible_item(1799 collection: &CollectionHandle<T>,1800 item_id: TokenId,1801 owner: &T::CrossAccountId,1802 ) -> DispatchResult {1803 let collection_id = collection.id;18041805 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1806 .ok_or(Error::<T>::TokenNotFound)?;1807 let rft_balance = token1808 .owner1809 .iter()1810 .find(|&i| i.owner == *owner)1811 .ok_or(Error::<T>::TokenNotFound)?;1812 Self::remove_token_index(collection, item_id, owner)?;18131814 1815 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1816 .checked_sub(rft_balance.fraction)1817 .ok_or(Error::<T>::NumOverflow)?;1818 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);18191820 1821 let index = token1822 .owner1823 .iter()1824 .position(|i| i.owner == *owner)1825 .expect("owned item is exists");1826 token.owner.remove(index);1827 let owner_count = token.owner.len();18281829 1830 if owner_count == 0 {1831 <ReFungibleItemList<T>>::remove(collection_id, item_id);1832 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);1833 } else {1834 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1835 }18361837 Ok(())1838 }18391840 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1841 let collection_id = collection.id;18421843 let item =1844 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1845 Self::remove_token_index(collection, item_id, &item.owner)?;18461847 1848 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1849 .checked_sub(1)1850 .ok_or(Error::<T>::NumOverflow)?;1851 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1852 <NftItemList<T>>::remove(collection_id, item_id);1853 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);18541855 collection.log(ERC721Events::Transfer {1856 from: *item.owner.as_eth(),1857 to: H160::default(),1858 token_id: item_id.into(),1859 })?;1860 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1861 Ok(())1862 }18631864 fn burn_fungible_item(1865 owner: &T::CrossAccountId,1866 collection: &CollectionHandle<T>,1867 value: u128,1868 ) -> DispatchResult {1869 let collection_id = collection.id;18701871 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1872 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);18731874 1875 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1876 .checked_sub(value)1877 .ok_or(Error::<T>::NumOverflow)?;1878 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18791880 if balance.value - value > 0 {1881 balance.value -= value;1882 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1883 } else {1884 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());1885 }18861887 collection.log(ERC20Events::Transfer {1888 from: *owner.as_eth(),1889 to: H160::default(),1890 value: value.into(),1891 })?;1892 Ok(())1893 }18941895 pub fn get_collection(1896 collection_id: CollectionId,1897 ) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1898 Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1899 }19001901 fn check_owner_permissions(1902 target_collection: &CollectionHandle<T>,1903 subject: &T::AccountId,1904 ) -> DispatchResult {1905 ensure!(1906 *subject == target_collection.owner,1907 Error::<T>::NoPermission1908 );19091910 Ok(())1911 }19121913 fn is_owner_or_admin_permissions(1914 collection: &CollectionHandle<T>,1915 subject: &T::CrossAccountId,1916 ) -> Result<bool, DispatchError> {1917 collection.consume_sload()?;1918 Ok(*subject.as_sub() == collection.owner1919 || <AdminList<T>>::get(collection.id).contains(subject))1920 }19211922 fn check_owner_or_admin_permissions(1923 collection: &CollectionHandle<T>,1924 subject: &T::CrossAccountId,1925 ) -> DispatchResult {1926 ensure!(1927 Self::is_owner_or_admin_permissions(collection, subject)?,1928 Error::<T>::NoPermission1929 );19301931 Ok(())1932 }19331934 fn owned_amount(1935 subject: &T::CrossAccountId,1936 collection: &CollectionHandle<T>,1937 item_id: TokenId,1938 ) -> Result<Option<u128>, DispatchError> {1939 collection.consume_sload()?;1940 Ok(Self::owned_amount_unchecked(subject, collection, item_id))1941 }19421943 fn owned_amount_unchecked(1944 subject: &T::CrossAccountId,1945 target_collection: &CollectionHandle<T>,1946 item_id: TokenId,1947 ) -> Option<u128> {1948 let collection_id = target_collection.id;19491950 match target_collection.mode {1951 CollectionMode::NFT => {1952 (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)1953 }1954 CollectionMode::Fungible(_) => {1955 Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)1956 }1957 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?1958 .owner1959 .iter()1960 .find(|i| i.owner == *subject)1961 .map(|i| i.fraction),1962 CollectionMode::Invalid => None,1963 }1964 }19651966 fn is_item_owner(1967 subject: &T::CrossAccountId,1968 target_collection: &CollectionHandle<T>,1969 item_id: TokenId,1970 ) -> Result<bool, DispatchError> {1971 Ok(match target_collection.mode {1972 CollectionMode::Fungible(_) => true,1973 _ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),1974 })1975 }19761977 fn check_white_list(1978 collection: &CollectionHandle<T>,1979 address: &T::CrossAccountId,1980 ) -> DispatchResult {1981 collection.consume_sload()?;1982 ensure!(1983 <WhiteList<T>>::contains_key(collection.id, address.as_sub()),1984 Error::<T>::AddresNotInWhiteList,1985 );1986 Ok(())1987 }19881989 1990 1991 fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1992 let collection_id = target_collection.id;1993 let exists = match target_collection.mode {1994 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),1995 CollectionMode::Fungible(_) => true,1996 CollectionMode::ReFungible => {1997 <ReFungibleItemList<T>>::contains_key(collection_id, item_id)1998 }1999 _ => false,2000 };20012002 ensure!(exists, Error::<T>::TokenNotFound);2003 Ok(())2004 }20052006 fn transfer_fungible(2007 collection: &CollectionHandle<T>,2008 value: u128,2009 owner: &T::CrossAccountId,2010 recipient: &T::CrossAccountId,2011 ) -> DispatchResult {2012 let collection_id = collection.id;20132014 collection.consume_sload()?;2015 collection.consume_sload()?;2016 let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2017 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());20182019 recipient_balance.value = recipient_balance2020 .value2021 .checked_add(value)2022 .ok_or(Error::<T>::NumOverflow)?;2023 balance.value = balance2024 .value2025 .checked_sub(value)2026 .ok_or(Error::<T>::TokenValueTooLow)?;20272028 2029 collection.consume_sstore()?;2030 collection.consume_sstore()?;2031 if balance.value != 0 {2032 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2033 } else {2034 <Balance<T>>::remove(collection_id, owner.as_sub());2035 }2036 <Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);20372038 2039 collection.consume_sstore()?;2040 collection.consume_sstore()?;2041 if balance.value != 0 {2042 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2043 } else {2044 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2045 }2046 <FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);20472048 collection.log(ERC20Events::Transfer {2049 from: *owner.as_eth(),2050 to: *recipient.as_eth(),2051 value: value.into(),2052 })?;2053 Self::deposit_event(RawEvent::Transfer(2054 collection.id,2055 1,2056 owner.clone(),2057 recipient.clone(),2058 value,2059 ));20602061 Ok(())2062 }20632064 fn transfer_refungible(2065 collection: &CollectionHandle<T>,2066 item_id: TokenId,2067 value: u128,2068 owner: T::CrossAccountId,2069 new_owner: T::CrossAccountId,2070 ) -> DispatchResult {2071 let collection_id = collection.id;2072 collection.consume_sload()?;2073 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2074 .ok_or(Error::<T>::TokenNotFound)?;20752076 let item = full_item2077 .owner2078 .iter()2079 .find(|i| i.owner == owner)2080 .ok_or(Error::<T>::TokenNotFound)?;2081 let amount = item.fraction;20822083 ensure!(amount >= value, Error::<T>::TokenValueTooLow);20842085 collection.consume_sload()?;2086 2087 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2088 .checked_sub(value)2089 .ok_or(Error::<T>::NumOverflow)?;2090 collection.consume_sstore()?;2091 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);20922093 collection.consume_sload()?;2094 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2095 .checked_add(value)2096 .ok_or(Error::<T>::NumOverflow)?;2097 collection.consume_sstore()?;2098 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);20992100 let old_owner = item.owner.clone();2101 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21022103 let mut new_full_item = full_item.clone();2104 2105 if amount == value && !new_owner_has_account {2106 2107 2108 new_full_item2109 .owner2110 .iter_mut()2111 .find(|i| i.owner == owner)2112 .expect("old owner does present in refungible")2113 .owner = new_owner.clone();2114 collection.consume_sstore()?;2115 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);21162117 2118 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2119 } else {2120 new_full_item2121 .owner2122 .iter_mut()2123 .find(|i| i.owner == owner)2124 .expect("old owner does present in refungible")2125 .fraction -= value;21262127 2128 if new_owner_has_account {2129 2130 new_full_item2131 .owner2132 .iter_mut()2133 .find(|i| i.owner == new_owner)2134 .expect("new owner has account")2135 .fraction += value;2136 } else {2137 2138 new_full_item.owner.push(Ownership {2139 owner: new_owner.clone(),2140 fraction: value,2141 });2142 Self::add_token_index(collection, item_id, &new_owner)?;2143 }21442145 collection.consume_sstore()?;2146 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2147 }21482149 Self::deposit_event(RawEvent::Transfer(2150 collection.id,2151 item_id,2152 owner,2153 new_owner,2154 amount,2155 ));21562157 Ok(())2158 }21592160 fn transfer_nft(2161 collection: &CollectionHandle<T>,2162 item_id: TokenId,2163 sender: T::CrossAccountId,2164 new_owner: T::CrossAccountId,2165 ) -> DispatchResult {2166 let collection_id = collection.id;2167 collection.consume_sload()?;2168 let mut item =2169 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;21702171 ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);21722173 collection.consume_sload()?;2174 2175 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2176 .checked_sub(1)2177 .ok_or(Error::<T>::NumOverflow)?;2178 collection.consume_sstore()?;2179 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21802181 collection.consume_sload()?;2182 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2183 .checked_add(1)2184 .ok_or(Error::<T>::NumOverflow)?;2185 collection.consume_sstore()?;2186 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21872188 2189 let old_owner = item.owner.clone();2190 item.owner = new_owner.clone();2191 collection.consume_sstore()?;2192 <NftItemList<T>>::insert(collection_id, item_id, item);21932194 2195 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;21962197 collection.log(ERC721Events::Transfer {2198 from: *sender.as_eth(),2199 to: *new_owner.as_eth(),2200 token_id: item_id.into(),2201 })?;2202 Self::deposit_event(RawEvent::Transfer(2203 collection.id,2204 item_id,2205 sender,2206 new_owner,2207 1,2208 ));22092210 Ok(())2211 }22122213 fn set_re_fungible_variable_data(2214 collection: &CollectionHandle<T>,2215 item_id: TokenId,2216 data: Vec<u8>,2217 ) -> DispatchResult {2218 let collection_id = collection.id;2219 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2220 .ok_or(Error::<T>::TokenNotFound)?;22212222 item.variable_data = data;22232224 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);22252226 Ok(())2227 }22282229 fn set_nft_variable_data(2230 collection: &CollectionHandle<T>,2231 item_id: TokenId,2232 data: Vec<u8>,2233 ) -> DispatchResult {2234 let collection_id = collection.id;2235 let mut item =2236 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22372238 item.variable_data = data;22392240 <NftItemList<T>>::insert(collection_id, item_id, item);22412242 Ok(())2243 }22442245 #[allow(dead_code)]2246 fn init_collection(item: &Collection<T>) {2247 2248 assert!(2249 item.decimal_points <= MAX_DECIMAL_POINTS,2250 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2251 );2252 assert!(2253 item.name.len() <= 64,2254 "Collection name can not be longer than 63 char"2255 );2256 assert!(2257 item.name.len() <= 256,2258 "Collection description can not be longer than 255 char"2259 );2260 assert!(2261 item.token_prefix.len() <= 16,2262 "Token prefix can not be longer than 15 char"2263 );22642265 2266 let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();22672268 CreatedCollectionCount::put(next_id);2269 }22702271 #[allow(dead_code)]2272 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2273 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22742275 Self::add_token_index(2276 &CollectionHandle::get(collection_id).unwrap(),2277 current_index,2278 &item.owner,2279 )2280 .unwrap();22812282 <ItemListIndex>::insert(collection_id, current_index);22832284 2285 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2286 .checked_add(1)2287 .unwrap();2288 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2289 }22902291 #[allow(dead_code)]2292 fn init_fungible_token(2293 collection_id: CollectionId,2294 owner: &T::CrossAccountId,2295 item: &FungibleItemType,2296 ) {2297 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22982299 Self::add_token_index(2300 &CollectionHandle::get(collection_id).unwrap(),2301 current_index,2302 owner,2303 )2304 .unwrap();23052306 <ItemListIndex>::insert(collection_id, current_index);23072308 2309 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2310 .checked_add(item.value)2311 .unwrap();2312 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2313 }23142315 #[allow(dead_code)]2316 fn init_refungible_token(2317 collection_id: CollectionId,2318 item: &ReFungibleItemType<T::CrossAccountId>,2319 ) {2320 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23212322 let value = item.owner.first().unwrap().fraction;2323 let owner = item.owner.first().unwrap().owner.clone();23242325 Self::add_token_index(2326 &CollectionHandle::get(collection_id).unwrap(),2327 current_index,2328 &owner,2329 )2330 .unwrap();23312332 <ItemListIndex>::insert(collection_id, current_index);23332334 2335 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2336 .checked_add(value)2337 .unwrap();2338 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2339 }23402341 fn add_token_index(2342 collection: &CollectionHandle<T>,2343 item_index: TokenId,2344 owner: &T::CrossAccountId,2345 ) -> DispatchResult {2346 2347 collection.consume_sload()?;2348 if <AccountItemCount<T>>::contains_key(owner.as_sub()) {2349 2350 collection.consume_sload()?;2351 let count = <AccountItemCount<T>>::get(owner.as_sub());2352 ensure!(2353 count < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2354 Error::<T>::AddressOwnershipLimitExceeded2355 );23562357 collection.consume_sstore()?;2358 <AccountItemCount<T>>::insert(2359 owner.as_sub(),2360 count.checked_add(1).ok_or(Error::<T>::NumOverflow)?,2361 );2362 } else {2363 collection.consume_sstore()?;2364 <AccountItemCount<T>>::insert(owner.as_sub(), 1);2365 }23662367 collection.consume_sload()?;2368 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2369 if list_exists {2370 collection.consume_sload()?;2371 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2372 let item_contains = list.contains(&item_index.clone());23732374 if !item_contains {2375 list.push(item_index);2376 }23772378 collection.consume_sstore()?;2379 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2380 } else {2381 let itm = vec![item_index];2382 collection.consume_sstore()?;2383 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2384 }23852386 Ok(())2387 }23882389 fn remove_token_index(2390 collection: &CollectionHandle<T>,2391 item_index: TokenId,2392 owner: &T::CrossAccountId,2393 ) -> DispatchResult {2394 2395 collection.consume_sload()?;2396 collection.consume_sstore()?;2397 <AccountItemCount<T>>::insert(2398 owner.as_sub(),2399 <AccountItemCount<T>>::get(owner.as_sub())2400 .checked_sub(1)2401 .ok_or(Error::<T>::NumOverflow)?,2402 );24032404 collection.consume_sload()?;2405 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2406 if list_exists {2407 collection.consume_sload()?;2408 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2409 let item_contains = list.contains(&item_index.clone());24102411 if item_contains {2412 list.retain(|&item| item != item_index);2413 collection.consume_sstore()?;2414 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2415 }2416 }24172418 Ok(())2419 }24202421 fn move_token_index(2422 collection: &CollectionHandle<T>,2423 item_index: TokenId,2424 old_owner: &T::CrossAccountId,2425 new_owner: &T::CrossAccountId,2426 ) -> DispatchResult {2427 Self::remove_token_index(collection, item_index, old_owner)?;2428 Self::add_token_index(collection, item_index, new_owner)?;24292430 Ok(())2431 }2432}24332434sp_api::decl_runtime_apis! {2435 pub trait NftApi {2436 2437 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2438 }2439}