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 306307 308 309 310 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;311 312 313 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;314 315 316 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;317 318319 320 321 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;322323 324 325 326 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;327328 329 330 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;331 332 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;333 334 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;335 336337 338 339 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;340 341342 343 344 345 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;346 347 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;348 349 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;350 351 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;352 353354 355 356 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;357 }358 add_extra_genesis {359 build(|config: &GenesisConfig<T>| {360 361 for (_num, _c) in &config.collection_id {362 <Module<T>>::init_collection(_c);363 }364365 for (_num, _c, _i) in &config.nft_item_id {366 <Module<T>>::init_nft_token(*_c, _i);367 }368369 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {370 <Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);371 }372373 for (_num, _c, _i) in &config.refungible_item_id {374 <Module<T>>::init_refungible_token(*_c, _i);375 }376 })377 }378}379380decl_event!(381 pub enum Event<T>382 where383 AccountId = <T as frame_system::Config>::AccountId,384 CrossAccountId = <T as Config>::CrossAccountId,385 {386 387 388 389 390 391 392 393 394 395 CollectionCreated(CollectionId, u8, AccountId),396397 398 399 400 401 402 403 404 405 406 ItemCreated(CollectionId, TokenId, CrossAccountId),407408 409 410 411 412 413 414 415 ItemDestroyed(CollectionId, TokenId),416417 418 419 420 421 422 423 424 425 426 427 428 Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),429430 431 432 433 434 435 436 437 438 439 Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),440 }441);442443decl_module! {444 pub struct Module<T: Config> for enum Call445 where446 origin: T::Origin447 {448 fn deposit_event() = default;449 const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;450 type Error = Error<T>;451452 fn on_initialize(_now: T::BlockNumber) -> Weight {453 0454 }455456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 #[weight = <SelfWeightOf<T>>::create_collection()]473 #[transactional]474 pub fn create_collection(origin,475 collection_name: Vec<u16>,476 collection_description: Vec<u16>,477 token_prefix: Vec<u8>,478 mode: CollectionMode) -> DispatchResult {479480 481 let who = ensure_signed(origin)?;482483 484 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();485 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(486 &T::TreasuryAccountId::get(),487 T::CollectionCreationPrice::get(),488 ));489 <T as Config>::Currency::settle(490 &who,491 imbalance,492 WithdrawReasons::TRANSFER,493 ExistenceRequirement::KeepAlive,494 ).map_err(|_| Error::<T>::NoPermission)?;495496 let decimal_points = match mode {497 CollectionMode::Fungible(points) => points,498 _ => 0499 };500501 let created_count = CreatedCollectionCount::get();502 let destroyed_count = DestroyedCollectionCount::get();503504 505 ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);506507 508 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);509 ensure!(collection_name.len() <= MAX_COLLECTION_NAME_LENGTH, Error::<T>::CollectionNameLimitExceeded);510 ensure!(collection_description.len() <= MAX_COLLECTION_DESCRIPTION_LENGTH, Error::<T>::CollectionDescriptionLimitExceeded);511 ensure!(token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH, Error::<T>::CollectionTokenPrefixLimitExceeded);512513 514 let next_id = created_count515 .checked_add(1)516 .ok_or(Error::<T>::NumOverflow)?;517518 CreatedCollectionCount::put(next_id);519520 let limits = CollectionLimits {521 sponsored_data_size: CUSTOM_DATA_LIMIT,522 ..Default::default()523 };524525 526 let new_collection = Collection {527 owner: who.clone(),528 name: collection_name,529 mode: mode.clone(),530 mint_mode: false,531 access: AccessMode::Normal,532 description: collection_description,533 decimal_points,534 token_prefix,535 offchain_schema: Vec::new(),536 schema_version: SchemaVersion::ImageURL,537 sponsorship: SponsorshipState::Disabled,538 variable_on_chain_schema: Vec::new(),539 const_on_chain_schema: Vec::new(),540 limits,541 transfers_enabled: true,542 };543544 545 <CollectionById<T>>::insert(next_id, new_collection);546547 548 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));549550 Ok(())551 }552553 554 555 556 557 558 559 560 561 562 #[weight = <SelfWeightOf<T>>::destroy_collection()]563 #[transactional]564 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {565566 let sender = ensure_signed(origin)?;567 let collection = Self::get_collection(collection_id)?;568 Self::check_owner_permissions(&collection, &sender)?;569 if !collection.limits.owner_can_destroy {570 fail!(Error::<T>::NoPermission);571 }572573 <AddressTokens<T>>::remove_prefix(collection_id, None);574 <Allowances<T>>::remove_prefix(collection_id, None);575 <Balance<T>>::remove_prefix(collection_id, None);576 <ItemListIndex>::remove(collection_id);577 <AdminList<T>>::remove(collection_id);578 <CollectionById<T>>::remove(collection_id);579 <WhiteList<T>>::remove_prefix(collection_id, None);580581 <NftItemList<T>>::remove_prefix(collection_id, None);582 <FungibleItemList<T>>::remove_prefix(collection_id, None);583 <ReFungibleItemList<T>>::remove_prefix(collection_id, None);584585 <NftTransferBasket<T>>::remove_prefix(collection_id, None);586 <FungibleTransferBasket<T>>::remove_prefix(collection_id, None);587 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);588589 <VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);590591 DestroyedCollectionCount::put(DestroyedCollectionCount::get()592 .checked_add(1)593 .ok_or(Error::<T>::NumOverflow)?);594595 Ok(())596 }597598 599 600 601 602 603 604 605 606 607 608 609 610 #[weight = <SelfWeightOf<T>>::add_to_white_list()]611 #[transactional]612 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{613614 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);615 let collection = Self::get_collection(collection_id)?;616617 Self::toggle_white_list_internal(618 &sender,619 &collection,620 &address,621 true,622 )?;623624 Ok(())625 }626627 628 629 630 631 632 633 634 635 636 637 638 639 #[weight = <SelfWeightOf<T>>::remove_from_white_list()]640 #[transactional]641 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{642643 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);644 let collection = Self::get_collection(collection_id)?;645646 Self::toggle_white_list_internal(647 &sender,648 &collection,649 &address,650 false,651 )?;652653 Ok(())654 }655656 657 658 659 660 661 662 663 664 665 666 667 #[weight = <SelfWeightOf<T>>::set_public_access_mode()]668 #[transactional]669 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult670 {671 let sender = ensure_signed(origin)?;672673 let mut target_collection = Self::get_collection(collection_id)?;674 Self::check_owner_permissions(&target_collection, &sender)?;675 target_collection.access = mode;676 target_collection.save()677 }678679 680 681 682 683 684 685 686 687 688 689 690 691 692 #[weight = <SelfWeightOf<T>>::set_mint_permission()]693 #[transactional]694 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult695 {696 let sender = ensure_signed(origin)?;697698 let mut target_collection = Self::get_collection(collection_id)?;699 Self::check_owner_permissions(&target_collection, &sender)?;700 target_collection.mint_mode = mint_permission;701 target_collection.save()702 }703704 705 706 707 708 709 710 711 712 713 714 715 #[weight = <SelfWeightOf<T>>::change_collection_owner()]716 #[transactional]717 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {718719 let sender = ensure_signed(origin)?;720 let mut target_collection = Self::get_collection(collection_id)?;721 Self::check_owner_permissions(&target_collection, &sender)?;722 target_collection.owner = new_owner;723 target_collection.save()724 }725726 727 728 729 730 731 732 733 734 735 736 737 738 739 #[weight = <SelfWeightOf<T>>::add_collection_admin()]740 #[transactional]741 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {742 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);743 let collection = Self::get_collection(collection_id)?;744 Self::check_owner_or_admin_permissions(&collection, &sender)?;745 let mut admin_arr = <AdminList<T>>::get(collection_id);746747 match admin_arr.binary_search(&new_admin_id) {748 Ok(_) => {},749 Err(idx) => {750 ensure!(admin_arr.len() < COLLECTION_ADMINS_LIMIT as usize, Error::<T>::CollectionAdminsLimitExceeded);751 admin_arr.insert(idx, new_admin_id);752 <AdminList<T>>::insert(collection_id, admin_arr);753 }754 }755 Ok(())756 }757758 759 760 761 762 763 764 765 766 767 768 769 770 #[weight = <SelfWeightOf<T>>::remove_collection_admin()]771 #[transactional]772 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {773 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);774 let collection = Self::get_collection(collection_id)?;775 Self::check_owner_or_admin_permissions(&collection, &sender)?;776 let mut admin_arr = <AdminList<T>>::get(collection_id);777778 if let Ok(idx) = admin_arr.binary_search(&account_id) {779 admin_arr.remove(idx);780 <AdminList<T>>::insert(collection_id, admin_arr);781 }782 Ok(())783 }784785 786 787 788 789 790 791 792 793 794 #[weight = <SelfWeightOf<T>>::set_collection_sponsor()]795 #[transactional]796 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {797 let sender = ensure_signed(origin)?;798 let mut target_collection = Self::get_collection(collection_id)?;799 Self::check_owner_permissions(&target_collection, &sender)?;800801 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);802 target_collection.save()803 }804805 806 807 808 809 810 811 812 #[weight = <SelfWeightOf<T>>::confirm_sponsorship()]813 #[transactional]814 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {815 let sender = ensure_signed(origin)?;816817 let mut target_collection = Self::get_collection(collection_id)?;818 ensure!(819 target_collection.sponsorship.pending_sponsor() == Some(&sender),820 Error::<T>::ConfirmUnsetSponsorFail821 );822823 target_collection.sponsorship = SponsorshipState::Confirmed(sender);824 target_collection.save()825 }826827 828 829 830 831 832 833 834 835 836 #[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]837 #[transactional]838 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {839 let sender = ensure_signed(origin)?;840841 let mut target_collection = Self::get_collection(collection_id)?;842 Self::check_owner_permissions(&target_collection, &sender)?;843844 target_collection.sponsorship = SponsorshipState::Disabled;845 target_collection.save()846 }847848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871872 #[weight = <SelfWeightOf<T>>::create_item(data.data_size() as u32)]873 #[transactional]874 pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {875 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);876 let collection = Self::get_collection(collection_id)?;877878 Self::create_item_internal(&sender, &collection, &owner, data)?;879880 collection.submit_logs()881 }882883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 #[weight = <SelfWeightOf<T>>::create_multiple_items(items_data.len() as u32)]902 #[transactional]903 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {904905 ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);906 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);907 let collection = Self::get_collection(collection_id)?;908909 Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;910911 collection.submit_logs()912 }913914 915916 917 918 919 920 921 922 923 924 925 926 927 #[weight = <SelfWeightOf<T>>::set_transfers_enabled_flag()]928 #[transactional]929 pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {930931 let sender = ensure_signed(origin)?;932 let mut target_collection = Self::get_collection(collection_id)?;933934 Self::check_owner_permissions(&target_collection, &sender)?;935936 target_collection.transfers_enabled = value;937 target_collection.save()938 }939940 941 942 943 944 945 946 947 948 949 950 951 952 953 #[weight = <SelfWeightOf<T>>::burn_item()]954 #[transactional]955 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {956957 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);958 let target_collection = Self::get_collection(collection_id)?;959960 Self::burn_item_internal(&sender, &target_collection, item_id, value)?;961962 target_collection.submit_logs()963 }964965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 #[weight = <SelfWeightOf<T>>::transfer()]989 #[transactional]990 pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {991 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);992 let collection = Self::get_collection(collection_id)?;993994 Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;995996 collection.submit_logs()997 }998999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 #[weight = <SelfWeightOf<T>>::approve()]1015 #[transactional]1016 pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1017 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1018 let collection = Self::get_collection(collection_id)?;10191020 Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10211022 collection.submit_logs()1023 }10241025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 #[weight = <SelfWeightOf<T>>::transfer_from()]1045 #[transactional]1046 pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1047 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1048 let collection = Self::get_collection(collection_id)?;10491050 Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10511052 collection.submit_logs()1053 }1054 1055 1056 1057 1058 10591060 10611062 10631064 1065 10661067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 #[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]1080 #[transactional]1081 pub fn set_variable_meta_data (1082 origin,1083 collection_id: CollectionId,1084 item_id: TokenId,1085 data: Vec<u8>1086 ) -> DispatchResult {1087 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);10881089 let collection = Self::get_collection(collection_id)?;10901091 Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;10921093 Ok(())1094 }10951096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 #[weight = <SelfWeightOf<T>>::set_schema_version()]1111 #[transactional]1112 pub fn set_schema_version(1113 origin,1114 collection_id: CollectionId,1115 version: SchemaVersion1116 ) -> DispatchResult {1117 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1118 let mut target_collection = Self::get_collection(collection_id)?;1119 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1120 target_collection.schema_version = version;1121 target_collection.save()1122 }11231124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 #[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]1137 #[transactional]1138 pub fn set_offchain_schema(1139 origin,1140 collection_id: CollectionId,1141 schema: Vec<u8>1142 ) -> DispatchResult {1143 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1144 let mut target_collection = Self::get_collection(collection_id)?;1145 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11461147 1148 ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");11491150 target_collection.offchain_schema = schema;1151 target_collection.save()1152 }11531154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1167 #[transactional]1168 pub fn set_const_on_chain_schema (1169 origin,1170 collection_id: CollectionId,1171 schema: Vec<u8>1172 ) -> DispatchResult {1173 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1174 let mut target_collection = Self::get_collection(collection_id)?;1175 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11761177 1178 ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");11791180 target_collection.const_on_chain_schema = schema;1181 target_collection.save()1182 }11831184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1197 #[transactional]1198 pub fn set_variable_on_chain_schema (1199 origin,1200 collection_id: CollectionId,1201 schema: Vec<u8>1202 ) -> DispatchResult {1203 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1204 let mut target_collection = Self::get_collection(collection_id)?;1205 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12061207 1208 ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");12091210 target_collection.variable_on_chain_schema = schema;1211 target_collection.save()1212 }12131214 #[weight = <SelfWeightOf<T>>::set_collection_limits()]1215 #[transactional]1216 pub fn set_collection_limits(1217 origin,1218 collection_id: u32,1219 new_limits: CollectionLimits<T::BlockNumber>,1220 ) -> DispatchResult {1221 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1222 let mut target_collection = Self::get_collection(collection_id)?;1223 Self::check_owner_permissions(&target_collection, sender.as_sub())?;1224 let old_limits = &target_collection.limits;12251226 1227 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1228 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1229 new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,1230 Error::<T>::CollectionLimitBoundsExceeded);12311232 1233 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1234 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12351236 ensure!(1237 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1238 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1239 Error::<T>::OwnerPermissionsCantBeReverted,1240 );12411242 target_collection.limits = new_limits;12431244 target_collection.save()1245 }1246 }1247}12481249impl<T: Config> Module<T> {1250 pub fn create_item_internal(1251 sender: &T::CrossAccountId,1252 collection: &CollectionHandle<T>,1253 owner: &T::CrossAccountId,1254 data: CreateItemData,1255 ) -> DispatchResult {1256 ensure!(1257 owner != &T::CrossAccountId::from_eth(H160([0; 20])),1258 Error::<T>::AddressIsZero1259 );12601261 Self::can_create_items_in_collection(collection, sender, owner, 1)?;1262 Self::validate_create_item_args(collection, &data)?;1263 Self::create_item_no_validation(collection, owner, data)?;12641265 Ok(())1266 }12671268 pub fn transfer_internal(1269 sender: &T::CrossAccountId,1270 recipient: &T::CrossAccountId,1271 target_collection: &CollectionHandle<T>,1272 item_id: TokenId,1273 value: u128,1274 ) -> DispatchResult {1275 ensure!(1276 recipient != &T::CrossAccountId::from_eth(H160([0; 20])),1277 Error::<T>::AddressIsZero1278 );12791280 1281 Self::is_correct_transfer(target_collection, recipient)?;12821283 1284 ensure!(1285 Self::is_item_owner(sender, target_collection, item_id)?1286 || Self::is_owner_or_admin_permissions(target_collection, sender)?,1287 Error::<T>::NoPermission1288 );12891290 if target_collection.access == AccessMode::WhiteList {1291 Self::check_white_list(target_collection, sender)?;1292 Self::check_white_list(target_collection, recipient)?;1293 }12941295 match target_collection.mode {1296 CollectionMode::NFT => Self::transfer_nft(1297 target_collection,1298 item_id,1299 sender.clone(),1300 recipient.clone(),1301 )?,1302 CollectionMode::Fungible(_) => {1303 Self::transfer_fungible(target_collection, value, sender, recipient)?1304 }1305 CollectionMode::ReFungible => Self::transfer_refungible(1306 target_collection,1307 item_id,1308 value,1309 sender.clone(),1310 recipient.clone(),1311 )?,1312 _ => (),1313 };13141315 Self::deposit_event(RawEvent::Transfer(1316 target_collection.id,1317 item_id,1318 sender.clone(),1319 recipient.clone(),1320 value,1321 ));13221323 Ok(())1324 }13251326 pub fn approve_internal(1327 sender: &T::CrossAccountId,1328 spender: &T::CrossAccountId,1329 collection: &CollectionHandle<T>,1330 item_id: TokenId,1331 amount: u128,1332 ) -> DispatchResult {1333 Self::token_exists(collection, item_id)?;13341335 1336 let bypasses_limits = collection.limits.owner_can_transfer1337 && Self::is_owner_or_admin_permissions(collection, sender)?;13381339 let allowance_limit = if bypasses_limits {1340 None1341 } else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {1342 Some(amount)1343 } else {1344 fail!(Error::<T>::NoPermission);1345 };13461347 if collection.access == AccessMode::WhiteList {1348 Self::check_white_list(collection, sender)?;1349 Self::check_white_list(collection, spender)?;1350 }13511352 collection.consume_sload()?;1353 let allowance: u128 = amount1354 .checked_add(<Allowances<T>>::get(1355 collection.id,1356 (item_id, sender.as_sub(), spender.as_sub()),1357 ))1358 .ok_or(Error::<T>::NumOverflow)?;1359 if let Some(limit) = allowance_limit {1360 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1361 }1362 collection.consume_sstore()?;1363 <Allowances<T>>::insert(1364 collection.id,1365 (item_id, sender.as_sub(), spender.as_sub()),1366 allowance,1367 );13681369 if matches!(collection.mode, CollectionMode::NFT) {1370 1371 collection.log(ERC721Events::Approval {1372 owner: *sender.as_eth(),1373 approved: *spender.as_eth(),1374 token_id: item_id.into(),1375 })?;1376 }13771378 if matches!(collection.mode, CollectionMode::Fungible(_)) {1379 1380 collection.log(ERC20Events::Approval {1381 owner: *sender.as_eth(),1382 spender: *spender.as_eth(),1383 value: allowance.into(),1384 })?;1385 }13861387 Self::deposit_event(RawEvent::Approved(1388 collection.id,1389 item_id,1390 sender.clone(),1391 spender.clone(),1392 allowance,1393 ));1394 Ok(())1395 }13961397 pub fn transfer_from_internal(1398 sender: &T::CrossAccountId,1399 from: &T::CrossAccountId,1400 recipient: &T::CrossAccountId,1401 collection: &CollectionHandle<T>,1402 item_id: TokenId,1403 amount: u128,1404 ) -> DispatchResult {1405 if sender == from {1406 1407 return Self::transfer_internal(from, recipient, collection, item_id, amount);1408 }14091410 1411 collection.consume_sload()?;1412 let approval: u128 =1413 <Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14141415 1416 Self::is_correct_transfer(collection, recipient)?;14171418 1419 ensure!(1420 approval >= amount1421 || (collection.limits.owner_can_transfer1422 && Self::is_owner_or_admin_permissions(collection, sender)?),1423 Error::<T>::NoPermission1424 );14251426 if collection.access == AccessMode::WhiteList {1427 Self::check_white_list(collection, sender)?;1428 Self::check_white_list(collection, recipient)?;1429 }14301431 1432 let allowance = approval.saturating_sub(amount);1433 collection.consume_sstore()?;1434 if allowance > 0 {1435 <Allowances<T>>::insert(1436 collection.id,1437 (item_id, from.as_sub(), sender.as_sub()),1438 allowance,1439 );1440 } else {1441 <Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1442 }14431444 match collection.mode {1445 CollectionMode::NFT => {1446 Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1447 }1448 CollectionMode::Fungible(_) => {1449 Self::transfer_fungible(collection, amount, from, recipient)?1450 }1451 CollectionMode::ReFungible => Self::transfer_refungible(1452 collection,1453 item_id,1454 amount,1455 from.clone(),1456 recipient.clone(),1457 )?,1458 _ => (),1459 };14601461 if matches!(collection.mode, CollectionMode::Fungible(_)) {1462 collection.log(ERC20Events::Approval {1463 owner: *from.as_eth(),1464 spender: *sender.as_eth(),1465 value: allowance.into(),1466 })?;1467 }14681469 Ok(())1470 }14711472 pub fn set_variable_meta_data_internal(1473 sender: &T::CrossAccountId,1474 collection: &CollectionHandle<T>,1475 item_id: TokenId,1476 data: Vec<u8>,1477 ) -> DispatchResult {1478 Self::token_exists(collection, item_id)?;14791480 ensure!(1481 CUSTOM_DATA_LIMIT >= data.len() as u32,1482 Error::<T>::TokenVariableDataLimitExceeded1483 );14841485 1486 ensure!(1487 Self::is_item_owner(sender, collection, item_id)?1488 || Self::is_owner_or_admin_permissions(collection, sender)?,1489 Error::<T>::NoPermission1490 );14911492 match collection.mode {1493 CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1494 CollectionMode::ReFungible => {1495 Self::set_re_fungible_variable_data(collection, item_id, data)?1496 }1497 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1498 _ => fail!(Error::<T>::UnexpectedCollectionType),1499 };15001501 Ok(())1502 }15031504 pub fn get_variable_metadata(1505 collection: &CollectionHandle<T>,1506 item_id: TokenId,1507 ) -> Result<Vec<u8>, DispatchError> {1508 Ok(match collection.mode {1509 CollectionMode::NFT => {1510 <NftItemList<T>>::get(collection.id, item_id)1511 .ok_or(Error::<T>::TokenNotFound)?1512 .variable_data1513 }1514 CollectionMode::ReFungible => {1515 <ReFungibleItemList<T>>::get(collection.id, item_id)1516 .ok_or(Error::<T>::TokenNotFound)?1517 .variable_data1518 }1519 _ => fail!(Error::<T>::UnexpectedCollectionType),1520 })1521 }15221523 pub fn create_multiple_items_internal(1524 sender: &T::CrossAccountId,1525 collection: &CollectionHandle<T>,1526 owner: &T::CrossAccountId,1527 items_data: Vec<CreateItemData>,1528 ) -> DispatchResult {1529 Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15301531 for data in &items_data {1532 Self::validate_create_item_args(collection, data)?;1533 }1534 for data in &items_data {1535 Self::create_item_no_validation(collection, owner, data.clone())?;1536 }15371538 Ok(())1539 }15401541 pub fn burn_item_internal(1542 sender: &T::CrossAccountId,1543 collection: &CollectionHandle<T>,1544 item_id: TokenId,1545 value: u128,1546 ) -> DispatchResult {1547 ensure!(1548 Self::is_item_owner(sender, collection, item_id)?1549 || (collection.limits.owner_can_transfer1550 && Self::is_owner_or_admin_permissions(collection, sender)?),1551 Error::<T>::NoPermission1552 );15531554 if collection.access == AccessMode::WhiteList {1555 Self::check_white_list(collection, sender)?;1556 }15571558 match collection.mode {1559 CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1560 CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1561 CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1562 _ => (),1563 };15641565 Ok(())1566 }15671568 pub fn toggle_white_list_internal(1569 sender: &T::CrossAccountId,1570 collection: &CollectionHandle<T>,1571 address: &T::CrossAccountId,1572 whitelisted: bool,1573 ) -> DispatchResult {1574 Self::check_owner_or_admin_permissions(collection, sender)?;15751576 if whitelisted {1577 <WhiteList<T>>::insert(collection.id, address.as_sub(), true);1578 } else {1579 <WhiteList<T>>::remove(collection.id, address.as_sub());1580 }15811582 Ok(())1583 }15841585 fn is_correct_transfer(1586 collection: &CollectionHandle<T>,1587 recipient: &T::CrossAccountId,1588 ) -> DispatchResult {1589 let collection_id = collection.id;15901591 1592 collection.consume_sload()?;1593 let account_items: u32 =1594 <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;15951596 1597 1598 let limit = if collection.limits.account_token_ownership_limit == 01599 || collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1600 {1601 ACCOUNT_TOKEN_OWNERSHIP_LIMIT1602 } else {1603 collection.limits.account_token_ownership_limit1604 };16051606 ensure!(limit > account_items, Error::<T>::AccountTokenLimitExceeded);16071608 1609 ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);16101611 Ok(())1612 }16131614 fn can_create_items_in_collection(1615 collection: &CollectionHandle<T>,1616 sender: &T::CrossAccountId,1617 owner: &T::CrossAccountId,1618 amount: u32,1619 ) -> DispatchResult {1620 let collection_id = collection.id;16211622 1623 let total_items: u32 = ItemListIndex::get(collection_id)1624 .checked_add(amount)1625 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1626 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1627 as u32)1628 .checked_add(amount)1629 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;16301631 1632 1633 let account_token_limit = if collection.limits.account_token_ownership_limit == 01634 || collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1635 {1636 ACCOUNT_TOKEN_OWNERSHIP_LIMIT1637 } else {1638 collection.limits.account_token_ownership_limit1639 };16401641 ensure!(1642 collection.limits.token_limit >= total_items,1643 Error::<T>::CollectionTokenLimitExceeded1644 );1645 ensure!(1646 account_token_limit >= account_items,1647 Error::<T>::AccountTokenLimitExceeded1648 );16491650 if !Self::is_owner_or_admin_permissions(collection, sender)? {1651 ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1652 Self::check_white_list(collection, owner)?;1653 Self::check_white_list(collection, sender)?;1654 }16551656 Ok(())1657 }16581659 fn validate_create_item_args(1660 target_collection: &CollectionHandle<T>,1661 data: &CreateItemData,1662 ) -> DispatchResult {1663 match target_collection.mode {1664 CollectionMode::NFT => {1665 if !matches!(data, CreateItemData::NFT(_)) {1666 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1667 }1668 }1669 CollectionMode::Fungible(_) => {1670 if !matches!(data, CreateItemData::Fungible(_)) {1671 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1672 }1673 }1674 CollectionMode::ReFungible => {1675 if let CreateItemData::ReFungible(data) = data {1676 1677 ensure!(1678 data.pieces <= MAX_REFUNGIBLE_PIECES,1679 Error::<T>::WrongRefungiblePieces1680 );1681 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1682 } else {1683 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1684 }1685 }1686 _ => {1687 fail!(Error::<T>::UnexpectedCollectionType);1688 }1689 };16901691 Ok(())1692 }16931694 fn create_item_no_validation(1695 collection: &CollectionHandle<T>,1696 owner: &T::CrossAccountId,1697 data: CreateItemData,1698 ) -> DispatchResult {1699 match data {1700 CreateItemData::NFT(data) => {1701 let item = NftItemType {1702 owner: owner.clone(),1703 const_data: data.const_data.into_inner(),1704 variable_data: data.variable_data.into_inner(),1705 };17061707 Self::add_nft_item(collection, item)?;1708 }1709 CreateItemData::Fungible(data) => {1710 Self::add_fungible_item(collection, owner, data.value)?;1711 }1712 CreateItemData::ReFungible(data) => {1713 let owner_list = vec![Ownership {1714 owner: owner.clone(),1715 fraction: data.pieces,1716 }];17171718 let item = ReFungibleItemType {1719 owner: owner_list,1720 const_data: data.const_data.into_inner(),1721 variable_data: data.variable_data.into_inner(),1722 };17231724 Self::add_refungible_item(collection, item)?;1725 }1726 };17271728 Ok(())1729 }17301731 fn add_fungible_item(1732 collection: &CollectionHandle<T>,1733 owner: &T::CrossAccountId,1734 value: u128,1735 ) -> DispatchResult {1736 let collection_id = collection.id;17371738 1739 collection.consume_sload()?;1740 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17411742 1743 let item = FungibleItemType {1744 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1745 };1746 collection.consume_sstore()?;1747 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);17481749 1750 collection.consume_sload()?;1751 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1752 .checked_add(value)1753 .ok_or(Error::<T>::NumOverflow)?;1754 collection.consume_sstore()?;1755 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17561757 collection.log(ERC20Events::Transfer {1758 from: H160::default(),1759 to: *owner.as_eth(),1760 value: value.into(),1761 })?;1762 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1763 Ok(())1764 }17651766 fn add_refungible_item(1767 collection: &CollectionHandle<T>,1768 item: ReFungibleItemType<T::CrossAccountId>,1769 ) -> DispatchResult {1770 let collection_id = collection.id;17711772 let current_index = <ItemListIndex>::get(collection_id)1773 .checked_add(1)1774 .ok_or(Error::<T>::NumOverflow)?;1775 let itemcopy = item.clone();17761777 ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1778 let item_owner = item.owner.first().expect("only one owner is defined");17791780 let value = item_owner.fraction;1781 let owner = item_owner.owner.clone();17821783 Self::add_token_index(collection, current_index, &owner)?;17841785 <ItemListIndex>::insert(collection_id, current_index);1786 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17871788 1789 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1790 .checked_add(value)1791 .ok_or(Error::<T>::NumOverflow)?;1792 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17931794 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1795 Ok(())1796 }17971798 fn add_nft_item(1799 collection: &CollectionHandle<T>,1800 item: NftItemType<T::CrossAccountId>,1801 ) -> DispatchResult {1802 let collection_id = collection.id;18031804 let current_index = <ItemListIndex>::get(collection_id)1805 .checked_add(1)1806 .ok_or(Error::<T>::NumOverflow)?;18071808 let item_owner = item.owner.clone();1809 Self::add_token_index(collection, current_index, &item.owner)?;18101811 <ItemListIndex>::insert(collection_id, current_index);1812 <NftItemList<T>>::insert(collection_id, current_index, item);18131814 1815 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1816 .checked_add(1)1817 .ok_or(Error::<T>::NumOverflow)?;1818 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);18191820 collection.log(ERC721Events::Transfer {1821 from: H160::default(),1822 to: *item_owner.as_eth(),1823 token_id: current_index.into(),1824 })?;1825 Self::deposit_event(RawEvent::ItemCreated(1826 collection_id,1827 current_index,1828 item_owner,1829 ));1830 Ok(())1831 }18321833 fn burn_refungible_item(1834 collection: &CollectionHandle<T>,1835 item_id: TokenId,1836 owner: &T::CrossAccountId,1837 ) -> DispatchResult {1838 let collection_id = collection.id;18391840 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1841 .ok_or(Error::<T>::TokenNotFound)?;1842 let rft_balance = token1843 .owner1844 .iter()1845 .find(|&i| i.owner == *owner)1846 .ok_or(Error::<T>::TokenNotFound)?;1847 Self::remove_token_index(collection, item_id, owner)?;18481849 1850 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1851 .checked_sub(rft_balance.fraction)1852 .ok_or(Error::<T>::NumOverflow)?;1853 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);18541855 1856 let index = token1857 .owner1858 .iter()1859 .position(|i| i.owner == *owner)1860 .expect("owned item is exists");1861 token.owner.remove(index);1862 let owner_count = token.owner.len();18631864 1865 if owner_count == 0 {1866 <ReFungibleItemList<T>>::remove(collection_id, item_id);1867 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);1868 } else {1869 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1870 }18711872 Ok(())1873 }18741875 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1876 let collection_id = collection.id;18771878 let item =1879 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1880 Self::remove_token_index(collection, item_id, &item.owner)?;18811882 1883 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1884 .checked_sub(1)1885 .ok_or(Error::<T>::NumOverflow)?;1886 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1887 <NftItemList<T>>::remove(collection_id, item_id);1888 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);18891890 collection.log(ERC721Events::Transfer {1891 from: *item.owner.as_eth(),1892 to: H160::default(),1893 token_id: item_id.into(),1894 })?;1895 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1896 Ok(())1897 }18981899 fn burn_fungible_item(1900 owner: &T::CrossAccountId,1901 collection: &CollectionHandle<T>,1902 value: u128,1903 ) -> DispatchResult {1904 let collection_id = collection.id;19051906 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1907 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19081909 1910 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1911 .checked_sub(value)1912 .ok_or(Error::<T>::NumOverflow)?;1913 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19141915 if balance.value - value > 0 {1916 balance.value -= value;1917 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1918 } else {1919 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());1920 }19211922 collection.log(ERC20Events::Transfer {1923 from: *owner.as_eth(),1924 to: H160::default(),1925 value: value.into(),1926 })?;1927 Ok(())1928 }19291930 pub fn get_collection(1931 collection_id: CollectionId,1932 ) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1933 Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1934 }19351936 fn check_owner_permissions(1937 target_collection: &CollectionHandle<T>,1938 subject: &T::AccountId,1939 ) -> DispatchResult {1940 ensure!(1941 *subject == target_collection.owner,1942 Error::<T>::NoPermission1943 );19441945 Ok(())1946 }19471948 fn is_owner_or_admin_permissions(1949 collection: &CollectionHandle<T>,1950 subject: &T::CrossAccountId,1951 ) -> Result<bool, DispatchError> {1952 collection.consume_sload()?;1953 Ok(*subject.as_sub() == collection.owner1954 || <AdminList<T>>::get(collection.id).contains(subject))1955 }19561957 fn check_owner_or_admin_permissions(1958 collection: &CollectionHandle<T>,1959 subject: &T::CrossAccountId,1960 ) -> DispatchResult {1961 ensure!(1962 Self::is_owner_or_admin_permissions(collection, subject)?,1963 Error::<T>::NoPermission1964 );19651966 Ok(())1967 }19681969 fn owned_amount(1970 subject: &T::CrossAccountId,1971 collection: &CollectionHandle<T>,1972 item_id: TokenId,1973 ) -> Result<Option<u128>, DispatchError> {1974 collection.consume_sload()?;1975 Ok(Self::owned_amount_unchecked(subject, collection, item_id))1976 }19771978 fn owned_amount_unchecked(1979 subject: &T::CrossAccountId,1980 target_collection: &CollectionHandle<T>,1981 item_id: TokenId,1982 ) -> Option<u128> {1983 let collection_id = target_collection.id;19841985 match target_collection.mode {1986 CollectionMode::NFT => {1987 (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)1988 }1989 CollectionMode::Fungible(_) => {1990 Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)1991 }1992 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?1993 .owner1994 .iter()1995 .find(|i| i.owner == *subject)1996 .map(|i| i.fraction),1997 CollectionMode::Invalid => None,1998 }1999 }20002001 fn is_item_owner(2002 subject: &T::CrossAccountId,2003 target_collection: &CollectionHandle<T>,2004 item_id: TokenId,2005 ) -> Result<bool, DispatchError> {2006 Ok(match target_collection.mode {2007 CollectionMode::Fungible(_) => true,2008 _ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),2009 })2010 }20112012 fn check_white_list(2013 collection: &CollectionHandle<T>,2014 address: &T::CrossAccountId,2015 ) -> DispatchResult {2016 collection.consume_sload()?;2017 ensure!(2018 <WhiteList<T>>::contains_key(collection.id, address.as_sub()),2019 Error::<T>::AddresNotInWhiteList,2020 );2021 Ok(())2022 }20232024 2025 2026 fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2027 let collection_id = target_collection.id;2028 let exists = match target_collection.mode {2029 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2030 CollectionMode::Fungible(_) => true,2031 CollectionMode::ReFungible => {2032 <ReFungibleItemList<T>>::contains_key(collection_id, item_id)2033 }2034 _ => false,2035 };20362037 ensure!(exists, Error::<T>::TokenNotFound);2038 Ok(())2039 }20402041 fn transfer_fungible(2042 collection: &CollectionHandle<T>,2043 value: u128,2044 owner: &T::CrossAccountId,2045 recipient: &T::CrossAccountId,2046 ) -> DispatchResult {2047 let collection_id = collection.id;20482049 collection.consume_sload()?;2050 collection.consume_sload()?;2051 let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2052 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());20532054 recipient_balance.value = recipient_balance2055 .value2056 .checked_add(value)2057 .ok_or(Error::<T>::NumOverflow)?;2058 balance.value = balance2059 .value2060 .checked_sub(value)2061 .ok_or(Error::<T>::TokenValueTooLow)?;20622063 2064 collection.consume_sstore()?;2065 collection.consume_sstore()?;2066 if balance.value != 0 {2067 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2068 } else {2069 <Balance<T>>::remove(collection_id, owner.as_sub());2070 }2071 <Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);20722073 2074 collection.consume_sstore()?;2075 collection.consume_sstore()?;2076 if balance.value != 0 {2077 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2078 } else {2079 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2080 }2081 <FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);20822083 collection.log(ERC20Events::Transfer {2084 from: *owner.as_eth(),2085 to: *recipient.as_eth(),2086 value: value.into(),2087 })?;2088 Self::deposit_event(RawEvent::Transfer(2089 collection.id,2090 1,2091 owner.clone(),2092 recipient.clone(),2093 value,2094 ));20952096 Ok(())2097 }20982099 fn transfer_refungible(2100 collection: &CollectionHandle<T>,2101 item_id: TokenId,2102 value: u128,2103 owner: T::CrossAccountId,2104 new_owner: T::CrossAccountId,2105 ) -> DispatchResult {2106 let collection_id = collection.id;2107 collection.consume_sload()?;2108 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2109 .ok_or(Error::<T>::TokenNotFound)?;21102111 let item = full_item2112 .owner2113 .iter()2114 .find(|i| i.owner == owner)2115 .ok_or(Error::<T>::TokenNotFound)?;2116 let amount = item.fraction;21172118 ensure!(amount >= value, Error::<T>::TokenValueTooLow);21192120 collection.consume_sload()?;2121 2122 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2123 .checked_sub(value)2124 .ok_or(Error::<T>::NumOverflow)?;2125 collection.consume_sstore()?;2126 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21272128 collection.consume_sload()?;2129 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2130 .checked_add(value)2131 .ok_or(Error::<T>::NumOverflow)?;2132 collection.consume_sstore()?;2133 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21342135 let old_owner = item.owner.clone();2136 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21372138 let mut new_full_item = full_item.clone();2139 2140 if amount == value && !new_owner_has_account {2141 2142 2143 new_full_item2144 .owner2145 .iter_mut()2146 .find(|i| i.owner == owner)2147 .expect("old owner does present in refungible")2148 .owner = new_owner.clone();2149 collection.consume_sstore()?;2150 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);21512152 2153 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2154 } else {2155 new_full_item2156 .owner2157 .iter_mut()2158 .find(|i| i.owner == owner)2159 .expect("old owner does present in refungible")2160 .fraction -= value;21612162 2163 if new_owner_has_account {2164 2165 new_full_item2166 .owner2167 .iter_mut()2168 .find(|i| i.owner == new_owner)2169 .expect("new owner has account")2170 .fraction += value;2171 } else {2172 2173 new_full_item.owner.push(Ownership {2174 owner: new_owner.clone(),2175 fraction: value,2176 });2177 Self::add_token_index(collection, item_id, &new_owner)?;2178 }21792180 collection.consume_sstore()?;2181 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2182 }21832184 Self::deposit_event(RawEvent::Transfer(2185 collection.id,2186 item_id,2187 owner,2188 new_owner,2189 amount,2190 ));21912192 Ok(())2193 }21942195 fn transfer_nft(2196 collection: &CollectionHandle<T>,2197 item_id: TokenId,2198 sender: T::CrossAccountId,2199 new_owner: T::CrossAccountId,2200 ) -> DispatchResult {2201 let collection_id = collection.id;2202 collection.consume_sload()?;2203 let mut item =2204 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22052206 ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);22072208 collection.consume_sload()?;2209 2210 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2211 .checked_sub(1)2212 .ok_or(Error::<T>::NumOverflow)?;2213 collection.consume_sstore()?;2214 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);22152216 collection.consume_sload()?;2217 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2218 .checked_add(1)2219 .ok_or(Error::<T>::NumOverflow)?;2220 collection.consume_sstore()?;2221 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22222223 2224 let old_owner = item.owner.clone();2225 item.owner = new_owner.clone();2226 collection.consume_sstore()?;2227 <NftItemList<T>>::insert(collection_id, item_id, item);22282229 2230 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;22312232 collection.log(ERC721Events::Transfer {2233 from: *sender.as_eth(),2234 to: *new_owner.as_eth(),2235 token_id: item_id.into(),2236 })?;2237 Self::deposit_event(RawEvent::Transfer(2238 collection.id,2239 item_id,2240 sender,2241 new_owner,2242 1,2243 ));22442245 Ok(())2246 }22472248 fn set_re_fungible_variable_data(2249 collection: &CollectionHandle<T>,2250 item_id: TokenId,2251 data: Vec<u8>,2252 ) -> DispatchResult {2253 let collection_id = collection.id;2254 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2255 .ok_or(Error::<T>::TokenNotFound)?;22562257 item.variable_data = data;22582259 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);22602261 Ok(())2262 }22632264 fn set_nft_variable_data(2265 collection: &CollectionHandle<T>,2266 item_id: TokenId,2267 data: Vec<u8>,2268 ) -> DispatchResult {2269 let collection_id = collection.id;2270 let mut item =2271 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22722273 item.variable_data = data;22742275 <NftItemList<T>>::insert(collection_id, item_id, item);22762277 Ok(())2278 }22792280 #[allow(dead_code)]2281 fn init_collection(item: &Collection<T>) {2282 2283 assert!(2284 item.decimal_points <= MAX_DECIMAL_POINTS,2285 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2286 );2287 assert!(2288 item.name.len() <= 64,2289 "Collection name can not be longer than 63 char"2290 );2291 assert!(2292 item.name.len() <= 256,2293 "Collection description can not be longer than 255 char"2294 );2295 assert!(2296 item.token_prefix.len() <= 16,2297 "Token prefix can not be longer than 15 char"2298 );22992300 2301 let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();23022303 CreatedCollectionCount::put(next_id);2304 }23052306 #[allow(dead_code)]2307 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2308 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23092310 Self::add_token_index(2311 &CollectionHandle::get(collection_id).unwrap(),2312 current_index,2313 &item.owner,2314 )2315 .unwrap();23162317 <ItemListIndex>::insert(collection_id, current_index);23182319 2320 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2321 .checked_add(1)2322 .unwrap();2323 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2324 }23252326 #[allow(dead_code)]2327 fn init_fungible_token(2328 collection_id: CollectionId,2329 owner: &T::CrossAccountId,2330 item: &FungibleItemType,2331 ) {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 owner,2338 )2339 .unwrap();23402341 <ItemListIndex>::insert(collection_id, current_index);23422343 2344 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2345 .checked_add(item.value)2346 .unwrap();2347 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2348 }23492350 #[allow(dead_code)]2351 fn init_refungible_token(2352 collection_id: CollectionId,2353 item: &ReFungibleItemType<T::CrossAccountId>,2354 ) {2355 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23562357 let value = item.owner.first().unwrap().fraction;2358 let owner = item.owner.first().unwrap().owner.clone();23592360 Self::add_token_index(2361 &CollectionHandle::get(collection_id).unwrap(),2362 current_index,2363 &owner,2364 )2365 .unwrap();23662367 <ItemListIndex>::insert(collection_id, current_index);23682369 2370 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2371 .checked_add(value)2372 .unwrap();2373 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2374 }23752376 fn add_token_index(2377 collection: &CollectionHandle<T>,2378 item_index: TokenId,2379 owner: &T::CrossAccountId,2380 ) -> DispatchResult {2381 collection.consume_sload()?;2382 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2383 if list_exists {2384 collection.consume_sload()?;2385 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());23862387 2388 let account_items: u32 = list.len() as u32;2389 ensure!(2390 account_items < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2391 Error::<T>::AddressOwnershipLimitExceeded2392 );23932394 let item_contains = list.contains(&item_index.clone());23952396 if !item_contains {2397 list.push(item_index);2398 }23992400 collection.consume_sstore()?;2401 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2402 } else {2403 let itm = vec![item_index];2404 collection.consume_sstore()?;2405 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2406 }24072408 Ok(())2409 }24102411 fn remove_token_index(2412 collection: &CollectionHandle<T>,2413 item_index: TokenId,2414 owner: &T::CrossAccountId,2415 ) -> DispatchResult {2416 collection.consume_sload()?;2417 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2418 if list_exists {2419 collection.consume_sload()?;2420 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2421 let item_contains = list.contains(&item_index.clone());24222423 if item_contains {2424 list.retain(|&item| item != item_index);2425 collection.consume_sstore()?;2426 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2427 }2428 }24292430 Ok(())2431 }24322433 fn move_token_index(2434 collection: &CollectionHandle<T>,2435 item_index: TokenId,2436 old_owner: &T::CrossAccountId,2437 new_owner: &T::CrossAccountId,2438 ) -> DispatchResult {2439 Self::remove_token_index(collection, item_index, old_owner)?;2440 Self::add_token_index(collection, item_index, new_owner)?;24412442 Ok(())2443 }2444}24452446sp_api::decl_runtime_apis! {2447 pub trait NftApi {2448 2449 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2450 }2451}